VectorCraft: An open-source, vector art tool written by scratch in pure Rust
refactor(eps): move import/graphics.rs items to import/graphics/{ops,paint,path,state}.rs
aionggf8fe7075f4cf
diff --git a/crates/eps/src/import/graphics.rs b/crates/eps/src/import/graphics.rsindex 5d4f7b9fa..bd6f25287 100644--- a/crates/eps/src/import/graphics.rs+++ b/crates/eps/src/import/graphics.rs@@ -17,6 +17,14 @@ use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Point, Rect, Vec2};use super::interp::{Interp, MAX_GSAVE, matrix_obj};use super::obj::{DictRef, Key, Obj, Op, PsError, Res, Shared, clamp_between, ps_err};+mod ops;+mod paint;+mod path;+mod state;++pub(crate) use paint::collapse;+pub(crate) use state::{GState, Out, Space, process};+/// Most objects one file makes.const MAX_NODES: usize = 1 << 20;/// Objects reaching further than this from the page (points) come from damaged coordinates and@@ -61,1775 +69,3 @@ const NESTED_PATTERNS: &str = "patterns nested too deeply are filled with mid-grpub(crate) const MAX_APART: u32 = 8;const UNKNOWN_FUNCTIONS: &str = "shadings whose functions are of an unknown type are filled with their middle colour";const UNKNOWN_SHADINGS: &str = "shadings of an unknown type were left out";--/// A colour space.-#[derive(Clone, Debug)]-pub(crate) enum Space {- Gray,- Rgb,- Cmyk,- /// Separation and DeviceN: the ink names, the alternate space and the tint transform.- Inks {- names: Vec<Rc<str>>,- alt: Rc<Space>,- tint: Obj,- },- Indexed {- base: Rc<Space>,- table: Rc<Vec<f64>>,- },- /// Patterns; an uncoloured one paints in a colour of the underlying space.- Pattern(Option<Rc<Space>>),-}--impl Space {- /// Components a colour has in it.- pub fn n(&self) -> usize {- match self {- Self::Gray | Self::Indexed { .. } | Self::Pattern(_) => 1,- Self::Rgb => 3,- Self::Cmyk => 4,- Self::Inks { names, .. } => names.len().max(1),- }- }-- /// The colour `setcolorspace` starts with.- fn initial(&self) -> Vec<f64> {- match self {- Self::Cmyk => vec![0.0, 0.0, 0.0, 1.0],- Self::Inks { names, .. } => vec![1.0; names.len().max(1)],- s => vec![0.0; s.n()],- }- }-}--/// A process colour from components in `space` (grey, RGB or CMYK), each clamped to 0–1.-pub(crate) fn process(space: &Space, c: &[f64]) -> Option<Color> {- let v = |i: usize| c.get(i).map_or(0.0, |x| if x.is_finite() { x.clamp(0.0, 1.0) as f32 } else { 0.0 });- Some(match space {- Space::Gray => Color::gray(1.0 - v(0)),- Space::Rgb => Color::rgb(v(0), v(1), v(2)),- Space::Cmyk => Color::cmyk(v(0), v(1), v(2), v(3)),- _ => return None,- })-}--#[derive(Clone, Debug)]-pub(crate) struct GState {- /// User space → PostScript's default space.- pub ctm: Affine,- pub space: Rc<Space>,- /// The `setcolorspace` operand, for `currentcolorspace`.- pub space_obj: Obj,- pub comps: Vec<f64>,- pub paint: Paint,- pub width: f64,- pub cap: LineCap,- pub join: LineJoin,- pub miter: f64,- /// The dash pattern, shared by the states saved or copied from this one.- pub dash: Rc<[f64]>,- pub dash_offset: f64,- /// The current path, in document space.- pub path: BezPath,- pub cur: Option<Point>,- pub start: Option<Point>,- pub clips: Vec<Arc<Clip>>,- /// The clips `clipsave` saved, for `cliprestore`.- pub saved_clips: Vec<Rc<[Arc<Clip>]>>,- pub overprint: bool,- pub font: Option<DictRef>,- /// `nulldevice`: painting draws nothing.- pub null: bool,- /// The colour is a shading pattern whose shading is a mesh: a fill paints it (the shading- /// and pattern space → the document).- pub mesh: Option<(DictRef, Affine)>,-}--impl Default for GState {- fn default() -> Self {- Self {- ctm: Affine::IDENTITY,- space: Rc::new(Space::Gray),- space_obj: Obj::name("DeviceGray"),- comps: vec![0.0],- paint: Paint::solid(Color::gray(1.0)),- width: 1.0,- cap: LineCap::Butt,- join: LineJoin::Miter,- miter: 10.0,- dash: Rc::from([]),- dash_offset: 0.0,- path: BezPath::new(),- cur: None,- start: None,- clips: vec![],- saved_clips: vec![],- overprint: false,- font: None,- null: false,- mesh: None,- }- }-}--/// What the program draws.-pub(crate) struct Out {- /// The document being made: ids, images and swatches.- pub doc: Document,- pub drawn: Drawn,- pub warnings: Vec<String>,- /// PostScript's default space → document space.- pub page: Affine,- /// The page (the bounding box) in document space.- pub frame: Rect,- /// Clip and group ids are given in the order they open, so a chain of both sorts by id.- next_clip: u32,- /// The groups open (outermost first), and how many more opened past [`MAX_NEST`] (their art- /// goes in the innermost group kept).- groups: Vec<Arc<Clip>>,- too_deep: usize,- /// Path elements (and the clips and groups of each object) drawn so far (see [`MAX_DRAWN`]).- elements: usize,- /// The path the last object was filled with: a stroke of the same path right after joins it.- merge: Option<BezPath>,- /// Process colours painted, by model (the document opens in CMYK when most are).- pub cmyk: usize,- pub rgb: usize,- /// Spot inks used: name and colour at full tint.- pub spots: Vec<(String, Color)>,- /// The color at full tint of each spot ink in [`Self::spots`], by name.- spot_colors: HashMap<Rc<str>, Color>,- /// Rectangles painted with a shading (`shfill`): a clipping group of one is the clip path- /// filled with it.- pub shadings: HashSet<NodeId>,- /// Tiling patterns made into pattern swatches: the pattern's `PaintProc` (a pattern made- /// again with `makepattern` shares it) and cell, the colour an uncoloured one painted in, and- /// the swatch's name. Each list holds the patterns of one [`tiling_hash`]; a pattern whose- /// cell has a NaN corner is left out.- tilings: HashMap<u64, Vec<Tiling>>,- /// How deep art drawn apart (a pattern's cell, a Type 3 glyph) is nested.- pub apart: u32,-}--fn sane(r: Rect) -> bool {- [r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite() && v.abs() <= LIMIT)-}--/// A tiling pattern made into a pattern swatch, as [`Out::tilings`] lists it.-type Tiling = (Shared<Obj>, Rect, Option<Paint>, String);--/// A hash of what tells tiling patterns apart in [`Out::tilings`]. Patterns that compare equal-/// hash alike: each number goes in by its bits, and −0 goes in as 0.-fn tiling_hash(proc: &Shared<Obj>, tile: Rect, under: Option<&Paint>) -> u64 {- let mut h = DefaultHasher::new();- proc.hash(&mut h);- [tile.x0, tile.y0, tile.x1, tile.y1].map(|v| (v + 0.0).to_bits()).hash(&mut h);- if let Some(Paint::Solid { color, swatch, tint }) = under {- let c = match *color {- Color::Rgb { r, g, b } => [r, g, b, 0.0],- Color::Cmyk { c, m, y, k } => [c, m, y, k],- Color::Gray { k } => [k, 0.0, 0.0, 0.0],- Color::Lab { l, a, b } => [l, a, b, 0.0],- };- c.map(|v| (v + 0.0).to_bits()).hash(&mut h);- swatch.hash(&mut h);- (tint + 0.0).to_bits().hash(&mut h);- }- h.finish()-}--impl Out {- pub fn new(doc: Document, page: Affine, frame: Rect) -> Self {- Self {- doc,- drawn: vec![],- warnings: vec![],- page,- frame,- next_clip: 0,- groups: vec![],- too_deep: 0,- elements: 0,- merge: None,- cmyk: 0,- rgb: 0,- spots: vec![],- spot_colors: HashMap::new(),- shadings: HashSet::new(),- tilings: HashMap::new(),- apart: 0,- }- }-- pub fn warn(&mut self, w: &str) {- if !self.warnings.iter().any(|x| x == w) {- self.warnings.push(w.to_string());- }- }-- /// Open a group: what is drawn until it ends ([`Self::end_group`]) goes in it.- pub fn begin_group(&mut self) {- if self.groups.len() >= MAX_NEST {- self.too_deep += 1;- self.warn(&format!("groups nested more than {MAX_NEST} deep were read as part of the group around them"));- return;- }- self.next_clip += 1;- self.groups.push(Arc::new(Clip { id: self.next_clip, region: None }));- }-- /// End the innermost group open (an end without a beginning ends nothing).- pub fn end_group(&mut self) {- if self.too_deep > 0 {- self.too_deep -= 1;- } else {- self.groups.pop();- }- }-- /// The chain an object drawn under `clips` is drawn in: the clips and the groups open, in the- /// order they opened.- pub fn chain(&self, clips: &[Arc<Clip>]) -> Vec<Arc<Clip>> {- if self.groups.is_empty() {- return clips.to_vec();- }- let mut chain = Vec::with_capacity(clips.len() + self.groups.len());- let (mut a, mut b) = (clips.iter().peekable(), self.groups.iter().peekable());- while let (Some(x), Some(y)) = (a.peek(), b.peek()) {- let next = if x.id < y.id { a.next() } else { b.next() };- chain.extend(next.cloned());- }- chain.extend(a.chain(b).cloned());- chain- }-- /// Add `node` under `clips` (in the groups open); `None` when it was left out.- pub fn push(&mut self, mut node: Node, clips: &[Arc<Clip>]) -> Option<NodeId> {- self.merge = None;- let chain = self.chain(clips);- let size = node.path_data().map_or(1, |p| p.subpaths.iter().map(|s| s.anchors.len()).sum()) + chain.len();- self.elements = self.elements.saturating_add(size);- if self.drawn.len() >= MAX_NODES || self.elements > MAX_DRAWN {- self.warn(TOO_MUCH);- return None;- }- if !node.visual_bounds().is_none_or(sane) {- self.warn(FAR_AWAY);- return None;- }- node.id = self.doc.alloc_id();- let id = node.id;- self.drawn.push((chain, node));- Some(id)- }-- /// Count a paint's colour model.- fn count(&mut self, p: &Paint) {- match p {- Paint::Solid { color: Color::Cmyk { .. }, swatch: None, .. } => self.cmyk += 1,- Paint::Solid { color: Color::Rgb { .. }, swatch: None, .. } => self.rgb += 1,- _ => {}- }- }-- /// Fill `bp` with `paint`.- fn fill(&mut self, bp: BezPath, rule: FillRule, paint: Paint, overprint: bool, clips: &[Arc<Clip>]) {- self.count(&paint);- let item = AppearanceItem::Fill(FillLayer { overprint, ..FillLayer::new(paint) });- let mut n = Node::path(NodeId(0), PathData::from_bezpath(&bp), Appearance { items: vec![item], ..Appearance::default() });- if let NodeKind::Path { rule: r, .. } = &mut n.kind {- *r = rule;- }- if self.push(n, clips).is_some() {- self.merge = Some(bp);- }- }-- /// Stroke `bp` with `st`: joins the object just filled with the same path, under the same- /// clips (`gsave fill grestore stroke`).- fn stroke(&mut self, bp: BezPath, st: StrokeLayer, clips: &[Arc<Clip>]) {- self.count(&st.paint);- if self.merge.as_ref() == Some(&bp) {- let here = self.chain(clips);- if let Some((chain, last)) = self.drawn.last_mut()- && chain.iter().map(|c| c.id).eq(here.iter().map(|c| c.id))- {- last.appearance.items.push(AppearanceItem::Stroke(st));- self.merge = None;- return;- }- }- let n = Node::path(NodeId(0), PathData::from_bezpath(&bp), Appearance { items: vec![AppearanceItem::Stroke(st)], ..Appearance::default() });- self.push(n, clips);- }-- /// A new clip of `path` inside `clips`; `None` for a rectangle around the whole page, which- /// clips nothing.- fn clip(&mut self, path: BezPath, rule: FillRule) -> Option<Arc<Clip>> {- // Only a polygon that really covers the page: a diamond touching its edges has the page as- // its bounding box but cuts its corners away (#1542).- if path.elements().len() <= 6 && vectorcraft_geom::hit::polygon_covers_rect(&path, self.frame, 0.5) {- return None;- }- self.next_clip += 1;- Some(Arc::new(Clip { id: self.next_clip, region: Some((path, rule)) }))- }-}--/// The smallest angle from `a` to `b` (radians, −π to π).-fn turn(a: f64, b: f64) -> f64 {- let d = (b - a).rem_euclid(std::f64::consts::TAU);- if d > std::f64::consts::PI { d - std::f64::consts::TAU } else { d }-}--/// The angle from `a` counterclockwise to `b` (degrees, 0 to 360), worked out from what is left-/// of each after whole turns.-fn ccw_turn(a: f64, b: f64) -> f64 {- (b % 360.0 - a % 360.0).rem_euclid(360.0)-}--impl Interp<'_> {- /// User space → document space.- pub fn xf(&self) -> Affine {- self.out.page * self.g.ctm- }-- /// How much user-space lengths grow in the document.- pub fn scale(&self) -> f64 {- let s = self.xf().determinant().abs().sqrt();- if s.is_finite() { s } else { 0.0 }- }-- /// The current point in user space.- pub fn user_point(&self) -> Res<Point> {- let p = self.g.cur.ok_or(PsError::Ps("nocurrentpoint", String::new()))?;- let inv = self.xf();- if inv.determinant().abs() < 1e-12 {- return ps_err("undefinedresult", "");- }- Ok(inv.inverse() * p)- }-- pub fn gsave(&mut self) -> Res {- if self.saved.len() >= MAX_GSAVE {- return Err(PsError::Limit("too many saved graphics states"));- }- self.alloc(std::mem::size_of_val(self.g.path.elements()))?;- self.saved.push(self.g.clone());- Ok(())- }-- pub fn grestore(&mut self) {- if let Some(g) = self.saved.pop() {- self.g = g;- }- }-- // ---------- paths ------------ /// Room for one more element in the current path.- pub fn grow(&self) -> Res {- if self.g.path.elements().len() >= MAX_PATH {- return Err(PsError::Limit("a path has too many points"));- }- Ok(())- }-- /// Count `n` path elements an operator makes, reads or copies against the operation budget,- /// an operation each: making or reading an element takes up to about as long as an operation,- /// and copying one takes less (measured).- fn spend_elements(&mut self, n: usize) -> Res {- self.spend(n as u64)- }-- fn move_to(&mut self, p: Point) -> Res {- self.grow()?;- // Consecutive movetos: the last one counts.- if let Some(PathEl::MoveTo(_)) = self.g.path.elements().last() {- self.g.path.pop();- }- self.g.path.move_to(p);- self.g.cur = Some(p);- self.g.start = Some(p);- Ok(())- }-- fn line_to(&mut self, p: Point) -> Res {- self.grow()?;- if self.g.cur.is_none() {- return ps_err("nocurrentpoint", "");- }- self.g.path.line_to(p);- self.g.cur = Some(p);- Ok(())- }-- /// Path elements in user space appended (the first move a line when there is a current point),- /// each counted against the operation budget.- fn append_user(&mut self, els: impl Iterator<Item = PathEl>) -> Res {- let xf = self.xf();- for el in els {- self.spend_elements(1)?;- match el {- PathEl::MoveTo(p) => {- let p = xf * p;- if self.g.cur.is_some() { self.line_to(p)? } else { self.move_to(p)? }- }- PathEl::LineTo(p) => self.line_to(xf * p)?,- PathEl::QuadTo(a, p) => {- self.grow()?;- self.g.path.quad_to(xf * a, xf * p);- self.g.cur = Some(xf * p);- }- PathEl::CurveTo(a, b, p) => {- self.grow()?;- self.g.path.curve_to(xf * a, xf * b, xf * p);- self.g.cur = Some(xf * p);- }- PathEl::ClosePath => {- self.grow()?;- self.g.path.close_path();- }- }- }- Ok(())- }-- /// `arc` / `arcn`: from angle `a1` to `a2` (degrees, counter-clockwise or clockwise).- fn arc(&mut self, c: Point, r: f64, a1: f64, a2: f64, ccw: bool) -> Res {- // `arc` raises `a2` by multiples of 360 until it is at least `a1`, and `arcn` lowers it- // until it is at most `a1` (PLRM 3rd ed., `arc` and `arcn` in chapter 8). Those sweeps,- // and the first endpoint, are worked out from what is left of each angle after whole turns.- let sweep = if ccw && a2 < a1 {- ccw_turn(a1, a2)- } else if !ccw && a2 > a1 {- -ccw_turn(a2, a1)- } else {- a2 - a1- };- let tau = std::f64::consts::TAU;- let sweep = sweep.to_radians().clamp(-tau * 4.0, tau * 4.0);- let a1 = (a1 % 360.0).to_radians();- let start = c + Vec2::new(r * a1.cos(), r * a1.sin());- self.append_user(std::iter::once(PathEl::MoveTo(start)))?;- let arc = kurbo::Arc::new(c, Vec2::new(r, r), a1, sweep, 0.0);- let tol = (0.01 / self.scale().max(1e-9)).max(1e-9);- self.append_user(arc.append_iter(tol))- }-- /// `arct` / `arcto`: a line towards `p1` rounded with radius `r` into the line to `p2`; the- /// tangent points (user space).- fn arct(&mut self, p1: Point, p2: Point, r: f64) -> Res<[Point; 2]> {- let p0 = self.user_point()?;- let (u, v) = (p0 - p1, p2 - p1);- let (lu, lv) = (u.hypot(), v.hypot());- let cross = u.cross(v);- if lu < 1e-12 || lv < 1e-12 || cross.abs() < 1e-12 || r <= 0.0 {- self.append_user(std::iter::once(PathEl::LineTo(p1)))?;- return Ok([p1, p1]);- }- let (u, v) = (u / lu, v / lv);- let half = u.dot(v).clamp(-1.0, 1.0).acos() / 2.0;- let dist = r / half.tan();- let (t1, t2) = (p1 + u * dist, p1 + v * dist);- let bis = (u + v).normalize();- let c = p1 + bis * (r / half.sin());- let (a1, a2) = ((t1 - c).atan2(), (t2 - c).atan2());- self.append_user(std::iter::once(PathEl::LineTo(t1)))?;- let tol = (0.01 / self.scale().max(1e-9)).max(1e-9);- let arc = kurbo::Arc::new(c, Vec2::new(r, r), a1, turn(a1, a2), 0.0);- self.append_user(arc.append_iter(tol))?;- Ok([t1, t2])- }-- fn rect_path(&self, x: f64, y: f64, w: f64, h: f64) -> BezPath {- let xf = self.xf();- let mut bp = BezPath::new();- bp.move_to(xf * Point::new(x, y));- bp.line_to(xf * Point::new(x + w, y));- bp.line_to(xf * Point::new(x + w, y + h));- bp.line_to(xf * Point::new(x, y + h));- bp.close_path();- bp- }-- /// The rectangles of `rectfill`, `rectstroke` and `rectclip`: `x y w h` or an array of them.- fn rects(&mut self) -> Res<BezPath> {- let nums: Vec<f64> = match self.stack.last() {- Some(Obj::Array { .. }) => {- let items = self.pop_array()?;- // Five elements a rectangle, counted before the array is read.- self.spend_elements(items.len() / 4 * 5)?;- let v: Option<Vec<f64>> = items.borrow().iter().map(Obj::as_num).collect();- v.ok_or(PsError::Ps("typecheck", String::new()))?- }- _ => self.nums::<4>()?.to_vec(),- };- if nums.len() / 4 * 5 >= MAX_PATH {- return Err(PsError::Limit("a path has too many points"));- }- let mut bp = BezPath::new();- for [x, y, w, h] in nums.as_chunks::<4>().0 {- bp.extend(self.rect_path(*x, *y, *w, *h));- }- Ok(bp)- }-- // ---------- painting ------------ fn fill_path(&mut self, bp: BezPath, rule: FillRule) -> Res {- if bp.elements().is_empty() || self.g.null {- return Ok(());- }- // A mesh pattern paints its shading inside the path.- if let Some((sh, m)) = self.g.mesh.clone() {- let clips = self.g.clips.clone();- self.clip_with(bp, rule);- let r = self.mesh_fill(&sh, m);- self.g.clips = clips;- return r;- }- if self.g.paint.is_none() {- return Ok(());- }- let (paint, overprint) = (self.g.paint.clone(), self.g.overprint);- self.out.fill(bp, rule, paint, overprint, &self.g.clips);- Ok(())- }-- fn stroke_path(&mut self, bp: BezPath) -> Res {- if bp.elements().is_empty() || self.g.paint.is_none() || self.g.null {- return Ok(());- }- let st = self.stroke_layer()?;- self.out.stroke(bp, st, &self.g.clips);- Ok(())- }-- /// The stroke the graphics state draws, in document space. Each entry of the dash pattern it- /// copies counts as an operation.- fn stroke_layer(&mut self) -> Res<StrokeLayer> {- self.spend(self.g.dash.len() as u64)?;- let k = self.scale();- let w = self.g.width * k;- let mut st = StrokeLayer::new(self.g.paint.clone(), if w > 0.0 && w.is_finite() { w } else { HAIRLINE });- st.cap = self.g.cap;- st.join = self.g.join;- st.miter_limit = self.g.miter.clamp(1.0, 500.0);- st.overprint = self.g.overprint;- let pattern: Vec<f64> = self.g.dash.iter().map(|d| d * k).collect();- let dash = Dash { pattern, offset: self.g.dash_offset * k, align_corners: false };- st.dash = dash.is_dashed().then_some(dash);- Ok(st)- }-- /// The current path in user space, each element as its operator and points (quadratic- /// segments as cubic ones).- fn user_elements(&self) -> Res<Vec<(Op, Vec<Point>)>> {- let xf = self.xf();- if xf.determinant().abs() < 1e-12 {- return ps_err("undefinedresult", "");- }- let inv = xf.inverse();- let mut last = Point::ZERO;- let mut out = Vec::with_capacity(self.g.path.elements().len());- for el in self.g.path.elements() {- let (op, pts) = match *el {- PathEl::MoveTo(p) => (Op::MoveTo, vec![p]),- PathEl::LineTo(p) => (Op::LineTo, vec![p]),- PathEl::QuadTo(a, p) => (Op::CurveTo, vec![last + (a - last) * (2.0 / 3.0), p + (a - p) * (2.0 / 3.0), p]),- PathEl::CurveTo(a, b, p) => (Op::CurveTo, vec![a, b, p]),- PathEl::ClosePath => (Op::ClosePath, vec![]),- };- last = pts.last().copied().unwrap_or(last);- out.push((op, pts.into_iter().map(|p| inv * p).collect()));- }- Ok(out)- }-- /// `pathforall`: the current path in user space, each element through its procedure.- fn path_for_all(&mut self) -> Res {- let close = self.pop_proc()?;- let curve = self.pop_proc()?;- let line = self.pop_proc()?;- let mv = self.pop_proc()?;- self.spend_elements(self.g.path.elements().len())?;- for (op, pts) in self.user_elements()? {- for p in pts {- self.push_num(p.x)?;- self.push_num(p.y)?;- }- let proc = match op {- Op::MoveTo => &mv,- Op::LineTo => &line,- Op::CurveTo => &curve,- _ => &close,- };- if !self.body(proc)? {- break;- }- }- Ok(())- }-- /// Append user path `up` to the current path: a procedure of path operators, or the encoded- /// form (numbers and a string of operator codes).- fn user_path(&mut self, up: Obj) -> Res {- let items = up.items().cloned().ok_or(PsError::Ps("typecheck", "a user path".into()))?;- let encoded = match (items.get(0), items.get(1), items.len()) {- (Some(nums @ (Obj::Array { .. } | Obj::Str(_))), Some(Obj::Str(ops)), 2) => Some((nums, ops.to_vec())),- _ => None,- };- let Some((nums, ops)) = encoded else { return self.call(Obj::Array { items, exec: true }) };- // The operators by code, with how many operands each takes.- const OPS: [(Op, usize); 12] = [- (Op::SetBBox, 4),- (Op::MoveTo, 2),- (Op::RMoveTo, 2),- (Op::LineTo, 2),- (Op::RLineTo, 2),- (Op::CurveTo, 6),- (Op::RCurveTo, 6),- (Op::Arc, 5),- (Op::Arcn, 5),- (Op::Arct, 5),- (Op::ClosePath, 0),- (Op::UCache, 0),- ];- let nums: Vec<f64> = match nums {- Obj::Array { items, .. } => {- // Each entry of the data array and each byte of the operator string counts as an- // element read.- self.spend_elements(items.len().saturating_add(ops.len()))?;- items.borrow().iter().filter_map(Obj::as_num).collect()- }- _ => return ps_err("typecheck", "an encoded user path"),- };- let mut next = nums.into_iter();- let mut repeat = 1usize;- for code in ops {- if code >= 32 {- repeat = usize::from(code - 32);- continue;- }- let &(op, n) = OPS.get(usize::from(code)).ok_or(PsError::Ps("rangecheck", "a user path".into()))?;- for _ in 0..std::mem::replace(&mut repeat, 1) {- for _ in 0..n {- let v = next.next().ok_or(PsError::Ps("rangecheck", "a user path".into()))?;- self.push_num(v)?;- }- // Each operator run counts as an operation.- self.spend(1)?;- self.op(op)?;- }- }- Ok(())- }-- /// `ufill`, `ueofill`, `ustroke` (with an optional matrix): paint a user path, keeping the- /// current path.- fn paint_user_path(&mut self, op: Op) -> Res {- let m = match (op, self.stack.last()) {- (Op::UStroke, Some(Obj::Array { items, exec: false })) if items.len() == 6 && self.stack.len() >= 2 => Some(self.pop_matrix()?),- _ => None,- };- let up = self.pop()?;- self.gsave()?;- let depth = self.saved.len();- self.take_path();- let r = self.user_path(up).and_then(|()| {- if let Some(m) = m {- self.g.ctm *= m;- }- let bp = self.take_path();- match op {- Op::UStroke => self.stroke_path(bp),- _ => self.fill_path(bp, if op == Op::UEoFill { FillRule::EvenOdd } else { FillRule::NonZero }),- }- });- self.saved.truncate(depth);- self.grestore();- r- }-- /// `upath`: the current path as a user path (a procedure, in user space).- fn upath(&mut self) -> Res {- self.pop_bool()?;- let elements = self.user_elements()?;- let b = self.xf().inverse().transform_rect_bbox(self.g.path.bounding_box());- let mut items: Vec<Obj> = [b.x0, b.y0, b.x1, b.y1].into_iter().map(Obj::Real).collect();- items.push(Obj::Op(Op::SetBBox));- for (op, pts) in elements {- items.extend(pts.iter().flat_map(|p| [Obj::Real(p.x), Obj::Real(p.y)]));- items.push(Obj::Op(op));- }- self.alloc(items.len() * std::mem::size_of::<Obj>())?;- self.push(Obj::proc(items))- }-- /// `execform`: the form's `PaintProc` run with its matrix, clipped to its box.- fn exec_form(&mut self) -> Res {- let d = self.pop_dict()?;- let get = |k: &str| d.borrow().get(&Key::name(k)).cloned();- let m = get("Matrix").and_then(|o| o.items().and_then(|i| super::interp::matrix_of(&i.borrow()))).unwrap_or(Affine::IDENTITY);- let bbox: Vec<f64> = get("BBox").and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default();- let paint = get("PaintProc").ok_or(PsError::Ps("undefined", "PaintProc".into()))?;- self.gsave()?;- let depth = self.saved.len();- self.g.ctm *= m;- if let [x0, y0, x1, y1] = bbox[..] {- let bp = self.rect_path(x0, y0, x1 - x0, y1 - y0);- self.take_path();- self.clip_with(bp, FillRule::NonZero);- }- self.push(Obj::Dict(d))?;- let r = self.call(paint);- self.saved.truncate(depth);- self.grestore();- r- }-- pub(super) fn take_path(&mut self) -> BezPath {- self.g.cur = None;- self.g.start = None;- std::mem::take(&mut self.g.path)- }-- fn clip_with(&mut self, path: BezPath, rule: FillRule) {- let Some(c) = self.out.clip(path, rule) else { return };- if self.g.clips.len() < MAX_NEST {- self.g.clips.push(c);- } else {- self.out.warn(&deep_clips());- }- }-- /// The area the clip leaves, in document space (the page without a clip). The clip path read- /// counts against the operation budget.- fn clip_bounds(&mut self) -> Res<Rect> {- let (bounds, len) =- self.g.clips.iter().rev().find_map(|c| c.region.as_ref()).map_or((self.out.frame, 0), |(p, _)| (p.bounding_box(), p.elements().len()));- self.spend_elements(len)?;- Ok(bounds)- }-- // ---------- colour ------------ /// A colour space operand.- pub(super) fn space_of(&mut self, o: &Obj, depth: u32) -> Res<Space> {- if depth > 4 {- return ps_err("limitcheck", "setcolorspace");- }- let (family, items) = match o {- Obj::Name(n) | Obj::Exec(n) => (n.clone(), vec![]),- Obj::Array { items, .. } => {- let v = items.to_vec();- let n = v.first().and_then(Obj::text).ok_or(PsError::Ps("typecheck", "setcolorspace".into()))?;- (n, v)- }- _ => return ps_err("typecheck", "setcolorspace"),- };- let arg = |i: usize| items.get(i).cloned().ok_or(PsError::Ps("rangecheck", "setcolorspace".into()));- Ok(match &*family {- "DeviceGray" | "CIEBasedA" | "CalGray" => Space::Gray,- "DeviceRGB" | "CIEBasedABC" | "CalRGB" | "Lab" | "CIEBasedDEF" => Space::Rgb,- "DeviceCMYK" | "CIEBasedDEFG" => Space::Cmyk,- "Pattern" => Space::Pattern(match items.get(1) {- Some(base) => Some(Rc::new(self.space_of(base, depth + 1)?)),- None => None,- }),- "ICCBased" => match arg(1)? {- Obj::Dict(d) => match d.borrow().get(&Key::name("N")).and_then(Obj::as_num) {- Some(1.0) => Space::Gray,- Some(4.0) => Space::Cmyk,- _ => Space::Rgb,- },- _ => Space::Rgb,- },- "Separation" | "DeviceN" => {- let names: Vec<Rc<str>> = match arg(1)? {- Obj::Array { items, .. } => items.borrow().iter().filter_map(Obj::text).collect(),- o => o.text().into_iter().collect(),- };- if names.len() > MAX_INKS {- return ps_err("limitcheck", "DeviceN");- }- let alt = self.space_of(&arg(2)?, depth + 1)?;- Space::Inks { names, alt: Rc::new(alt), tint: arg(3)? }- }- "Indexed" => {- let base = self.space_of(&arg(1)?, depth + 1)?;- let hival =- arg(2)?.as_num().filter(|v| (0.0..=MAX_HIVAL as f64).contains(v)).ok_or(PsError::Ps("rangecheck", "Indexed".into()))? as usize;- let n = base.n();- let table: Vec<f64> = match arg(3)? {- Obj::Str(s) => s.borrow().iter().map(|b| f64::from(*b) / 255.0).collect(),- p @ Obj::Array { .. } => {- let mut t = Vec::with_capacity((hival + 1) * n);- for i in 0..=hival {- self.push(Obj::Int(i as i64))?;- self.call(p.clone())?;- let mut c = vec![0.0; n];- for slot in c.iter_mut().rev() {- *slot = self.pop_num()?;- }- t.extend(c);- }- t- }- _ => return ps_err("typecheck", "Indexed"),- };- Space::Indexed { base: Rc::new(base), table: Rc::new(table) }- }- _ => return ps_err("undefined", &family),- })- }-- fn set_space(&mut self, o: Obj) -> Res {- let space = self.space_of(&o, 0)?;- let comps = space.initial();- self.g.space = Rc::new(space);- self.g.space_obj = o;- self.set_comps(comps)- }-- /// Set the colour to `comps` in the current space.- fn set_comps(&mut self, comps: Vec<f64>) -> Res {- let space = self.g.space.clone();- self.g.mesh = None;- self.g.paint = self.paint_of(&space, &comps)?;- self.g.comps = comps;- Ok(())- }-- /// Set a process colour, its space with it.- fn set_process(&mut self, space: Space, name: &str, comps: Vec<f64>) -> Res {- self.g.space = Rc::new(space);- self.g.space_obj = Obj::name(name);- self.set_comps(comps)- }-- /// The paint of colour `comps` in `space`: a spot ink links to its swatch at the tint.- pub fn paint_of(&mut self, space: &Space, comps: &[f64]) -> Res<Paint> {- Ok(match space {- Space::Inks { names, alt, tint } => {- let t = comps.first().copied().unwrap_or(1.0).clamp(0.0, 1.0) as f32;- match names.as_slice() {- [one] if &**one == "None" => Paint::None,- [one] if &**one == "All" => {- Paint::Solid { color: Color::cmyk(1.0, 1.0, 1.0, 1.0).tinted(t), swatch: Some(REGISTRATION.into()), tint: t }- }- [one] => {- let full = match self.out.spot_colors.get(one) {- Some(c) => *c,- None => {- let c = self.tint_color(alt, tint, &[1.0])?;- self.out.spots.push((one.to_string(), c));- // The tint transform may have listed this ink already: the color- // listed first stays.- self.out.spot_colors.entry(one.clone()).or_insert(c);- c- }- };- Paint::Solid { color: full.tinted(t), swatch: Some(one.to_string()), tint: t }- }- _ => Paint::solid(self.tint_color(alt, tint, comps)?),- }- }- Space::Indexed { base, table } => {- let n = base.n();- let i = comps.first().copied().unwrap_or(0.0).round().max(0.0) as usize;- let c = table.get(i * n..i * n + n).ok_or(PsError::Ps("rangecheck", "setcolor".into()))?.to_vec();- Paint::solid(process(base, &c).unwrap_or(Color::BLACK))- }- Space::Pattern(_) => Paint::None,- s => Paint::solid(process(s, comps).unwrap_or(Color::BLACK)),- })- }-- /// The alternate colour of inks at `comps`, through the tint transform.- pub fn tint_color(&mut self, alt: &Space, tint: &Obj, comps: &[f64]) -> Res<Color> {- let base = self.stack.len();- for c in comps {- self.push_num(*c)?;- }- self.call(tint.clone())?;- let n = alt.n();- let at = self.stack.len().checked_sub(n).filter(|a| *a >= base).ok_or(PsError::Ps("stackunderflow", "tint transform".into()))?;- let v: Vec<f64> = self.stack.split_off(at).iter().map(|o| o.as_num().unwrap_or(0.0)).collect();- self.stack.truncate(base);- Ok(process(alt, &v).unwrap_or(Color::BLACK))- }-- /// The current colour as grey, RGB or CMYK components (`currentgray` …).- fn current_rgb(&self) -> [f32; 3] {- self.g.paint.color().map_or([0.0; 3], |c| c.to_rgb_uncalibrated())- }-- /// `setcolor` in a pattern space: the pattern operand, and before it an uncoloured- /// pattern's colour in the underlying space.- fn set_pattern(&mut self, base: Option<Rc<Space>>) -> Res {- let Obj::Dict(d) = self.pop()? else { return ps_err("typecheck", "") };- let uncoloured = d.borrow().get(&Key::name("PaintType")).and_then(Obj::as_num) == Some(2.0);- let under = match base.filter(|_| uncoloured) {- Some(base) => {- let mut c = vec![0.0; base.n()];- for slot in c.iter_mut().rev() {- *slot = self.pop_num()?;- }- Some(self.paint_of(&base, &c)?)- }- None => None,- };- self.g.mesh = None;- self.g.paint = self.pattern_paint(&d, under)?;- Ok(())- }-- /// A pattern colour: a shading pattern's gradient, a tiling pattern's swatch (`under`: the- /// colour an uncoloured one paints in).- fn pattern_paint(&mut self, d: &DictRef, under: Option<Paint>) -> Res<Paint> {- let kind = d.borrow().get(&Key::name("PatternType")).and_then(Obj::as_num);- let sh = d.borrow().get(&Key::name("Shading")).cloned();- let m = d.borrow().get(&Key::name("VCMatrix")).and_then(|o| o.items().and_then(|i| super::interp::matrix_of(&i.borrow())));- // Pattern space → the document.- let m = self.out.page * m.unwrap_or(self.g.ctm);- match (kind, sh) {- (Some(2.0), Some(Obj::Dict(sh))) if is_mesh(&sh) => {- self.g.mesh = Some((sh, m));- Ok(Paint::None)- }- (Some(2.0), Some(Obj::Dict(sh))) => Ok(self.gradient(&sh, m)?.map_or(Paint::None, |g| Paint::Gradient(Box::new(g)))),- (Some(2.0), _) => ps_err("typecheck", "Shading"),- _ => self.tiling(d, under, m),- }- }-- /// A tiling pattern as a pattern swatch (made the first time): its `PaintProc` drawn in- /// pattern space, one cell of `XStep` × `YStep` from the corner of its `BBox`; `m` maps pattern- /// space onto the document.- fn tiling(&mut self, d: &DictRef, under: Option<Paint>, m: Affine) -> Res<Paint> {- let get = |k: &str| d.borrow().get(&Key::name(k)).cloned();- let bbox: Vec<f64> = get("BBox").and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default();- let [x0, y0, x1, y1] = bbox[..] else { return ps_err("rangecheck", "BBox") };- let step = |k: &str| get(k).and_then(|o| o.as_num()).map(f64::abs).filter(|v| v.is_finite() && *v > 1e-9 && *v < LIMIT);- let (Some(xs), Some(ys)) = (step("XStep"), step("YStep")) else { return ps_err("rangecheck", "XStep") };- let tile = Rect::from_origin_size((x0.min(x1), y0.min(y1)), (xs, ys));- let xf = m * Affine::translate(tile.origin().to_vec2());- let proc = get("PaintProc").ok_or(PsError::Ps("undefined", "PaintProc".into()))?;- let key = proc.items().cloned().ok_or(PsError::Ps("typecheck", "PaintProc".into()))?;- let hash = tiling_hash(&key, tile, under.as_ref());- let made = self.out.tilings.get(&hash).and_then(|list| list.iter().find(|(p, t, u, _)| p.same(&key) && *t == tile && *u == under));- if let Some((.., name)) = made {- return Ok(Paint::Pattern { pattern: name.clone(), xf });- }- if self.out.apart >= MAX_APART {- self.out.warn(NESTED_PATTERNS);- return Ok(Paint::solid(Color::gray(0.5)));- }- let paint = under.clone();- let art = self.draw_apart(Rect::new(x0, y0, x1, y1).abs(), |it| {- if let Some(p) = paint {- it.g.paint = p;- }- it.push(Obj::Dict(d.clone()))?;- it.call(proc)- })?;- if art.is_empty() {- return Ok(Paint::None);- }- // The document gets its patterns only here, so the n made so far are Pattern 1 to- // Pattern n.- let name = format!("Pattern {}", self.out.doc.patterns.len() + 1);- let mut def = PatternDef::new(&name, art);- def.tile = tile;- self.out.doc.patterns.push(def);- // A cell with a NaN corner equals no cell, so the lookup above could never find it.- if !tile.is_nan() {- self.out.tilings.entry(hash).or_insert_with(|| Vec::with_capacity(1)).push((key, tile, under, name.clone()));- }- Ok(Paint::Pattern { pattern: name, xf })- }-- /// The art `draw` draws on its own, in its own space (user space is the document's, the page- /// `frame`), from a fresh graphics state with the current font: a pattern's cell, a glyph.- pub fn draw_apart(&mut self, frame: Rect, draw: impl FnOnce(&mut Self) -> Res) -> Res<Vec<Arc<Node>>> {- let fresh = GState { font: self.g.font.clone(), ..GState::default() };- let g = std::mem::replace(&mut self.g, fresh);- let saved = std::mem::take(&mut self.saved);- let drawn = std::mem::take(&mut self.out.drawn);- let page = std::mem::replace(&mut self.out.page, Affine::IDENTITY);- let frame = std::mem::replace(&mut self.out.frame, frame);- let merge = self.out.merge.take();- // The art isn't in the groups open around it.- let groups = std::mem::take(&mut self.out.groups);- let too_deep = std::mem::take(&mut self.out.too_deep);- self.out.apart += 1;- let r = draw(self);- self.out.apart -= 1;- let art = std::mem::replace(&mut self.out.drawn, drawn);- (self.out.page, self.out.frame, self.out.merge) = (page, frame, merge);- (self.out.groups, self.out.too_deep) = (groups, too_deep);- (self.g, self.saved) = (g, saved);- r?;- let mut nodes = vectorcraft_doc::clipnest::nest(&mut self.out.doc, art);- if !self.out.shadings.is_empty() {- collapse(&mut nodes, &self.out.shadings);- }- Ok(nodes)- }-- /// An axial or radial shading as a gradient, `m` mapping its space onto the document.- fn gradient(&mut self, sh: &DictRef, m: Affine) -> Res<Option<GradientPaint>> {- let get = |k: &str| sh.borrow().get(&Key::name(k)).cloned();- let kind = get("ShadingType").and_then(|o| o.as_num()).unwrap_or(0.0);- if !is_gradient(sh) {- self.out.warn(UNKNOWN_SHADINGS);- return Ok(None);- }- let space = self.space_of(&get("ColorSpace").ok_or(PsError::Ps("undefined", "ColorSpace".into()))?, 0)?;- let nums = |o: Option<Obj>| -> Vec<f64> {- o.and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default()- };- let coords = nums(get("Coords"));- let domain = nums(get("Domain"));- let (d0, d1) = (domain.first().copied().unwrap_or(0.0), domain.get(1).copied().unwrap_or(1.0));- let f = get("Function").ok_or(PsError::Ps("undefined", "Function".into()))?;- // Where the colour changes: the ends, and the bounds of stitched linear functions (unless- // there are too many).- let mut visits = 0;- let points = linear_points(&f, 0, &mut visits).filter(|p| p.len() <= MAX_STITCH_STOPS);- let stitched = points.is_some();- let ts: Vec<f64> = match points {- Some(mut pts) => {- pts.retain(|t| (d0.min(d1)..=d0.max(d1)).contains(t));- pts.iter().map(|t| if d1 != d0 { (t - d0) / (d1 - d0) } else { 0.0 }).chain([0.0, 1.0]).collect()- }- None => (0..=SHADING_SAMPLES).map(|i| i as f64 / SHADING_SAMPLES as f64).collect(),- };- let mut ts = ts;- ts.sort_by(f64::total_cmp);- ts.dedup_by(|a, b| (*a - *b).abs() < 1e-9);- let radial = kind == 3.0;- let c = |i: usize| coords.get(i).copied().unwrap_or(0.0);- let (r0, r1) = (c(2).max(0.0), c(5).max(1e-6));- let mut stops = Vec::with_capacity(ts.len());- let stop = |paint: Paint, offset: f64| match paint {- Paint::Solid { color, swatch, tint } => GradientStop { swatch, tint, ..GradientStop::new(offset as f32, color) },- _ => GradientStop::new(offset as f32, Color::BLACK),- };- for t in ts {- let comps = self.eval(&f, &[d0 + (d1 - d0) * t], 0)?;- let paint = self.paint_of(&space, &comps)?;- let offset = if radial { (r0 + (r1 - r0) * t) / r1 } else { t };- // At a bound of a stitched function the pieces need not meet (a hard colour change):- // the colour just before the bound is a stop at the same offset, ahead of the one- // after it.- if stitched && t > 0.0 && t < 1.0 {- let comps = self.eval(&f, &[d0 + (d1 - d0) * (t - 1e-9)], 0)?;- let before = stop(self.paint_of(&space, &comps)?, offset);- if before.color != stop(paint.clone(), offset).color {- stops.push(before);- }- }- stops.push(stop(paint, offset));- }- let (gk, geom) = if radial {- let centre = Point::new(c(3), c(4));- let mut geom = GradientGeom { start: centre, end: centre + Vec2::new(r1, 0.0), aspect: 1.0, focal: None };- geom.set_focal(Some(Point::new(c(0), c(1))));- geom.transform(m, GradientKind::Radial);- (GradientKind::Radial, geom)- } else {- (GradientKind::Linear, GradientGeom { start: m * Point::new(c(0), c(1)), end: m * Point::new(c(2), c(3)), aspect: 1.0, focal: None })- };- let mut g = GradientPaint::new(Gradient::new(gk, stops));- g.geom = Some(geom);- Ok(Some(g))- }-- /// A function (types 0, 2 and 3; an array of them, one per component) at `x` (types 2 and 3- /// take one input).- pub fn eval(&mut self, f: &Obj, x: &[f64], depth: u32) -> Res<Vec<f64>> {- self.eval_inner(f, x, depth, &mut 0)- }-- /// [`Self::eval`], with `visits` (shared by the whole recursion, incremented on every call)- /// counting the functions visited against [`MAX_FUNCTION_VISITS`], as [`linear_points`] counts- /// its nodes. The depth limit alone stops a function that refers to itself, but not one that- /// fans out through shared arrays: when four levels of arrays each have 100 entries that all- /// refer to the same array of the level below (at the last level, the same function), one- /// evaluation would visit 101,010,101 functions. Each function visited also counts- /// [`FUNCTION_OPS`] against the operation budget.- fn eval_inner(&mut self, f: &Obj, x: &[f64], depth: u32, visits: &mut usize) -> Res<Vec<f64>> {- *visits += 1;- if depth > 8 || *visits > MAX_FUNCTION_VISITS {- return ps_err("limitcheck", "Function");- }- self.spend(FUNCTION_OPS)?;- let d = match f {- Obj::Dict(d) => d.clone(),- Obj::Array { items, .. } => {- // Each entry is at least one more function: an array with more entries than the- // visits left raises `limitcheck` before it is copied.- if items.len() > MAX_FUNCTION_VISITS - *visits {- return ps_err("limitcheck", "Function");- }- let fs = items.to_vec();- let mut out = vec![];- for g in &fs {- out.extend(self.eval_inner(g, x, depth + 1, visits)?.first().copied());- }- return Ok(out);- }- _ => return ps_err("typecheck", "Function"),- };- let get = |k: &str| d.borrow().get(&Key::name(k)).cloned();- let nums = |o: Option<Obj>| -> Vec<f64> {- o.and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default()- };- let domain = nums(get("Domain"));- let t = x.first().copied().unwrap_or(0.0);- let t = match domain.as_slice() {- [a, b, ..] => clamp_between(t, *a, *b),- _ => t,- };- match get("FunctionType").and_then(|o| o.as_num()) {- Some(0.0) => self.sampled(&d, x),- Some(2.0) => {- let c0 = nums(get("C0"));- let c1 = nums(get("C1"));- let (c0, c1) = (if c0.is_empty() { vec![0.0] } else { c0 }, if c1.is_empty() { vec![1.0] } else { c1 });- let n = get("N").and_then(|o| o.as_num()).unwrap_or(1.0);- let x = t.max(0.0).powf(n);- Ok(c0.iter().zip(&c1).map(|(a, b)| a + x * (b - a)).collect())- }- Some(3.0) => {- // Read the pieces through the borrow and clone only the one we recurse into: a- // `Functions` array of millions (shared, or reached again through a cycle) must- // not be copied on every call and at every live recursion level.- let functions = get("Functions");- let fs = functions.as_ref().and_then(Obj::items);- let n = fs.map_or(0, Shared::len);- let bounds = nums(get("Bounds"));- let encode = nums(get("Encode"));- let (lo, hi) = (domain.first().copied().unwrap_or(0.0), domain.get(1).copied().unwrap_or(1.0));- let k = bounds.iter().take_while(|b| t >= **b).count().min(n.saturating_sub(1));- let a = if k == 0 { lo } else { bounds.get(k - 1).copied().unwrap_or(lo) };- let b = bounds.get(k).copied().unwrap_or(hi);- let (e0, e1) = (encode.get(2 * k).copied().unwrap_or(0.0), encode.get(2 * k + 1).copied().unwrap_or(1.0));- let u = if b != a { e0 + (t - a) / (b - a) * (e1 - e0) } else { e0 };- let g = fs.and_then(|fs| fs.get(k)).ok_or(PsError::Ps("rangecheck", "Functions".into()))?;- self.eval_inner(&g, &[u], depth + 1, visits)- }- _ => {- self.out.warn(UNKNOWN_FUNCTIONS);- let r = nums(get("Range"));- Ok(r.chunks(2).map(|p| p.iter().sum::<f64>() / 2.0).collect())- }- }- }-- // ---------- the operators ------------ pub fn graphics_op(&mut self, op: Op) -> Res {- use Op::*;- match op {- Gsave => self.gsave()?,- Grestore => self.grestore(),- GrestoreAll => {- if let Some(g) = self.saved.first().cloned() {- self.saved.clear();- self.g = g;- }- }- InitGraphics => {- let font = self.g.font.take();- self.g = GState { font, null: self.g.null, ..GState::default() };- }- NullDevice => {- self.g.null = true;- self.g.ctm = Affine::IDENTITY;- self.g.clips.clear();- }- ExecForm => self.exec_form()?,- StrokePath => {- let bp = self.take_path();- let mut st = self.stroke_layer()?;- // A dash pattern far finer than the path would make countless pieces.- let period: f64 = st.dash.as_ref().map_or(0.0, |d| d.pattern.iter().sum());- let periods = if st.dash.is_some() && period > 0.0 { bp.perimeter(1e-3) / period } else { 0.0 };- if st.dash.is_some() && !(period > 0.0 && periods < MAX_DASHES) {- st.dash = None;- }- let tol = (0.01 / self.scale().max(1e-9)).clamp(1e-4, 1.0);- let outline = vectorcraft_effects::stroke::line_outline(&bp, &st, st.width, tol);- // The path, each entry of the dash pattern in each period, and the outline count- // as elements.- let dashes = st.dash.as_ref().map_or(0.0, |d| periods * d.pattern.len() as f64) as usize;- self.spend_elements(bp.elements().len().saturating_add(dashes).saturating_add(outline.elements().len()))?;- if outline.elements().len() >= MAX_PATH {- return Err(PsError::Limit("a path has too many points"));- }- self.g.cur = outline.elements().iter().rev().find_map(|e| e.end_point());- self.g.start = self.g.cur;- self.g.path = outline;- }- PathForAll => self.path_for_all()?,- UFill | UEoFill | UStroke => self.paint_user_path(op)?,- UAppend => {- let up = self.pop()?;- self.user_path(up)?;- }- UPath => self.upath()?,- SetBBox => {- self.nums::<4>()?;- }- CurrentHsbColor => {- let [r, g, b] = self.current_rgb();- let (max, min) = (r.max(g).max(b), r.min(g).min(b));- let d = max - min;- let h = if d <= 0.0 {- 0.0- } else if max == r {- ((g - b) / d).rem_euclid(6.0) / 6.0- } else if max == g {- ((b - r) / d + 2.0) / 6.0- } else {- ((r - g) / d + 4.0) / 6.0- };- let s = if max > 0.0 { d / max } else { 0.0 };- for v in [h, s, max] {- self.push_num(f64::from(v))?;- }- }- CurrentColorRendering => {- let d = super::obj::Dict::from([(Key::name("ColorRenderingType"), Obj::Int(1))]);- self.push(Obj::dict(d))?;- }- FindColorRendering => {- self.pop()?;- self.push(Obj::name("DefaultColorRendering"))?;- self.push(Obj::Bool(false))?;- }- CurrentColorScreen => {- for _ in 0..4 {- self.push(Obj::Real(60.0))?;- self.push(Obj::Real(45.0))?;- self.push(Obj::proc(vec![]))?;- }- }- CurrentSmoothness => self.push(Obj::Real(0.02))?,- SetHalftonePhase => {- self.nums::<2>()?;- }- CurrentHalftonePhase => {- self.push(Obj::Int(0))?;- self.push(Obj::Int(0))?;- }- GStateNew => {- self.spend_elements(self.g.path.elements().len())?;- self.alloc(std::mem::size_of_val(self.g.path.elements()))?;- self.push(Obj::GState(Rc::new(self.g.clone())))?;- }- CurrentGState => {- self.pop()?;- self.spend_elements(self.g.path.elements().len())?;- self.alloc(std::mem::size_of_val(self.g.path.elements()))?;- self.push(Obj::GState(Rc::new(self.g.clone())))?;- }- SetGState => match self.pop()? {- Obj::GState(g) => {- self.spend_elements(g.path.elements().len())?;- self.g = (*g).clone();- }- _ => return ps_err("typecheck", ""),- },- SetLineWidth => self.g.width = self.pop_num()?.abs(),- CurrentLineWidth => self.push_num(self.g.width)?,- SetLineCap => {- self.g.cap = match self.pop_int()? {- 1 => LineCap::Round,- 2 => LineCap::Square,- _ => LineCap::Butt,- }- }- CurrentLineCap => self.push(Obj::Int(self.g.cap as i64))?,- SetLineJoin => {- self.g.join = match self.pop_int()? {- 1 => LineJoin::Round,- 2 => LineJoin::Bevel,- _ => LineJoin::Miter,- }- }- CurrentLineJoin => self.push(Obj::Int(self.g.join as i64))?,- SetMiterLimit => self.g.miter = self.pop_num()?,- CurrentMiterLimit => self.push_num(self.g.miter)?,- SetDash => {- let offset = self.pop_num()?;- let items = self.pop_array()?;- if items.len() > MAX_DASH_ENTRIES {- return ps_err("limitcheck", "");- }- // Each entry read counts as an operation.- self.spend(items.len() as u64)?;- let v: Option<Vec<f64>> = items.borrow().iter().map(|o| o.as_num().filter(|v| v.is_finite() && *v >= 0.0)).collect();- self.g.dash = v.ok_or(PsError::Ps("typecheck", String::new()))?.into();- self.g.dash_offset = offset;- }- CurrentDash => {- // The array made counts against the memory budget.- self.alloc(self.g.dash.len() * std::mem::size_of::<Obj>())?;- let d = self.g.dash.iter().map(|v| Obj::Real(*v)).collect();- self.push(Obj::array(d))?;- self.push_num(self.g.dash_offset)?;- }- SetGray => {- let [g] = self.nums()?;- self.set_process(Space::Gray, "DeviceGray", vec![g])?;- }- SetRgbColor => {- let c = self.nums::<3>()?;- self.set_process(Space::Rgb, "DeviceRGB", c.to_vec())?;- }- SetHsbColor => {- let [h, s, b] = self.nums()?;- let [r, g, bl] =- Color::from_hsb((h.rem_euclid(1.0) * 360.0) as f32, s.clamp(0.0, 1.0) as f32, b.clamp(0.0, 1.0) as f32).to_rgb_uncalibrated();- self.set_process(Space::Rgb, "DeviceRGB", vec![f64::from(r), f64::from(g), f64::from(bl)])?;- }- SetCmykColor => {- let c = self.nums::<4>()?;- self.set_process(Space::Cmyk, "DeviceCMYK", c.to_vec())?;- }- CurrentGray => {- let [r, g, b] = self.current_rgb();- self.push_num(f64::from(0.3 * r + 0.59 * g + 0.11 * b))?;- }- CurrentRgbColor => {- for v in self.current_rgb() {- self.push_num(f64::from(v))?;- }- }- CurrentCmykColor => {- let c = self.g.paint.color().map_or([0.0, 0.0, 0.0, 1.0], |c| c.to_cmyk());- for v in c {- self.push_num(f64::from(v))?;- }- }- SetColorSpace => {- let o = self.pop()?;- self.set_space(o)?;- }- CurrentColorSpace => {- let o = match &self.g.space_obj {- o @ Obj::Array { .. } => o.clone(),- o => Obj::array(vec![o.clone()]),- };- self.push(o)?;- }- SetColor => {- if let Space::Pattern(base) = &*self.g.space {- self.set_pattern(base.clone())?;- } else {- let n = self.g.space.n();- let mut c = vec![0.0; n];- for slot in c.iter_mut().rev() {- *slot = self.pop_num()?;- }- self.set_comps(c)?;- }- }- CurrentColor => {- for v in self.g.comps.clone() {- self.push_num(v)?;- }- }- // `[/Pattern <current space>] setcolorspace setcolor`, unless in a pattern space already.- SetPattern => {- if !matches!(*self.g.space, Space::Pattern(_)) {- self.g.space = Rc::new(Space::Pattern(Some(self.g.space.clone())));- self.g.space_obj = Obj::array(vec![Obj::name("Pattern"), self.g.space_obj.clone()]);- }- let Space::Pattern(base) = &*self.g.space else { return ps_err("typecheck", "") };- self.set_pattern(base.clone())?;- }- MakePattern => {- let m = self.pop_matrix()?;- let d = self.pop_dict()?;- let mut copy = d.borrow().clone();- copy.insert(Key::name("VCMatrix"), matrix_obj(self.g.ctm * m));- self.push(Obj::dict(copy))?;- }- SetOverprint => self.g.overprint = self.pop_bool()?,- CurrentOverprint => self.push(Obj::Bool(self.g.overprint))?,- SetFlat | SetHalftone | SetTransfer | SetBlackGeneration | SetUnderColorRemoval | SetColorRendering | SetSmoothness | SetStrokeAdjust- | SetPageDevice | SetUserParams | SetSystemParams => {- self.pop()?;- }- SetScreen => {- for _ in 0..3 {- self.pop()?;- }- }- SetColorTransfer => {- for _ in 0..4 {- self.pop()?;- }- }- SetColorScreen => {- for _ in 0..12 {- self.pop()?;- }- }- SetCacheLimit => {- self.pop()?;- }- SetUCacheParams => {- let at = self.stack.iter().rposition(|o| matches!(o, Obj::Mark)).ok_or(PsError::Ps("unmatchedmark", String::new()))?;- self.stack.truncate(at);- }- UCache => {}- CurrentScreen => {- self.push(Obj::Real(60.0))?;- self.push(Obj::Real(45.0))?;- self.push(Obj::proc(vec![]))?;- }- CurrentTransfer | CurrentBlackGeneration | CurrentUnderColorRemoval => self.push(Obj::proc(vec![]))?,- CurrentColorTransfer => {- for _ in 0..4 {- self.push(Obj::proc(vec![]))?;- }- }- CurrentHalftone => {- let mut d = super::obj::Dict::new();- d.insert(Key::name("HalftoneType"), Obj::Int(1));- d.insert(Key::name("Frequency"), Obj::Real(60.0));- d.insert(Key::name("Angle"), Obj::Real(45.0));- d.insert(Key::name("SpotFunction"), Obj::proc(vec![]));- self.push(Obj::dict(d))?;- }- FindEncoding => {- self.pop()?;- self.push(Obj::array(vec![Obj::name(".notdef"); 256]))?;- }- CurrentFlat => self.push(Obj::Real(1.0))?,- CurrentStrokeAdjust => self.push(Obj::Bool(false))?,- CurrentPageDevice => {- let mut d = super::obj::Dict::new();- let f = self.out.frame;- d.insert(Key::name("PageSize"), Obj::array(vec![Obj::Real(f.width()), Obj::Real(f.height())]));- self.push(Obj::dict(d))?;- }- // The cache and stack sizes programs read (they `get` them without asking first).- CurrentUserParams | CurrentSystemParams => {- let keys: &[&str] = if op == CurrentUserParams {- &["MaxFontItem", "MaxFormItem", "MaxPatternItem", "MaxUPathItem", "MaxOpStack", "MaxDictStack", "MaxExecStack"]- } else {- &["MaxFontCache", "MaxFormCache", "MaxPatternCache", "MaxUPathCache", "MaxScreenStorage", "MaxDisplayList"]- };- let d: super::obj::Dict = keys.iter().map(|k| (Key::name(k), Obj::Int(1 << 20))).collect();- self.push(Obj::dict(d))?;- }- ShowPage => return Err(PsError::Quit),- CopyPage | ErasePage => {}- Matrix => self.push(matrix_obj(Affine::IDENTITY))?,- IdentMatrix | DefaultMatrix => {- let items = self.pop_array()?;- self.put_matrix(items, Affine::IDENTITY)?;- }- CurrentMatrix => {- let items = self.pop_array()?;- self.put_matrix(items, self.g.ctm)?;- }- SetMatrix => self.g.ctm = self.pop_matrix()?,- InitMatrix => self.g.ctm = Affine::IDENTITY,- Concat => {- let m = self.pop_matrix()?;- self.g.ctm *= m;- }- ConcatMatrix => {- let out = self.pop_array()?;- let (m2, m1) = (self.pop_matrix()?, self.pop_matrix()?);- self.put_matrix(out, m2 * m1)?;- }- Translate | Scale | Rotate => {- let into = match self.stack.last() {- Some(Obj::Array { .. }) => Some(self.pop_array()?),- _ => None,- };- let m = match op {- Rotate => Affine::rotate(self.pop_num()?.to_radians()),- Translate => {- let [x, y] = self.nums()?;- Affine::translate((x, y))- }- _ => {- let [x, y] = self.nums()?;- Affine::scale_non_uniform(x, y)- }- };- match into {- Some(items) => self.put_matrix(items, m)?,- None => self.g.ctm *= m,- }- }- Transform | ITransform | DTransform | IDTransform => {- let m = match self.stack.last() {- Some(Obj::Array { .. }) => self.pop_matrix()?,- _ => self.g.ctm,- };- let [x, y] = self.nums()?;- let inverse = matches!(op, ITransform | IDTransform);- if inverse && m.determinant().abs() < 1e-12 {- return ps_err("undefinedresult", "");- }- let m = if inverse { m.inverse() } else { m };- let p = if matches!(op, DTransform | IDTransform) {- let v = m * Point::new(x, y) - m * Point::ZERO;- Point::new(v.x, v.y)- } else {- m * Point::new(x, y)- };- self.push_num(p.x)?;- self.push_num(p.y)?;- }- InvertMatrix => {- let out = self.pop_array()?;- let m = self.pop_matrix()?;- if m.determinant().abs() < 1e-12 {- return ps_err("undefinedresult", "");- }- self.put_matrix(out, m.inverse())?;- }- NewPath => {- self.take_path();- }- CurrentPoint => {- let p = self.user_point()?;- self.push_num(p.x)?;- self.push_num(p.y)?;- }- MoveTo => {- let [x, y] = self.nums()?;- let p = self.xf() * Point::new(x, y);- self.move_to(p)?;- }- RMoveTo => {- let [dx, dy] = self.nums()?;- let p = self.user_point()? + Vec2::new(dx, dy);- let p = self.xf() * p;- self.move_to(p)?;- }- LineTo => {- let [x, y] = self.nums()?;- self.line_to(self.xf() * Point::new(x, y))?;- }- RLineTo => {- let [dx, dy] = self.nums()?;- let p = self.user_point()? + Vec2::new(dx, dy);- self.line_to(self.xf() * p)?;- }- CurveTo | RCurveTo => {- let v = self.nums::<6>()?;- let o = if op == RCurveTo { self.user_point()?.to_vec2() } else { Vec2::ZERO };- if self.g.cur.is_none() {- return ps_err("nocurrentpoint", "");- }- let xf = self.xf();- let [a, b, p] = [0, 2, 4].map(|i| xf * (Point::new(v[i], v[i + 1]) + o));- self.grow()?;- self.g.path.curve_to(a, b, p);- self.g.cur = Some(p);- }- Arc | Arcn => {- let [x, y, r, a1, a2] = self.nums()?;- self.arc(Point::new(x, y), r, a1, a2, op == Arc)?;- }- Arct | Arcto => {- let [x1, y1, x2, y2, r] = self.nums()?;- let [t1, t2] = self.arct(Point::new(x1, y1), Point::new(x2, y2), r)?;- if op == Arcto {- for v in [t1.x, t1.y, t2.x, t2.y] {- self.push_num(v)?;- }- }- }- ClosePath => {- if self.g.cur.is_some() {- self.grow()?;- self.g.path.close_path();- self.g.cur = self.g.start;- }- }- FlattenPath | ReversePath => {}- PathBBox => {- if self.g.path.elements().is_empty() {- return ps_err("nocurrentpoint", "");- }- let xf = self.xf();- if xf.determinant().abs() < 1e-12 {- return ps_err("undefinedresult", "");- }- self.spend_elements(self.g.path.elements().len())?;- let b = xf.inverse().transform_rect_bbox(self.g.path.bounding_box());- for v in [b.x0, b.y0, b.x1, b.y1] {- self.push_num(v)?;- }- }- ClipPath => {- let b = self.clip_bounds()?;- self.take_path();- self.g.path = b.to_path(0.1);- self.g.cur = Some(b.origin());- self.g.start = self.g.cur;- }- InitClip => self.g.clips.clear(),- ClipSave => {- if self.g.saved_clips.len() >= MAX_GSAVE {- return Err(PsError::Limit("too many saved clips"));- }- self.alloc(std::mem::size_of_val(self.g.clips.as_slice()))?;- let clips = self.g.clips.as_slice().into();- self.g.saved_clips.push(clips);- }- ClipRestore => {- if let Some(clips) = self.g.saved_clips.pop() {- self.g.clips = clips.to_vec();- }- }- Clip | EoClip => {- self.spend_elements(self.g.path.elements().len())?;- let bp = self.g.path.clone();- self.clip_with(bp, if op == EoClip { FillRule::EvenOdd } else { FillRule::NonZero });- }- RectClip => {- let bp = self.rects()?;- self.take_path();- self.clip_with(bp, FillRule::NonZero);- }- Fill | EoFill => {- let bp = self.take_path();- self.fill_path(bp, if op == EoFill { FillRule::EvenOdd } else { FillRule::NonZero })?;- }- Stroke => {- let bp = self.take_path();- self.stroke_path(bp)?;- }- RectFill => {- let bp = self.rects()?;- self.fill_path(bp, FillRule::NonZero)?;- }- RectStroke => {- let m = match self.stack.last() {- Some(Obj::Array { items, .. }) if items.len() == 6 => Some(self.pop_matrix()?),- _ => None,- };- let mut bp = self.rects()?;- if let Some(m) = m {- let xf = self.xf();- bp.apply_affine(xf * m * xf.inverse());- }- self.stroke_path(bp)?;- }- ShFill => {- let d = self.pop_dict()?;- if self.g.null {- return Ok(());- }- if is_mesh(&d) {- let m = self.xf();- return self.mesh_fill(&d, m);- }- let m = self.xf();- if let Some(g) = self.gradient(&d, m)? {- let area = self.clip_bounds()?;- let paint = Paint::Gradient(Box::new(g));- let clips = self.g.clips.clone();- self.out.fill(area.to_path(0.1), FillRule::NonZero, paint, self.g.overprint, &clips);- if let Some((_, n)) = self.out.drawn.last() {- let id = n.id;- self.out.shadings.insert(id);- }- }- }- _ => self.data_op(op)?,- }- Ok(())- }-}--/// Is shading `sh` axial or radial (a gradient)?-fn is_gradient(sh: &DictRef) -> bool {- matches!(sh.borrow().get(&Key::name("ShadingType")).and_then(Obj::as_num), Some(2.0 | 3.0))-}--/// Is shading `sh` one [`Interp::mesh_fill`] paints?-fn is_mesh(sh: &DictRef) -> bool {- matches!(sh.borrow().get(&Key::name("ShadingType")).and_then(Obj::as_num), Some(1.0 | 4.0 | 5.0 | 6.0 | 7.0))-}--/// Where a stitched function of linear interpolations changes slope (its bounds), when it is-/// one; `None` for functions that must be sampled. `depth` bounds the nesting the same way-/// [`Interp::eval`] does (`> 8`) and `visits` (shared by the whole recursion, incremented on-/// every call) bounds the total nodes looked at. Both are needed: the depth limit alone stops a-/// function that refers to itself in a cycle, but not one that fans out through shared children-/// (1025 references to a child a few levels deep is 1025^levels nodes without the visit cap). A-/// well-formed stitch of linear pieces is one level, at most `MAX_STITCH_STOPS + 1` pieces, so it-/// costs at most `MAX_STITCH_STOPS + 2` visits and is never cut off.-fn linear_points(f: &Obj, depth: u32, visits: &mut usize) -> Option<Vec<f64>> {- *visits += 1;- if depth > 8 || *visits > 2 * (MAX_STITCH_STOPS + 1) {- return None;- }- let Obj::Dict(d) = f else { return None };- let d = d.borrow();- let num = |k: &str| d.get(&Key::name(k)).and_then(Obj::as_num);- match num("FunctionType")? {- 2.0 if num("N").unwrap_or(1.0) == 1.0 => Some(vec![]),- 3.0 => {- let items = d.get(&Key::name("Functions"))?.items()?;- // More pieces than the stop cap allows: sample the function instead (tested before- // `to_vec`, so a huge `Functions` array is not copied only to be rejected). Each stop- // runs [`Interp::eval`], which reads one piece, so a short `Bounds` with a huge- // `Functions` would still be O(stops * Functions) to find each piece without this.- if items.len() > MAX_STITCH_STOPS + 1 {- return None;- }- let fs = items.to_vec();- if !fs.iter().all(|g| linear_points(g, depth + 1, visits).is_some_and(|p| p.is_empty())) {- return None;- }- d.get(&Key::name("Bounds"))?.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())- }- _ => None,- }-}--/// The clip path a clipping group of one shading rectangle (`shfill` through a clip) can be-/// filled with instead.-pub(crate) fn collapse(nodes: &mut [Arc<Node>], shadings: &HashSet<NodeId>) {- for n in nodes.iter_mut() {- let NodeKind::Group { children, clip: true } = &n.kind else {- if let Some(c) = Arc::make_mut(n).children_mut() {- collapse(c, shadings);- }- continue;- };- if let [clip, fill] = children.as_slice()- && shadings.contains(&fill.id)- && let (NodeKind::Path { path, rule, clipping: true, .. }, NodeKind::Path { .. }) = (&clip.kind, &fill.kind)- {- let mut p = Node::path(fill.id, path.clone(), (*fill.appearance).clone());- if let NodeKind::Path { rule: r, .. } = &mut p.kind {- *r = *rule;- }- *n = Arc::new(p);- continue;- }- if let Some(c) = Arc::make_mut(n).children_mut() {- collapse(c, shadings);- }- }-}diff --git a/crates/eps/src/import/graphics/ops.rs b/crates/eps/src/import/graphics/ops.rsnew file mode 100644index 000000000..608a62413--- /dev/null+++ b/crates/eps/src/import/graphics/ops.rs@@ -0,0 +1,533 @@+use super::paint::is_mesh;+use super::state::{GState, Space};+use super::*;++impl Interp<'_> {+ // ---------- the operators ----------++ pub fn graphics_op(&mut self, op: Op) -> Res {+ use Op::*;+ match op {+ Gsave => self.gsave()?,+ Grestore => self.grestore(),+ GrestoreAll => {+ if let Some(g) = self.saved.first().cloned() {+ self.saved.clear();+ self.g = g;+ }+ }+ InitGraphics => {+ let font = self.g.font.take();+ self.g = GState { font, null: self.g.null, ..GState::default() };+ }+ NullDevice => {+ self.g.null = true;+ self.g.ctm = Affine::IDENTITY;+ self.g.clips.clear();+ }+ ExecForm => self.exec_form()?,+ StrokePath => {+ let bp = self.take_path();+ let mut st = self.stroke_layer()?;+ // A dash pattern far finer than the path would make countless pieces.+ let period: f64 = st.dash.as_ref().map_or(0.0, |d| d.pattern.iter().sum());+ let periods = if st.dash.is_some() && period > 0.0 { bp.perimeter(1e-3) / period } else { 0.0 };+ if st.dash.is_some() && !(period > 0.0 && periods < MAX_DASHES) {+ st.dash = None;+ }+ let tol = (0.01 / self.scale().max(1e-9)).clamp(1e-4, 1.0);+ let outline = vectorcraft_effects::stroke::line_outline(&bp, &st, st.width, tol);+ // The path, each entry of the dash pattern in each period, and the outline count+ // as elements.+ let dashes = st.dash.as_ref().map_or(0.0, |d| periods * d.pattern.len() as f64) as usize;+ self.spend_elements(bp.elements().len().saturating_add(dashes).saturating_add(outline.elements().len()))?;+ if outline.elements().len() >= MAX_PATH {+ return Err(PsError::Limit("a path has too many points"));+ }+ self.g.cur = outline.elements().iter().rev().find_map(|e| e.end_point());+ self.g.start = self.g.cur;+ self.g.path = outline;+ }+ PathForAll => self.path_for_all()?,+ UFill | UEoFill | UStroke => self.paint_user_path(op)?,+ UAppend => {+ let up = self.pop()?;+ self.user_path(up)?;+ }+ UPath => self.upath()?,+ SetBBox => {+ self.nums::<4>()?;+ }+ CurrentHsbColor => {+ let [r, g, b] = self.current_rgb();+ let (max, min) = (r.max(g).max(b), r.min(g).min(b));+ let d = max - min;+ let h = if d <= 0.0 {+ 0.0+ } else if max == r {+ ((g - b) / d).rem_euclid(6.0) / 6.0+ } else if max == g {+ ((b - r) / d + 2.0) / 6.0+ } else {+ ((r - g) / d + 4.0) / 6.0+ };+ let s = if max > 0.0 { d / max } else { 0.0 };+ for v in [h, s, max] {+ self.push_num(f64::from(v))?;+ }+ }+ CurrentColorRendering => {+ let d = crate::import::obj::Dict::from([(Key::name("ColorRenderingType"), Obj::Int(1))]);+ self.push(Obj::dict(d))?;+ }+ FindColorRendering => {+ self.pop()?;+ self.push(Obj::name("DefaultColorRendering"))?;+ self.push(Obj::Bool(false))?;+ }+ CurrentColorScreen => {+ for _ in 0..4 {+ self.push(Obj::Real(60.0))?;+ self.push(Obj::Real(45.0))?;+ self.push(Obj::proc(vec![]))?;+ }+ }+ CurrentSmoothness => self.push(Obj::Real(0.02))?,+ SetHalftonePhase => {+ self.nums::<2>()?;+ }+ CurrentHalftonePhase => {+ self.push(Obj::Int(0))?;+ self.push(Obj::Int(0))?;+ }+ GStateNew => {+ self.spend_elements(self.g.path.elements().len())?;+ self.alloc(std::mem::size_of_val(self.g.path.elements()))?;+ self.push(Obj::GState(Rc::new(self.g.clone())))?;+ }+ CurrentGState => {+ self.pop()?;+ self.spend_elements(self.g.path.elements().len())?;+ self.alloc(std::mem::size_of_val(self.g.path.elements()))?;+ self.push(Obj::GState(Rc::new(self.g.clone())))?;+ }+ SetGState => match self.pop()? {+ Obj::GState(g) => {+ self.spend_elements(g.path.elements().len())?;+ self.g = (*g).clone();+ }+ _ => return ps_err("typecheck", ""),+ },+ SetLineWidth => self.g.width = self.pop_num()?.abs(),+ CurrentLineWidth => self.push_num(self.g.width)?,+ SetLineCap => {+ self.g.cap = match self.pop_int()? {+ 1 => LineCap::Round,+ 2 => LineCap::Square,+ _ => LineCap::Butt,+ }+ }+ CurrentLineCap => self.push(Obj::Int(self.g.cap as i64))?,+ SetLineJoin => {+ self.g.join = match self.pop_int()? {+ 1 => LineJoin::Round,+ 2 => LineJoin::Bevel,+ _ => LineJoin::Miter,+ }+ }+ CurrentLineJoin => self.push(Obj::Int(self.g.join as i64))?,+ SetMiterLimit => self.g.miter = self.pop_num()?,+ CurrentMiterLimit => self.push_num(self.g.miter)?,+ SetDash => {+ let offset = self.pop_num()?;+ let items = self.pop_array()?;+ if items.len() > MAX_DASH_ENTRIES {+ return ps_err("limitcheck", "");+ }+ // Each entry read counts as an operation.+ self.spend(items.len() as u64)?;+ let v: Option<Vec<f64>> = items.borrow().iter().map(|o| o.as_num().filter(|v| v.is_finite() && *v >= 0.0)).collect();+ self.g.dash = v.ok_or(PsError::Ps("typecheck", String::new()))?.into();+ self.g.dash_offset = offset;+ }+ CurrentDash => {+ // The array made counts against the memory budget.+ self.alloc(self.g.dash.len() * std::mem::size_of::<Obj>())?;+ let d = self.g.dash.iter().map(|v| Obj::Real(*v)).collect();+ self.push(Obj::array(d))?;+ self.push_num(self.g.dash_offset)?;+ }+ SetGray => {+ let [g] = self.nums()?;+ self.set_process(Space::Gray, "DeviceGray", vec![g])?;+ }+ SetRgbColor => {+ let c = self.nums::<3>()?;+ self.set_process(Space::Rgb, "DeviceRGB", c.to_vec())?;+ }+ SetHsbColor => {+ let [h, s, b] = self.nums()?;+ let [r, g, bl] =+ Color::from_hsb((h.rem_euclid(1.0) * 360.0) as f32, s.clamp(0.0, 1.0) as f32, b.clamp(0.0, 1.0) as f32).to_rgb_uncalibrated();+ self.set_process(Space::Rgb, "DeviceRGB", vec![f64::from(r), f64::from(g), f64::from(bl)])?;+ }+ SetCmykColor => {+ let c = self.nums::<4>()?;+ self.set_process(Space::Cmyk, "DeviceCMYK", c.to_vec())?;+ }+ CurrentGray => {+ let [r, g, b] = self.current_rgb();+ self.push_num(f64::from(0.3 * r + 0.59 * g + 0.11 * b))?;+ }+ CurrentRgbColor => {+ for v in self.current_rgb() {+ self.push_num(f64::from(v))?;+ }+ }+ CurrentCmykColor => {+ let c = self.g.paint.color().map_or([0.0, 0.0, 0.0, 1.0], |c| c.to_cmyk());+ for v in c {+ self.push_num(f64::from(v))?;+ }+ }+ SetColorSpace => {+ let o = self.pop()?;+ self.set_space(o)?;+ }+ CurrentColorSpace => {+ let o = match &self.g.space_obj {+ o @ Obj::Array { .. } => o.clone(),+ o => Obj::array(vec![o.clone()]),+ };+ self.push(o)?;+ }+ SetColor => {+ if let Space::Pattern(base) = &*self.g.space {+ self.set_pattern(base.clone())?;+ } else {+ let n = self.g.space.n();+ let mut c = vec![0.0; n];+ for slot in c.iter_mut().rev() {+ *slot = self.pop_num()?;+ }+ self.set_comps(c)?;+ }+ }+ CurrentColor => {+ for v in self.g.comps.clone() {+ self.push_num(v)?;+ }+ }+ // `[/Pattern <current space>] setcolorspace setcolor`, unless in a pattern space already.+ SetPattern => {+ if !matches!(*self.g.space, Space::Pattern(_)) {+ self.g.space = Rc::new(Space::Pattern(Some(self.g.space.clone())));+ self.g.space_obj = Obj::array(vec![Obj::name("Pattern"), self.g.space_obj.clone()]);+ }+ let Space::Pattern(base) = &*self.g.space else { return ps_err("typecheck", "") };+ self.set_pattern(base.clone())?;+ }+ MakePattern => {+ let m = self.pop_matrix()?;+ let d = self.pop_dict()?;+ let mut copy = d.borrow().clone();+ copy.insert(Key::name("VCMatrix"), matrix_obj(self.g.ctm * m));+ self.push(Obj::dict(copy))?;+ }+ SetOverprint => self.g.overprint = self.pop_bool()?,+ CurrentOverprint => self.push(Obj::Bool(self.g.overprint))?,+ SetFlat | SetHalftone | SetTransfer | SetBlackGeneration | SetUnderColorRemoval | SetColorRendering | SetSmoothness | SetStrokeAdjust+ | SetPageDevice | SetUserParams | SetSystemParams => {+ self.pop()?;+ }+ SetScreen => {+ for _ in 0..3 {+ self.pop()?;+ }+ }+ SetColorTransfer => {+ for _ in 0..4 {+ self.pop()?;+ }+ }+ SetColorScreen => {+ for _ in 0..12 {+ self.pop()?;+ }+ }+ SetCacheLimit => {+ self.pop()?;+ }+ SetUCacheParams => {+ let at = self.stack.iter().rposition(|o| matches!(o, Obj::Mark)).ok_or(PsError::Ps("unmatchedmark", String::new()))?;+ self.stack.truncate(at);+ }+ UCache => {}+ CurrentScreen => {+ self.push(Obj::Real(60.0))?;+ self.push(Obj::Real(45.0))?;+ self.push(Obj::proc(vec![]))?;+ }+ CurrentTransfer | CurrentBlackGeneration | CurrentUnderColorRemoval => self.push(Obj::proc(vec![]))?,+ CurrentColorTransfer => {+ for _ in 0..4 {+ self.push(Obj::proc(vec![]))?;+ }+ }+ CurrentHalftone => {+ let mut d = crate::import::obj::Dict::new();+ d.insert(Key::name("HalftoneType"), Obj::Int(1));+ d.insert(Key::name("Frequency"), Obj::Real(60.0));+ d.insert(Key::name("Angle"), Obj::Real(45.0));+ d.insert(Key::name("SpotFunction"), Obj::proc(vec![]));+ self.push(Obj::dict(d))?;+ }+ FindEncoding => {+ self.pop()?;+ self.push(Obj::array(vec![Obj::name(".notdef"); 256]))?;+ }+ CurrentFlat => self.push(Obj::Real(1.0))?,+ CurrentStrokeAdjust => self.push(Obj::Bool(false))?,+ CurrentPageDevice => {+ let mut d = crate::import::obj::Dict::new();+ let f = self.out.frame;+ d.insert(Key::name("PageSize"), Obj::array(vec![Obj::Real(f.width()), Obj::Real(f.height())]));+ self.push(Obj::dict(d))?;+ }+ // The cache and stack sizes programs read (they `get` them without asking first).+ CurrentUserParams | CurrentSystemParams => {+ let keys: &[&str] = if op == CurrentUserParams {+ &["MaxFontItem", "MaxFormItem", "MaxPatternItem", "MaxUPathItem", "MaxOpStack", "MaxDictStack", "MaxExecStack"]+ } else {+ &["MaxFontCache", "MaxFormCache", "MaxPatternCache", "MaxUPathCache", "MaxScreenStorage", "MaxDisplayList"]+ };+ let d: crate::import::obj::Dict = keys.iter().map(|k| (Key::name(k), Obj::Int(1 << 20))).collect();+ self.push(Obj::dict(d))?;+ }+ ShowPage => return Err(PsError::Quit),+ CopyPage | ErasePage => {}+ Matrix => self.push(matrix_obj(Affine::IDENTITY))?,+ IdentMatrix | DefaultMatrix => {+ let items = self.pop_array()?;+ self.put_matrix(items, Affine::IDENTITY)?;+ }+ CurrentMatrix => {+ let items = self.pop_array()?;+ self.put_matrix(items, self.g.ctm)?;+ }+ SetMatrix => self.g.ctm = self.pop_matrix()?,+ InitMatrix => self.g.ctm = Affine::IDENTITY,+ Concat => {+ let m = self.pop_matrix()?;+ self.g.ctm *= m;+ }+ ConcatMatrix => {+ let out = self.pop_array()?;+ let (m2, m1) = (self.pop_matrix()?, self.pop_matrix()?);+ self.put_matrix(out, m2 * m1)?;+ }+ Translate | Scale | Rotate => {+ let into = match self.stack.last() {+ Some(Obj::Array { .. }) => Some(self.pop_array()?),+ _ => None,+ };+ let m = match op {+ Rotate => Affine::rotate(self.pop_num()?.to_radians()),+ Translate => {+ let [x, y] = self.nums()?;+ Affine::translate((x, y))+ }+ _ => {+ let [x, y] = self.nums()?;+ Affine::scale_non_uniform(x, y)+ }+ };+ match into {+ Some(items) => self.put_matrix(items, m)?,+ None => self.g.ctm *= m,+ }+ }+ Transform | ITransform | DTransform | IDTransform => {+ let m = match self.stack.last() {+ Some(Obj::Array { .. }) => self.pop_matrix()?,+ _ => self.g.ctm,+ };+ let [x, y] = self.nums()?;+ let inverse = matches!(op, ITransform | IDTransform);+ if inverse && m.determinant().abs() < 1e-12 {+ return ps_err("undefinedresult", "");+ }+ let m = if inverse { m.inverse() } else { m };+ let p = if matches!(op, DTransform | IDTransform) {+ let v = m * Point::new(x, y) - m * Point::ZERO;+ Point::new(v.x, v.y)+ } else {+ m * Point::new(x, y)+ };+ self.push_num(p.x)?;+ self.push_num(p.y)?;+ }+ InvertMatrix => {+ let out = self.pop_array()?;+ let m = self.pop_matrix()?;+ if m.determinant().abs() < 1e-12 {+ return ps_err("undefinedresult", "");+ }+ self.put_matrix(out, m.inverse())?;+ }+ NewPath => {+ self.take_path();+ }+ CurrentPoint => {+ let p = self.user_point()?;+ self.push_num(p.x)?;+ self.push_num(p.y)?;+ }+ MoveTo => {+ let [x, y] = self.nums()?;+ let p = self.xf() * Point::new(x, y);+ self.move_to(p)?;+ }+ RMoveTo => {+ let [dx, dy] = self.nums()?;+ let p = self.user_point()? + Vec2::new(dx, dy);+ let p = self.xf() * p;+ self.move_to(p)?;+ }+ LineTo => {+ let [x, y] = self.nums()?;+ self.line_to(self.xf() * Point::new(x, y))?;+ }+ RLineTo => {+ let [dx, dy] = self.nums()?;+ let p = self.user_point()? + Vec2::new(dx, dy);+ self.line_to(self.xf() * p)?;+ }+ CurveTo | RCurveTo => {+ let v = self.nums::<6>()?;+ let o = if op == RCurveTo { self.user_point()?.to_vec2() } else { Vec2::ZERO };+ if self.g.cur.is_none() {+ return ps_err("nocurrentpoint", "");+ }+ let xf = self.xf();+ let [a, b, p] = [0, 2, 4].map(|i| xf * (Point::new(v[i], v[i + 1]) + o));+ self.grow()?;+ self.g.path.curve_to(a, b, p);+ self.g.cur = Some(p);+ }+ Arc | Arcn => {+ let [x, y, r, a1, a2] = self.nums()?;+ self.arc(Point::new(x, y), r, a1, a2, op == Arc)?;+ }+ Arct | Arcto => {+ let [x1, y1, x2, y2, r] = self.nums()?;+ let [t1, t2] = self.arct(Point::new(x1, y1), Point::new(x2, y2), r)?;+ if op == Arcto {+ for v in [t1.x, t1.y, t2.x, t2.y] {+ self.push_num(v)?;+ }+ }+ }+ ClosePath => {+ if self.g.cur.is_some() {+ self.grow()?;+ self.g.path.close_path();+ self.g.cur = self.g.start;+ }+ }+ FlattenPath | ReversePath => {}+ PathBBox => {+ if self.g.path.elements().is_empty() {+ return ps_err("nocurrentpoint", "");+ }+ let xf = self.xf();+ if xf.determinant().abs() < 1e-12 {+ return ps_err("undefinedresult", "");+ }+ self.spend_elements(self.g.path.elements().len())?;+ let b = xf.inverse().transform_rect_bbox(self.g.path.bounding_box());+ for v in [b.x0, b.y0, b.x1, b.y1] {+ self.push_num(v)?;+ }+ }+ ClipPath => {+ let b = self.clip_bounds()?;+ self.take_path();+ self.g.path = b.to_path(0.1);+ self.g.cur = Some(b.origin());+ self.g.start = self.g.cur;+ }+ InitClip => self.g.clips.clear(),+ ClipSave => {+ if self.g.saved_clips.len() >= MAX_GSAVE {+ return Err(PsError::Limit("too many saved clips"));+ }+ self.alloc(std::mem::size_of_val(self.g.clips.as_slice()))?;+ let clips = self.g.clips.as_slice().into();+ self.g.saved_clips.push(clips);+ }+ ClipRestore => {+ if let Some(clips) = self.g.saved_clips.pop() {+ self.g.clips = clips.to_vec();+ }+ }+ Clip | EoClip => {+ self.spend_elements(self.g.path.elements().len())?;+ let bp = self.g.path.clone();+ self.clip_with(bp, if op == EoClip { FillRule::EvenOdd } else { FillRule::NonZero });+ }+ RectClip => {+ let bp = self.rects()?;+ self.take_path();+ self.clip_with(bp, FillRule::NonZero);+ }+ Fill | EoFill => {+ let bp = self.take_path();+ self.fill_path(bp, if op == EoFill { FillRule::EvenOdd } else { FillRule::NonZero })?;+ }+ Stroke => {+ let bp = self.take_path();+ self.stroke_path(bp)?;+ }+ RectFill => {+ let bp = self.rects()?;+ self.fill_path(bp, FillRule::NonZero)?;+ }+ RectStroke => {+ let m = match self.stack.last() {+ Some(Obj::Array { items, .. }) if items.len() == 6 => Some(self.pop_matrix()?),+ _ => None,+ };+ let mut bp = self.rects()?;+ if let Some(m) = m {+ let xf = self.xf();+ bp.apply_affine(xf * m * xf.inverse());+ }+ self.stroke_path(bp)?;+ }+ ShFill => {+ let d = self.pop_dict()?;+ if self.g.null {+ return Ok(());+ }+ if is_mesh(&d) {+ let m = self.xf();+ return self.mesh_fill(&d, m);+ }+ let m = self.xf();+ if let Some(g) = self.gradient(&d, m)? {+ let area = self.clip_bounds()?;+ let paint = Paint::Gradient(Box::new(g));+ let clips = self.g.clips.clone();+ self.out.fill(area.to_path(0.1), FillRule::NonZero, paint, self.g.overprint, &clips);+ if let Some((_, n)) = self.out.drawn.last() {+ let id = n.id;+ self.out.shadings.insert(id);+ }+ }+ }+ _ => self.data_op(op)?,+ }+ Ok(())+ }+}diff --git a/crates/eps/src/import/graphics/paint.rs b/crates/eps/src/import/graphics/paint.rsnew file mode 100644index 000000000..f2e343858--- /dev/null+++ b/crates/eps/src/import/graphics/paint.rs@@ -0,0 +1,495 @@+use super::state::{GState, Space, process, tiling_hash};+use super::*;++impl Interp<'_> {+ // ---------- colour ----------++ /// A colour space operand.+ pub(in super::super) fn space_of(&mut self, o: &Obj, depth: u32) -> Res<Space> {+ if depth > 4 {+ return ps_err("limitcheck", "setcolorspace");+ }+ let (family, items) = match o {+ Obj::Name(n) | Obj::Exec(n) => (n.clone(), vec![]),+ Obj::Array { items, .. } => {+ let v = items.to_vec();+ let n = v.first().and_then(Obj::text).ok_or(PsError::Ps("typecheck", "setcolorspace".into()))?;+ (n, v)+ }+ _ => return ps_err("typecheck", "setcolorspace"),+ };+ let arg = |i: usize| items.get(i).cloned().ok_or(PsError::Ps("rangecheck", "setcolorspace".into()));+ Ok(match &*family {+ "DeviceGray" | "CIEBasedA" | "CalGray" => Space::Gray,+ "DeviceRGB" | "CIEBasedABC" | "CalRGB" | "Lab" | "CIEBasedDEF" => Space::Rgb,+ "DeviceCMYK" | "CIEBasedDEFG" => Space::Cmyk,+ "Pattern" => Space::Pattern(match items.get(1) {+ Some(base) => Some(Rc::new(self.space_of(base, depth + 1)?)),+ None => None,+ }),+ "ICCBased" => match arg(1)? {+ Obj::Dict(d) => match d.borrow().get(&Key::name("N")).and_then(Obj::as_num) {+ Some(1.0) => Space::Gray,+ Some(4.0) => Space::Cmyk,+ _ => Space::Rgb,+ },+ _ => Space::Rgb,+ },+ "Separation" | "DeviceN" => {+ let names: Vec<Rc<str>> = match arg(1)? {+ Obj::Array { items, .. } => items.borrow().iter().filter_map(Obj::text).collect(),+ o => o.text().into_iter().collect(),+ };+ if names.len() > MAX_INKS {+ return ps_err("limitcheck", "DeviceN");+ }+ let alt = self.space_of(&arg(2)?, depth + 1)?;+ Space::Inks { names, alt: Rc::new(alt), tint: arg(3)? }+ }+ "Indexed" => {+ let base = self.space_of(&arg(1)?, depth + 1)?;+ let hival =+ arg(2)?.as_num().filter(|v| (0.0..=MAX_HIVAL as f64).contains(v)).ok_or(PsError::Ps("rangecheck", "Indexed".into()))? as usize;+ let n = base.n();+ let table: Vec<f64> = match arg(3)? {+ Obj::Str(s) => s.borrow().iter().map(|b| f64::from(*b) / 255.0).collect(),+ p @ Obj::Array { .. } => {+ let mut t = Vec::with_capacity((hival + 1) * n);+ for i in 0..=hival {+ self.push(Obj::Int(i as i64))?;+ self.call(p.clone())?;+ let mut c = vec![0.0; n];+ for slot in c.iter_mut().rev() {+ *slot = self.pop_num()?;+ }+ t.extend(c);+ }+ t+ }+ _ => return ps_err("typecheck", "Indexed"),+ };+ Space::Indexed { base: Rc::new(base), table: Rc::new(table) }+ }+ _ => return ps_err("undefined", &family),+ })+ }++ pub(super) fn set_space(&mut self, o: Obj) -> Res {+ let space = self.space_of(&o, 0)?;+ let comps = space.initial();+ self.g.space = Rc::new(space);+ self.g.space_obj = o;+ self.set_comps(comps)+ }++ /// Set the colour to `comps` in the current space.+ pub(super) fn set_comps(&mut self, comps: Vec<f64>) -> Res {+ let space = self.g.space.clone();+ self.g.mesh = None;+ self.g.paint = self.paint_of(&space, &comps)?;+ self.g.comps = comps;+ Ok(())+ }++ /// Set a process colour, its space with it.+ pub(super) fn set_process(&mut self, space: Space, name: &str, comps: Vec<f64>) -> Res {+ self.g.space = Rc::new(space);+ self.g.space_obj = Obj::name(name);+ self.set_comps(comps)+ }++ /// The paint of colour `comps` in `space`: a spot ink links to its swatch at the tint.+ pub fn paint_of(&mut self, space: &Space, comps: &[f64]) -> Res<Paint> {+ Ok(match space {+ Space::Inks { names, alt, tint } => {+ let t = comps.first().copied().unwrap_or(1.0).clamp(0.0, 1.0) as f32;+ match names.as_slice() {+ [one] if &**one == "None" => Paint::None,+ [one] if &**one == "All" => {+ Paint::Solid { color: Color::cmyk(1.0, 1.0, 1.0, 1.0).tinted(t), swatch: Some(REGISTRATION.into()), tint: t }+ }+ [one] => {+ let full = match self.out.spot_colors.get(one) {+ Some(c) => *c,+ None => {+ let c = self.tint_color(alt, tint, &[1.0])?;+ self.out.spots.push((one.to_string(), c));+ // The tint transform may have listed this ink already: the color+ // listed first stays.+ self.out.spot_colors.entry(one.clone()).or_insert(c);+ c+ }+ };+ Paint::Solid { color: full.tinted(t), swatch: Some(one.to_string()), tint: t }+ }+ _ => Paint::solid(self.tint_color(alt, tint, comps)?),+ }+ }+ Space::Indexed { base, table } => {+ let n = base.n();+ let i = comps.first().copied().unwrap_or(0.0).round().max(0.0) as usize;+ let c = table.get(i * n..i * n + n).ok_or(PsError::Ps("rangecheck", "setcolor".into()))?.to_vec();+ Paint::solid(process(base, &c).unwrap_or(Color::BLACK))+ }+ Space::Pattern(_) => Paint::None,+ s => Paint::solid(process(s, comps).unwrap_or(Color::BLACK)),+ })+ }++ /// The alternate colour of inks at `comps`, through the tint transform.+ pub fn tint_color(&mut self, alt: &Space, tint: &Obj, comps: &[f64]) -> Res<Color> {+ let base = self.stack.len();+ for c in comps {+ self.push_num(*c)?;+ }+ self.call(tint.clone())?;+ let n = alt.n();+ let at = self.stack.len().checked_sub(n).filter(|a| *a >= base).ok_or(PsError::Ps("stackunderflow", "tint transform".into()))?;+ let v: Vec<f64> = self.stack.split_off(at).iter().map(|o| o.as_num().unwrap_or(0.0)).collect();+ self.stack.truncate(base);+ Ok(process(alt, &v).unwrap_or(Color::BLACK))+ }++ /// The current colour as grey, RGB or CMYK components (`currentgray` …).+ pub(super) fn current_rgb(&self) -> [f32; 3] {+ self.g.paint.color().map_or([0.0; 3], |c| c.to_rgb_uncalibrated())+ }++ /// `setcolor` in a pattern space: the pattern operand, and before it an uncoloured+ /// pattern's colour in the underlying space.+ pub(super) fn set_pattern(&mut self, base: Option<Rc<Space>>) -> Res {+ let Obj::Dict(d) = self.pop()? else { return ps_err("typecheck", "") };+ let uncoloured = d.borrow().get(&Key::name("PaintType")).and_then(Obj::as_num) == Some(2.0);+ let under = match base.filter(|_| uncoloured) {+ Some(base) => {+ let mut c = vec![0.0; base.n()];+ for slot in c.iter_mut().rev() {+ *slot = self.pop_num()?;+ }+ Some(self.paint_of(&base, &c)?)+ }+ None => None,+ };+ self.g.mesh = None;+ self.g.paint = self.pattern_paint(&d, under)?;+ Ok(())+ }++ /// A pattern colour: a shading pattern's gradient, a tiling pattern's swatch (`under`: the+ /// colour an uncoloured one paints in).+ fn pattern_paint(&mut self, d: &DictRef, under: Option<Paint>) -> Res<Paint> {+ let kind = d.borrow().get(&Key::name("PatternType")).and_then(Obj::as_num);+ let sh = d.borrow().get(&Key::name("Shading")).cloned();+ let m = d.borrow().get(&Key::name("VCMatrix")).and_then(|o| o.items().and_then(|i| crate::import::interp::matrix_of(&i.borrow())));+ // Pattern space → the document.+ let m = self.out.page * m.unwrap_or(self.g.ctm);+ match (kind, sh) {+ (Some(2.0), Some(Obj::Dict(sh))) if is_mesh(&sh) => {+ self.g.mesh = Some((sh, m));+ Ok(Paint::None)+ }+ (Some(2.0), Some(Obj::Dict(sh))) => Ok(self.gradient(&sh, m)?.map_or(Paint::None, |g| Paint::Gradient(Box::new(g)))),+ (Some(2.0), _) => ps_err("typecheck", "Shading"),+ _ => self.tiling(d, under, m),+ }+ }++ /// A tiling pattern as a pattern swatch (made the first time): its `PaintProc` drawn in+ /// pattern space, one cell of `XStep` × `YStep` from the corner of its `BBox`; `m` maps pattern+ /// space onto the document.+ fn tiling(&mut self, d: &DictRef, under: Option<Paint>, m: Affine) -> Res<Paint> {+ let get = |k: &str| d.borrow().get(&Key::name(k)).cloned();+ let bbox: Vec<f64> = get("BBox").and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default();+ let [x0, y0, x1, y1] = bbox[..] else { return ps_err("rangecheck", "BBox") };+ let step = |k: &str| get(k).and_then(|o| o.as_num()).map(f64::abs).filter(|v| v.is_finite() && *v > 1e-9 && *v < LIMIT);+ let (Some(xs), Some(ys)) = (step("XStep"), step("YStep")) else { return ps_err("rangecheck", "XStep") };+ let tile = Rect::from_origin_size((x0.min(x1), y0.min(y1)), (xs, ys));+ let xf = m * Affine::translate(tile.origin().to_vec2());+ let proc = get("PaintProc").ok_or(PsError::Ps("undefined", "PaintProc".into()))?;+ let key = proc.items().cloned().ok_or(PsError::Ps("typecheck", "PaintProc".into()))?;+ let hash = tiling_hash(&key, tile, under.as_ref());+ let made = self.out.tilings.get(&hash).and_then(|list| list.iter().find(|(p, t, u, _)| p.same(&key) && *t == tile && *u == under));+ if let Some((.., name)) = made {+ return Ok(Paint::Pattern { pattern: name.clone(), xf });+ }+ if self.out.apart >= MAX_APART {+ self.out.warn(NESTED_PATTERNS);+ return Ok(Paint::solid(Color::gray(0.5)));+ }+ let paint = under.clone();+ let art = self.draw_apart(Rect::new(x0, y0, x1, y1).abs(), |it| {+ if let Some(p) = paint {+ it.g.paint = p;+ }+ it.push(Obj::Dict(d.clone()))?;+ it.call(proc)+ })?;+ if art.is_empty() {+ return Ok(Paint::None);+ }+ // The document gets its patterns only here, so the n made so far are Pattern 1 to+ // Pattern n.+ let name = format!("Pattern {}", self.out.doc.patterns.len() + 1);+ let mut def = PatternDef::new(&name, art);+ def.tile = tile;+ self.out.doc.patterns.push(def);+ // A cell with a NaN corner equals no cell, so the lookup above could never find it.+ if !tile.is_nan() {+ self.out.tilings.entry(hash).or_insert_with(|| Vec::with_capacity(1)).push((key, tile, under, name.clone()));+ }+ Ok(Paint::Pattern { pattern: name, xf })+ }++ /// The art `draw` draws on its own, in its own space (user space is the document's, the page+ /// `frame`), from a fresh graphics state with the current font: a pattern's cell, a glyph.+ pub fn draw_apart(&mut self, frame: Rect, draw: impl FnOnce(&mut Self) -> Res) -> Res<Vec<Arc<Node>>> {+ let fresh = GState { font: self.g.font.clone(), ..GState::default() };+ let g = std::mem::replace(&mut self.g, fresh);+ let saved = std::mem::take(&mut self.saved);+ let drawn = std::mem::take(&mut self.out.drawn);+ let page = std::mem::replace(&mut self.out.page, Affine::IDENTITY);+ let frame = std::mem::replace(&mut self.out.frame, frame);+ let merge = self.out.merge.take();+ // The art isn't in the groups open around it.+ let groups = std::mem::take(&mut self.out.groups);+ let too_deep = std::mem::take(&mut self.out.too_deep);+ self.out.apart += 1;+ let r = draw(self);+ self.out.apart -= 1;+ let art = std::mem::replace(&mut self.out.drawn, drawn);+ (self.out.page, self.out.frame, self.out.merge) = (page, frame, merge);+ (self.out.groups, self.out.too_deep) = (groups, too_deep);+ (self.g, self.saved) = (g, saved);+ r?;+ let mut nodes = vectorcraft_doc::clipnest::nest(&mut self.out.doc, art);+ if !self.out.shadings.is_empty() {+ collapse(&mut nodes, &self.out.shadings);+ }+ Ok(nodes)+ }++ /// An axial or radial shading as a gradient, `m` mapping its space onto the document.+ pub(super) fn gradient(&mut self, sh: &DictRef, m: Affine) -> Res<Option<GradientPaint>> {+ let get = |k: &str| sh.borrow().get(&Key::name(k)).cloned();+ let kind = get("ShadingType").and_then(|o| o.as_num()).unwrap_or(0.0);+ if !is_gradient(sh) {+ self.out.warn(UNKNOWN_SHADINGS);+ return Ok(None);+ }+ let space = self.space_of(&get("ColorSpace").ok_or(PsError::Ps("undefined", "ColorSpace".into()))?, 0)?;+ let nums = |o: Option<Obj>| -> Vec<f64> {+ o.and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default()+ };+ let coords = nums(get("Coords"));+ let domain = nums(get("Domain"));+ let (d0, d1) = (domain.first().copied().unwrap_or(0.0), domain.get(1).copied().unwrap_or(1.0));+ let f = get("Function").ok_or(PsError::Ps("undefined", "Function".into()))?;+ // Where the colour changes: the ends, and the bounds of stitched linear functions (unless+ // there are too many).+ let mut visits = 0;+ let points = linear_points(&f, 0, &mut visits).filter(|p| p.len() <= MAX_STITCH_STOPS);+ let stitched = points.is_some();+ let ts: Vec<f64> = match points {+ Some(mut pts) => {+ pts.retain(|t| (d0.min(d1)..=d0.max(d1)).contains(t));+ pts.iter().map(|t| if d1 != d0 { (t - d0) / (d1 - d0) } else { 0.0 }).chain([0.0, 1.0]).collect()+ }+ None => (0..=SHADING_SAMPLES).map(|i| i as f64 / SHADING_SAMPLES as f64).collect(),+ };+ let mut ts = ts;+ ts.sort_by(f64::total_cmp);+ ts.dedup_by(|a, b| (*a - *b).abs() < 1e-9);+ let radial = kind == 3.0;+ let c = |i: usize| coords.get(i).copied().unwrap_or(0.0);+ let (r0, r1) = (c(2).max(0.0), c(5).max(1e-6));+ let mut stops = Vec::with_capacity(ts.len());+ let stop = |paint: Paint, offset: f64| match paint {+ Paint::Solid { color, swatch, tint } => GradientStop { swatch, tint, ..GradientStop::new(offset as f32, color) },+ _ => GradientStop::new(offset as f32, Color::BLACK),+ };+ for t in ts {+ let comps = self.eval(&f, &[d0 + (d1 - d0) * t], 0)?;+ let paint = self.paint_of(&space, &comps)?;+ let offset = if radial { (r0 + (r1 - r0) * t) / r1 } else { t };+ // At a bound of a stitched function the pieces need not meet (a hard colour change):+ // the colour just before the bound is a stop at the same offset, ahead of the one+ // after it.+ if stitched && t > 0.0 && t < 1.0 {+ let comps = self.eval(&f, &[d0 + (d1 - d0) * (t - 1e-9)], 0)?;+ let before = stop(self.paint_of(&space, &comps)?, offset);+ if before.color != stop(paint.clone(), offset).color {+ stops.push(before);+ }+ }+ stops.push(stop(paint, offset));+ }+ let (gk, geom) = if radial {+ let centre = Point::new(c(3), c(4));+ let mut geom = GradientGeom { start: centre, end: centre + Vec2::new(r1, 0.0), aspect: 1.0, focal: None };+ geom.set_focal(Some(Point::new(c(0), c(1))));+ geom.transform(m, GradientKind::Radial);+ (GradientKind::Radial, geom)+ } else {+ (GradientKind::Linear, GradientGeom { start: m * Point::new(c(0), c(1)), end: m * Point::new(c(2), c(3)), aspect: 1.0, focal: None })+ };+ let mut g = GradientPaint::new(Gradient::new(gk, stops));+ g.geom = Some(geom);+ Ok(Some(g))+ }++ /// A function (types 0, 2 and 3; an array of them, one per component) at `x` (types 2 and 3+ /// take one input).+ pub fn eval(&mut self, f: &Obj, x: &[f64], depth: u32) -> Res<Vec<f64>> {+ self.eval_inner(f, x, depth, &mut 0)+ }++ /// [`Self::eval`], with `visits` (shared by the whole recursion, incremented on every call)+ /// counting the functions visited against [`MAX_FUNCTION_VISITS`], as [`linear_points`] counts+ /// its nodes. The depth limit alone stops a function that refers to itself, but not one that+ /// fans out through shared arrays: when four levels of arrays each have 100 entries that all+ /// refer to the same array of the level below (at the last level, the same function), one+ /// evaluation would visit 101,010,101 functions. Each function visited also counts+ /// [`FUNCTION_OPS`] against the operation budget.+ fn eval_inner(&mut self, f: &Obj, x: &[f64], depth: u32, visits: &mut usize) -> Res<Vec<f64>> {+ *visits += 1;+ if depth > 8 || *visits > MAX_FUNCTION_VISITS {+ return ps_err("limitcheck", "Function");+ }+ self.spend(FUNCTION_OPS)?;+ let d = match f {+ Obj::Dict(d) => d.clone(),+ Obj::Array { items, .. } => {+ // Each entry is at least one more function: an array with more entries than the+ // visits left raises `limitcheck` before it is copied.+ if items.len() > MAX_FUNCTION_VISITS - *visits {+ return ps_err("limitcheck", "Function");+ }+ let fs = items.to_vec();+ let mut out = vec![];+ for g in &fs {+ out.extend(self.eval_inner(g, x, depth + 1, visits)?.first().copied());+ }+ return Ok(out);+ }+ _ => return ps_err("typecheck", "Function"),+ };+ let get = |k: &str| d.borrow().get(&Key::name(k)).cloned();+ let nums = |o: Option<Obj>| -> Vec<f64> {+ o.and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default()+ };+ let domain = nums(get("Domain"));+ let t = x.first().copied().unwrap_or(0.0);+ let t = match domain.as_slice() {+ [a, b, ..] => clamp_between(t, *a, *b),+ _ => t,+ };+ match get("FunctionType").and_then(|o| o.as_num()) {+ Some(0.0) => self.sampled(&d, x),+ Some(2.0) => {+ let c0 = nums(get("C0"));+ let c1 = nums(get("C1"));+ let (c0, c1) = (if c0.is_empty() { vec![0.0] } else { c0 }, if c1.is_empty() { vec![1.0] } else { c1 });+ let n = get("N").and_then(|o| o.as_num()).unwrap_or(1.0);+ let x = t.max(0.0).powf(n);+ Ok(c0.iter().zip(&c1).map(|(a, b)| a + x * (b - a)).collect())+ }+ Some(3.0) => {+ // Read the pieces through the borrow and clone only the one we recurse into: a+ // `Functions` array of millions (shared, or reached again through a cycle) must+ // not be copied on every call and at every live recursion level.+ let functions = get("Functions");+ let fs = functions.as_ref().and_then(Obj::items);+ let n = fs.map_or(0, Shared::len);+ let bounds = nums(get("Bounds"));+ let encode = nums(get("Encode"));+ let (lo, hi) = (domain.first().copied().unwrap_or(0.0), domain.get(1).copied().unwrap_or(1.0));+ let k = bounds.iter().take_while(|b| t >= **b).count().min(n.saturating_sub(1));+ let a = if k == 0 { lo } else { bounds.get(k - 1).copied().unwrap_or(lo) };+ let b = bounds.get(k).copied().unwrap_or(hi);+ let (e0, e1) = (encode.get(2 * k).copied().unwrap_or(0.0), encode.get(2 * k + 1).copied().unwrap_or(1.0));+ let u = if b != a { e0 + (t - a) / (b - a) * (e1 - e0) } else { e0 };+ let g = fs.and_then(|fs| fs.get(k)).ok_or(PsError::Ps("rangecheck", "Functions".into()))?;+ self.eval_inner(&g, &[u], depth + 1, visits)+ }+ _ => {+ self.out.warn(UNKNOWN_FUNCTIONS);+ let r = nums(get("Range"));+ Ok(r.chunks(2).map(|p| p.iter().sum::<f64>() / 2.0).collect())+ }+ }+ }+}++/// Is shading `sh` axial or radial (a gradient)?+fn is_gradient(sh: &DictRef) -> bool {+ matches!(sh.borrow().get(&Key::name("ShadingType")).and_then(Obj::as_num), Some(2.0 | 3.0))+}++/// Is shading `sh` one [`Interp::mesh_fill`] paints?+pub(super) fn is_mesh(sh: &DictRef) -> bool {+ matches!(sh.borrow().get(&Key::name("ShadingType")).and_then(Obj::as_num), Some(1.0 | 4.0 | 5.0 | 6.0 | 7.0))+}++/// Where a stitched function of linear interpolations changes slope (its bounds), when it is+/// one; `None` for functions that must be sampled. `depth` bounds the nesting the same way+/// [`Interp::eval`] does (`> 8`) and `visits` (shared by the whole recursion, incremented on+/// every call) bounds the total nodes looked at. Both are needed: the depth limit alone stops a+/// function that refers to itself in a cycle, but not one that fans out through shared children+/// (1025 references to a child a few levels deep is 1025^levels nodes without the visit cap). A+/// well-formed stitch of linear pieces is one level, at most `MAX_STITCH_STOPS + 1` pieces, so it+/// costs at most `MAX_STITCH_STOPS + 2` visits and is never cut off.+fn linear_points(f: &Obj, depth: u32, visits: &mut usize) -> Option<Vec<f64>> {+ *visits += 1;+ if depth > 8 || *visits > 2 * (MAX_STITCH_STOPS + 1) {+ return None;+ }+ let Obj::Dict(d) = f else { return None };+ let d = d.borrow();+ let num = |k: &str| d.get(&Key::name(k)).and_then(Obj::as_num);+ match num("FunctionType")? {+ 2.0 if num("N").unwrap_or(1.0) == 1.0 => Some(vec![]),+ 3.0 => {+ let items = d.get(&Key::name("Functions"))?.items()?;+ // More pieces than the stop cap allows: sample the function instead (tested before+ // `to_vec`, so a huge `Functions` array is not copied only to be rejected). Each stop+ // runs [`Interp::eval`], which reads one piece, so a short `Bounds` with a huge+ // `Functions` would still be O(stops * Functions) to find each piece without this.+ if items.len() > MAX_STITCH_STOPS + 1 {+ return None;+ }+ let fs = items.to_vec();+ if !fs.iter().all(|g| linear_points(g, depth + 1, visits).is_some_and(|p| p.is_empty())) {+ return None;+ }+ d.get(&Key::name("Bounds"))?.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())+ }+ _ => None,+ }+}++/// The clip path a clipping group of one shading rectangle (`shfill` through a clip) can be+/// filled with instead.+pub(crate) fn collapse(nodes: &mut [Arc<Node>], shadings: &HashSet<NodeId>) {+ for n in nodes.iter_mut() {+ let NodeKind::Group { children, clip: true } = &n.kind else {+ if let Some(c) = Arc::make_mut(n).children_mut() {+ collapse(c, shadings);+ }+ continue;+ };+ if let [clip, fill] = children.as_slice()+ && shadings.contains(&fill.id)+ && let (NodeKind::Path { path, rule, clipping: true, .. }, NodeKind::Path { .. }) = (&clip.kind, &fill.kind)+ {+ let mut p = Node::path(fill.id, path.clone(), (*fill.appearance).clone());+ if let NodeKind::Path { rule: r, .. } = &mut p.kind {+ *r = *rule;+ }+ *n = Arc::new(p);+ continue;+ }+ if let Some(c) = Arc::make_mut(n).children_mut() {+ collapse(c, shadings);+ }+ }+}diff --git a/crates/eps/src/import/graphics/path.rs b/crates/eps/src/import/graphics/path.rsnew file mode 100644index 000000000..3403e9add--- /dev/null+++ b/crates/eps/src/import/graphics/path.rs@@ -0,0 +1,428 @@+use super::state::{ccw_turn, turn};+use super::*;++impl Interp<'_> {+ /// User space → document space.+ pub fn xf(&self) -> Affine {+ self.out.page * self.g.ctm+ }++ /// How much user-space lengths grow in the document.+ pub fn scale(&self) -> f64 {+ let s = self.xf().determinant().abs().sqrt();+ if s.is_finite() { s } else { 0.0 }+ }++ /// The current point in user space.+ pub fn user_point(&self) -> Res<Point> {+ let p = self.g.cur.ok_or(PsError::Ps("nocurrentpoint", String::new()))?;+ let inv = self.xf();+ if inv.determinant().abs() < 1e-12 {+ return ps_err("undefinedresult", "");+ }+ Ok(inv.inverse() * p)+ }++ pub fn gsave(&mut self) -> Res {+ if self.saved.len() >= MAX_GSAVE {+ return Err(PsError::Limit("too many saved graphics states"));+ }+ self.alloc(std::mem::size_of_val(self.g.path.elements()))?;+ self.saved.push(self.g.clone());+ Ok(())+ }++ pub fn grestore(&mut self) {+ if let Some(g) = self.saved.pop() {+ self.g = g;+ }+ }++ // ---------- paths ----------++ /// Room for one more element in the current path.+ pub fn grow(&self) -> Res {+ if self.g.path.elements().len() >= MAX_PATH {+ return Err(PsError::Limit("a path has too many points"));+ }+ Ok(())+ }++ /// Count `n` path elements an operator makes, reads or copies against the operation budget,+ /// an operation each: making or reading an element takes up to about as long as an operation,+ /// and copying one takes less (measured).+ pub(super) fn spend_elements(&mut self, n: usize) -> Res {+ self.spend(n as u64)+ }++ pub(super) fn move_to(&mut self, p: Point) -> Res {+ self.grow()?;+ // Consecutive movetos: the last one counts.+ if let Some(PathEl::MoveTo(_)) = self.g.path.elements().last() {+ self.g.path.pop();+ }+ self.g.path.move_to(p);+ self.g.cur = Some(p);+ self.g.start = Some(p);+ Ok(())+ }++ pub(super) fn line_to(&mut self, p: Point) -> Res {+ self.grow()?;+ if self.g.cur.is_none() {+ return ps_err("nocurrentpoint", "");+ }+ self.g.path.line_to(p);+ self.g.cur = Some(p);+ Ok(())+ }++ /// Path elements in user space appended (the first move a line when there is a current point),+ /// each counted against the operation budget.+ fn append_user(&mut self, els: impl Iterator<Item = PathEl>) -> Res {+ let xf = self.xf();+ for el in els {+ self.spend_elements(1)?;+ match el {+ PathEl::MoveTo(p) => {+ let p = xf * p;+ if self.g.cur.is_some() { self.line_to(p)? } else { self.move_to(p)? }+ }+ PathEl::LineTo(p) => self.line_to(xf * p)?,+ PathEl::QuadTo(a, p) => {+ self.grow()?;+ self.g.path.quad_to(xf * a, xf * p);+ self.g.cur = Some(xf * p);+ }+ PathEl::CurveTo(a, b, p) => {+ self.grow()?;+ self.g.path.curve_to(xf * a, xf * b, xf * p);+ self.g.cur = Some(xf * p);+ }+ PathEl::ClosePath => {+ self.grow()?;+ self.g.path.close_path();+ }+ }+ }+ Ok(())+ }++ /// `arc` / `arcn`: from angle `a1` to `a2` (degrees, counter-clockwise or clockwise).+ pub(super) fn arc(&mut self, c: Point, r: f64, a1: f64, a2: f64, ccw: bool) -> Res {+ // `arc` raises `a2` by multiples of 360 until it is at least `a1`, and `arcn` lowers it+ // until it is at most `a1` (PLRM 3rd ed., `arc` and `arcn` in chapter 8). Those sweeps,+ // and the first endpoint, are worked out from what is left of each angle after whole turns.+ let sweep = if ccw && a2 < a1 {+ ccw_turn(a1, a2)+ } else if !ccw && a2 > a1 {+ -ccw_turn(a2, a1)+ } else {+ a2 - a1+ };+ let tau = std::f64::consts::TAU;+ let sweep = sweep.to_radians().clamp(-tau * 4.0, tau * 4.0);+ let a1 = (a1 % 360.0).to_radians();+ let start = c + Vec2::new(r * a1.cos(), r * a1.sin());+ self.append_user(std::iter::once(PathEl::MoveTo(start)))?;+ let arc = kurbo::Arc::new(c, Vec2::new(r, r), a1, sweep, 0.0);+ let tol = (0.01 / self.scale().max(1e-9)).max(1e-9);+ self.append_user(arc.append_iter(tol))+ }++ /// `arct` / `arcto`: a line towards `p1` rounded with radius `r` into the line to `p2`; the+ /// tangent points (user space).+ pub(super) fn arct(&mut self, p1: Point, p2: Point, r: f64) -> Res<[Point; 2]> {+ let p0 = self.user_point()?;+ let (u, v) = (p0 - p1, p2 - p1);+ let (lu, lv) = (u.hypot(), v.hypot());+ let cross = u.cross(v);+ if lu < 1e-12 || lv < 1e-12 || cross.abs() < 1e-12 || r <= 0.0 {+ self.append_user(std::iter::once(PathEl::LineTo(p1)))?;+ return Ok([p1, p1]);+ }+ let (u, v) = (u / lu, v / lv);+ let half = u.dot(v).clamp(-1.0, 1.0).acos() / 2.0;+ let dist = r / half.tan();+ let (t1, t2) = (p1 + u * dist, p1 + v * dist);+ let bis = (u + v).normalize();+ let c = p1 + bis * (r / half.sin());+ let (a1, a2) = ((t1 - c).atan2(), (t2 - c).atan2());+ self.append_user(std::iter::once(PathEl::LineTo(t1)))?;+ let tol = (0.01 / self.scale().max(1e-9)).max(1e-9);+ let arc = kurbo::Arc::new(c, Vec2::new(r, r), a1, turn(a1, a2), 0.0);+ self.append_user(arc.append_iter(tol))?;+ Ok([t1, t2])+ }++ fn rect_path(&self, x: f64, y: f64, w: f64, h: f64) -> BezPath {+ let xf = self.xf();+ let mut bp = BezPath::new();+ bp.move_to(xf * Point::new(x, y));+ bp.line_to(xf * Point::new(x + w, y));+ bp.line_to(xf * Point::new(x + w, y + h));+ bp.line_to(xf * Point::new(x, y + h));+ bp.close_path();+ bp+ }++ /// The rectangles of `rectfill`, `rectstroke` and `rectclip`: `x y w h` or an array of them.+ pub(super) fn rects(&mut self) -> Res<BezPath> {+ let nums: Vec<f64> = match self.stack.last() {+ Some(Obj::Array { .. }) => {+ let items = self.pop_array()?;+ // Five elements a rectangle, counted before the array is read.+ self.spend_elements(items.len() / 4 * 5)?;+ let v: Option<Vec<f64>> = items.borrow().iter().map(Obj::as_num).collect();+ v.ok_or(PsError::Ps("typecheck", String::new()))?+ }+ _ => self.nums::<4>()?.to_vec(),+ };+ if nums.len() / 4 * 5 >= MAX_PATH {+ return Err(PsError::Limit("a path has too many points"));+ }+ let mut bp = BezPath::new();+ for [x, y, w, h] in nums.as_chunks::<4>().0 {+ bp.extend(self.rect_path(*x, *y, *w, *h));+ }+ Ok(bp)+ }++ // ---------- painting ----------++ pub(super) fn fill_path(&mut self, bp: BezPath, rule: FillRule) -> Res {+ if bp.elements().is_empty() || self.g.null {+ return Ok(());+ }+ // A mesh pattern paints its shading inside the path.+ if let Some((sh, m)) = self.g.mesh.clone() {+ let clips = self.g.clips.clone();+ self.clip_with(bp, rule);+ let r = self.mesh_fill(&sh, m);+ self.g.clips = clips;+ return r;+ }+ if self.g.paint.is_none() {+ return Ok(());+ }+ let (paint, overprint) = (self.g.paint.clone(), self.g.overprint);+ self.out.fill(bp, rule, paint, overprint, &self.g.clips);+ Ok(())+ }++ pub(super) fn stroke_path(&mut self, bp: BezPath) -> Res {+ if bp.elements().is_empty() || self.g.paint.is_none() || self.g.null {+ return Ok(());+ }+ let st = self.stroke_layer()?;+ self.out.stroke(bp, st, &self.g.clips);+ Ok(())+ }++ /// The stroke the graphics state draws, in document space. Each entry of the dash pattern it+ /// copies counts as an operation.+ pub(super) fn stroke_layer(&mut self) -> Res<StrokeLayer> {+ self.spend(self.g.dash.len() as u64)?;+ let k = self.scale();+ let w = self.g.width * k;+ let mut st = StrokeLayer::new(self.g.paint.clone(), if w > 0.0 && w.is_finite() { w } else { HAIRLINE });+ st.cap = self.g.cap;+ st.join = self.g.join;+ st.miter_limit = self.g.miter.clamp(1.0, 500.0);+ st.overprint = self.g.overprint;+ let pattern: Vec<f64> = self.g.dash.iter().map(|d| d * k).collect();+ let dash = Dash { pattern, offset: self.g.dash_offset * k, align_corners: false };+ st.dash = dash.is_dashed().then_some(dash);+ Ok(st)+ }++ /// The current path in user space, each element as its operator and points (quadratic+ /// segments as cubic ones).+ fn user_elements(&self) -> Res<Vec<(Op, Vec<Point>)>> {+ let xf = self.xf();+ if xf.determinant().abs() < 1e-12 {+ return ps_err("undefinedresult", "");+ }+ let inv = xf.inverse();+ let mut last = Point::ZERO;+ let mut out = Vec::with_capacity(self.g.path.elements().len());+ for el in self.g.path.elements() {+ let (op, pts) = match *el {+ PathEl::MoveTo(p) => (Op::MoveTo, vec![p]),+ PathEl::LineTo(p) => (Op::LineTo, vec![p]),+ PathEl::QuadTo(a, p) => (Op::CurveTo, vec![last + (a - last) * (2.0 / 3.0), p + (a - p) * (2.0 / 3.0), p]),+ PathEl::CurveTo(a, b, p) => (Op::CurveTo, vec![a, b, p]),+ PathEl::ClosePath => (Op::ClosePath, vec![]),+ };+ last = pts.last().copied().unwrap_or(last);+ out.push((op, pts.into_iter().map(|p| inv * p).collect()));+ }+ Ok(out)+ }++ /// `pathforall`: the current path in user space, each element through its procedure.+ pub(super) fn path_for_all(&mut self) -> Res {+ let close = self.pop_proc()?;+ let curve = self.pop_proc()?;+ let line = self.pop_proc()?;+ let mv = self.pop_proc()?;+ self.spend_elements(self.g.path.elements().len())?;+ for (op, pts) in self.user_elements()? {+ for p in pts {+ self.push_num(p.x)?;+ self.push_num(p.y)?;+ }+ let proc = match op {+ Op::MoveTo => &mv,+ Op::LineTo => &line,+ Op::CurveTo => &curve,+ _ => &close,+ };+ if !self.body(proc)? {+ break;+ }+ }+ Ok(())+ }++ /// Append user path `up` to the current path: a procedure of path operators, or the encoded+ /// form (numbers and a string of operator codes).+ pub(super) fn user_path(&mut self, up: Obj) -> Res {+ let items = up.items().cloned().ok_or(PsError::Ps("typecheck", "a user path".into()))?;+ let encoded = match (items.get(0), items.get(1), items.len()) {+ (Some(nums @ (Obj::Array { .. } | Obj::Str(_))), Some(Obj::Str(ops)), 2) => Some((nums, ops.to_vec())),+ _ => None,+ };+ let Some((nums, ops)) = encoded else { return self.call(Obj::Array { items, exec: true }) };+ // The operators by code, with how many operands each takes.+ const OPS: [(Op, usize); 12] = [+ (Op::SetBBox, 4),+ (Op::MoveTo, 2),+ (Op::RMoveTo, 2),+ (Op::LineTo, 2),+ (Op::RLineTo, 2),+ (Op::CurveTo, 6),+ (Op::RCurveTo, 6),+ (Op::Arc, 5),+ (Op::Arcn, 5),+ (Op::Arct, 5),+ (Op::ClosePath, 0),+ (Op::UCache, 0),+ ];+ let nums: Vec<f64> = match nums {+ Obj::Array { items, .. } => {+ // Each entry of the data array and each byte of the operator string counts as an+ // element read.+ self.spend_elements(items.len().saturating_add(ops.len()))?;+ items.borrow().iter().filter_map(Obj::as_num).collect()+ }+ _ => return ps_err("typecheck", "an encoded user path"),+ };+ let mut next = nums.into_iter();+ let mut repeat = 1usize;+ for code in ops {+ if code >= 32 {+ repeat = usize::from(code - 32);+ continue;+ }+ let &(op, n) = OPS.get(usize::from(code)).ok_or(PsError::Ps("rangecheck", "a user path".into()))?;+ for _ in 0..std::mem::replace(&mut repeat, 1) {+ for _ in 0..n {+ let v = next.next().ok_or(PsError::Ps("rangecheck", "a user path".into()))?;+ self.push_num(v)?;+ }+ // Each operator run counts as an operation.+ self.spend(1)?;+ self.op(op)?;+ }+ }+ Ok(())+ }++ /// `ufill`, `ueofill`, `ustroke` (with an optional matrix): paint a user path, keeping the+ /// current path.+ pub(super) fn paint_user_path(&mut self, op: Op) -> Res {+ let m = match (op, self.stack.last()) {+ (Op::UStroke, Some(Obj::Array { items, exec: false })) if items.len() == 6 && self.stack.len() >= 2 => Some(self.pop_matrix()?),+ _ => None,+ };+ let up = self.pop()?;+ self.gsave()?;+ let depth = self.saved.len();+ self.take_path();+ let r = self.user_path(up).and_then(|()| {+ if let Some(m) = m {+ self.g.ctm *= m;+ }+ let bp = self.take_path();+ match op {+ Op::UStroke => self.stroke_path(bp),+ _ => self.fill_path(bp, if op == Op::UEoFill { FillRule::EvenOdd } else { FillRule::NonZero }),+ }+ });+ self.saved.truncate(depth);+ self.grestore();+ r+ }++ /// `upath`: the current path as a user path (a procedure, in user space).+ pub(super) fn upath(&mut self) -> Res {+ self.pop_bool()?;+ let elements = self.user_elements()?;+ let b = self.xf().inverse().transform_rect_bbox(self.g.path.bounding_box());+ let mut items: Vec<Obj> = [b.x0, b.y0, b.x1, b.y1].into_iter().map(Obj::Real).collect();+ items.push(Obj::Op(Op::SetBBox));+ for (op, pts) in elements {+ items.extend(pts.iter().flat_map(|p| [Obj::Real(p.x), Obj::Real(p.y)]));+ items.push(Obj::Op(op));+ }+ self.alloc(items.len() * std::mem::size_of::<Obj>())?;+ self.push(Obj::proc(items))+ }++ /// `execform`: the form's `PaintProc` run with its matrix, clipped to its box.+ pub(super) fn exec_form(&mut self) -> Res {+ let d = self.pop_dict()?;+ let get = |k: &str| d.borrow().get(&Key::name(k)).cloned();+ let m = get("Matrix").and_then(|o| o.items().and_then(|i| crate::import::interp::matrix_of(&i.borrow()))).unwrap_or(Affine::IDENTITY);+ let bbox: Vec<f64> = get("BBox").and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default();+ let paint = get("PaintProc").ok_or(PsError::Ps("undefined", "PaintProc".into()))?;+ self.gsave()?;+ let depth = self.saved.len();+ self.g.ctm *= m;+ if let [x0, y0, x1, y1] = bbox[..] {+ let bp = self.rect_path(x0, y0, x1 - x0, y1 - y0);+ self.take_path();+ self.clip_with(bp, FillRule::NonZero);+ }+ self.push(Obj::Dict(d))?;+ let r = self.call(paint);+ self.saved.truncate(depth);+ self.grestore();+ r+ }++ pub(in super::super) fn take_path(&mut self) -> BezPath {+ self.g.cur = None;+ self.g.start = None;+ std::mem::take(&mut self.g.path)+ }++ pub(super) fn clip_with(&mut self, path: BezPath, rule: FillRule) {+ let Some(c) = self.out.clip(path, rule) else { return };+ if self.g.clips.len() < MAX_NEST {+ self.g.clips.push(c);+ } else {+ self.out.warn(&deep_clips());+ }+ }++ /// The area the clip leaves, in document space (the page without a clip). The clip path read+ /// counts against the operation budget.+ pub(super) fn clip_bounds(&mut self) -> Res<Rect> {+ let (bounds, len) =+ self.g.clips.iter().rev().find_map(|c| c.region.as_ref()).map_or((self.out.frame, 0), |(p, _)| (p.bounding_box(), p.elements().len()));+ self.spend_elements(len)?;+ Ok(bounds)+ }+}diff --git a/crates/eps/src/import/graphics/state.rs b/crates/eps/src/import/graphics/state.rsnew file mode 100644index 000000000..6aa25d5a9--- /dev/null+++ b/crates/eps/src/import/graphics/state.rs@@ -0,0 +1,328 @@+use super::*;++/// A colour space.+#[derive(Clone, Debug)]+pub(crate) enum Space {+ Gray,+ Rgb,+ Cmyk,+ /// Separation and DeviceN: the ink names, the alternate space and the tint transform.+ Inks {+ names: Vec<Rc<str>>,+ alt: Rc<Space>,+ tint: Obj,+ },+ Indexed {+ base: Rc<Space>,+ table: Rc<Vec<f64>>,+ },+ /// Patterns; an uncoloured one paints in a colour of the underlying space.+ Pattern(Option<Rc<Space>>),+}++impl Space {+ /// Components a colour has in it.+ pub fn n(&self) -> usize {+ match self {+ Self::Gray | Self::Indexed { .. } | Self::Pattern(_) => 1,+ Self::Rgb => 3,+ Self::Cmyk => 4,+ Self::Inks { names, .. } => names.len().max(1),+ }+ }++ /// The colour `setcolorspace` starts with.+ pub(super) fn initial(&self) -> Vec<f64> {+ match self {+ Self::Cmyk => vec![0.0, 0.0, 0.0, 1.0],+ Self::Inks { names, .. } => vec![1.0; names.len().max(1)],+ s => vec![0.0; s.n()],+ }+ }+}++/// A process colour from components in `space` (grey, RGB or CMYK), each clamped to 0–1.+pub(crate) fn process(space: &Space, c: &[f64]) -> Option<Color> {+ let v = |i: usize| c.get(i).map_or(0.0, |x| if x.is_finite() { x.clamp(0.0, 1.0) as f32 } else { 0.0 });+ Some(match space {+ Space::Gray => Color::gray(1.0 - v(0)),+ Space::Rgb => Color::rgb(v(0), v(1), v(2)),+ Space::Cmyk => Color::cmyk(v(0), v(1), v(2), v(3)),+ _ => return None,+ })+}++#[derive(Clone, Debug)]+pub(crate) struct GState {+ /// User space → PostScript's default space.+ pub ctm: Affine,+ pub space: Rc<Space>,+ /// The `setcolorspace` operand, for `currentcolorspace`.+ pub space_obj: Obj,+ pub comps: Vec<f64>,+ pub paint: Paint,+ pub width: f64,+ pub cap: LineCap,+ pub join: LineJoin,+ pub miter: f64,+ /// The dash pattern, shared by the states saved or copied from this one.+ pub dash: Rc<[f64]>,+ pub dash_offset: f64,+ /// The current path, in document space.+ pub path: BezPath,+ pub cur: Option<Point>,+ pub start: Option<Point>,+ pub clips: Vec<Arc<Clip>>,+ /// The clips `clipsave` saved, for `cliprestore`.+ pub saved_clips: Vec<Rc<[Arc<Clip>]>>,+ pub overprint: bool,+ pub font: Option<DictRef>,+ /// `nulldevice`: painting draws nothing.+ pub null: bool,+ /// The colour is a shading pattern whose shading is a mesh: a fill paints it (the shading+ /// and pattern space → the document).+ pub mesh: Option<(DictRef, Affine)>,+}++impl Default for GState {+ fn default() -> Self {+ Self {+ ctm: Affine::IDENTITY,+ space: Rc::new(Space::Gray),+ space_obj: Obj::name("DeviceGray"),+ comps: vec![0.0],+ paint: Paint::solid(Color::gray(1.0)),+ width: 1.0,+ cap: LineCap::Butt,+ join: LineJoin::Miter,+ miter: 10.0,+ dash: Rc::from([]),+ dash_offset: 0.0,+ path: BezPath::new(),+ cur: None,+ start: None,+ clips: vec![],+ saved_clips: vec![],+ overprint: false,+ font: None,+ null: false,+ mesh: None,+ }+ }+}++/// What the program draws.+pub(crate) struct Out {+ /// The document being made: ids, images and swatches.+ pub doc: Document,+ pub drawn: Drawn,+ pub warnings: Vec<String>,+ /// PostScript's default space → document space.+ pub page: Affine,+ /// The page (the bounding box) in document space.+ pub frame: Rect,+ /// Clip and group ids are given in the order they open, so a chain of both sorts by id.+ next_clip: u32,+ /// The groups open (outermost first), and how many more opened past [`MAX_NEST`] (their art+ /// goes in the innermost group kept).+ pub(super) groups: Vec<Arc<Clip>>,+ pub(super) too_deep: usize,+ /// Path elements (and the clips and groups of each object) drawn so far (see [`MAX_DRAWN`]).+ elements: usize,+ /// The path the last object was filled with: a stroke of the same path right after joins it.+ pub(super) merge: Option<BezPath>,+ /// Process colours painted, by model (the document opens in CMYK when most are).+ pub cmyk: usize,+ pub rgb: usize,+ /// Spot inks used: name and colour at full tint.+ pub spots: Vec<(String, Color)>,+ /// The color at full tint of each spot ink in [`Self::spots`], by name.+ pub(super) spot_colors: HashMap<Rc<str>, Color>,+ /// Rectangles painted with a shading (`shfill`): a clipping group of one is the clip path+ /// filled with it.+ pub shadings: HashSet<NodeId>,+ /// Tiling patterns made into pattern swatches: the pattern's `PaintProc` (a pattern made+ /// again with `makepattern` shares it) and cell, the colour an uncoloured one painted in, and+ /// the swatch's name. Each list holds the patterns of one [`tiling_hash`]; a pattern whose+ /// cell has a NaN corner is left out.+ pub(super) tilings: HashMap<u64, Vec<Tiling>>,+ /// How deep art drawn apart (a pattern's cell, a Type 3 glyph) is nested.+ pub apart: u32,+}++fn sane(r: Rect) -> bool {+ [r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite() && v.abs() <= LIMIT)+}++/// A tiling pattern made into a pattern swatch, as [`Out::tilings`] lists it.+pub(super) type Tiling = (Shared<Obj>, Rect, Option<Paint>, String);++/// A hash of what tells tiling patterns apart in [`Out::tilings`]. Patterns that compare equal+/// hash alike: each number goes in by its bits, and −0 goes in as 0.+pub(super) fn tiling_hash(proc: &Shared<Obj>, tile: Rect, under: Option<&Paint>) -> u64 {+ let mut h = DefaultHasher::new();+ proc.hash(&mut h);+ [tile.x0, tile.y0, tile.x1, tile.y1].map(|v| (v + 0.0).to_bits()).hash(&mut h);+ if let Some(Paint::Solid { color, swatch, tint }) = under {+ let c = match *color {+ Color::Rgb { r, g, b } => [r, g, b, 0.0],+ Color::Cmyk { c, m, y, k } => [c, m, y, k],+ Color::Gray { k } => [k, 0.0, 0.0, 0.0],+ Color::Lab { l, a, b } => [l, a, b, 0.0],+ };+ c.map(|v| (v + 0.0).to_bits()).hash(&mut h);+ swatch.hash(&mut h);+ (tint + 0.0).to_bits().hash(&mut h);+ }+ h.finish()+}++impl Out {+ pub fn new(doc: Document, page: Affine, frame: Rect) -> Self {+ Self {+ doc,+ drawn: vec![],+ warnings: vec![],+ page,+ frame,+ next_clip: 0,+ groups: vec![],+ too_deep: 0,+ elements: 0,+ merge: None,+ cmyk: 0,+ rgb: 0,+ spots: vec![],+ spot_colors: HashMap::new(),+ shadings: HashSet::new(),+ tilings: HashMap::new(),+ apart: 0,+ }+ }++ pub fn warn(&mut self, w: &str) {+ if !self.warnings.iter().any(|x| x == w) {+ self.warnings.push(w.to_string());+ }+ }++ /// Open a group: what is drawn until it ends ([`Self::end_group`]) goes in it.+ pub fn begin_group(&mut self) {+ if self.groups.len() >= MAX_NEST {+ self.too_deep += 1;+ self.warn(&format!("groups nested more than {MAX_NEST} deep were read as part of the group around them"));+ return;+ }+ self.next_clip += 1;+ self.groups.push(Arc::new(Clip { id: self.next_clip, region: None }));+ }++ /// End the innermost group open (an end without a beginning ends nothing).+ pub fn end_group(&mut self) {+ if self.too_deep > 0 {+ self.too_deep -= 1;+ } else {+ self.groups.pop();+ }+ }++ /// The chain an object drawn under `clips` is drawn in: the clips and the groups open, in the+ /// order they opened.+ pub fn chain(&self, clips: &[Arc<Clip>]) -> Vec<Arc<Clip>> {+ if self.groups.is_empty() {+ return clips.to_vec();+ }+ let mut chain = Vec::with_capacity(clips.len() + self.groups.len());+ let (mut a, mut b) = (clips.iter().peekable(), self.groups.iter().peekable());+ while let (Some(x), Some(y)) = (a.peek(), b.peek()) {+ let next = if x.id < y.id { a.next() } else { b.next() };+ chain.extend(next.cloned());+ }+ chain.extend(a.chain(b).cloned());+ chain+ }++ /// Add `node` under `clips` (in the groups open); `None` when it was left out.+ pub fn push(&mut self, mut node: Node, clips: &[Arc<Clip>]) -> Option<NodeId> {+ self.merge = None;+ let chain = self.chain(clips);+ let size = node.path_data().map_or(1, |p| p.subpaths.iter().map(|s| s.anchors.len()).sum()) + chain.len();+ self.elements = self.elements.saturating_add(size);+ if self.drawn.len() >= MAX_NODES || self.elements > MAX_DRAWN {+ self.warn(TOO_MUCH);+ return None;+ }+ if !node.visual_bounds().is_none_or(sane) {+ self.warn(FAR_AWAY);+ return None;+ }+ node.id = self.doc.alloc_id();+ let id = node.id;+ self.drawn.push((chain, node));+ Some(id)+ }++ /// Count a paint's colour model.+ fn count(&mut self, p: &Paint) {+ match p {+ Paint::Solid { color: Color::Cmyk { .. }, swatch: None, .. } => self.cmyk += 1,+ Paint::Solid { color: Color::Rgb { .. }, swatch: None, .. } => self.rgb += 1,+ _ => {}+ }+ }++ /// Fill `bp` with `paint`.+ pub(super) fn fill(&mut self, bp: BezPath, rule: FillRule, paint: Paint, overprint: bool, clips: &[Arc<Clip>]) {+ self.count(&paint);+ let item = AppearanceItem::Fill(FillLayer { overprint, ..FillLayer::new(paint) });+ let mut n = Node::path(NodeId(0), PathData::from_bezpath(&bp), Appearance { items: vec![item], ..Appearance::default() });+ if let NodeKind::Path { rule: r, .. } = &mut n.kind {+ *r = rule;+ }+ if self.push(n, clips).is_some() {+ self.merge = Some(bp);+ }+ }++ /// Stroke `bp` with `st`: joins the object just filled with the same path, under the same+ /// clips (`gsave fill grestore stroke`).+ pub(super) fn stroke(&mut self, bp: BezPath, st: StrokeLayer, clips: &[Arc<Clip>]) {+ self.count(&st.paint);+ if self.merge.as_ref() == Some(&bp) {+ let here = self.chain(clips);+ if let Some((chain, last)) = self.drawn.last_mut()+ && chain.iter().map(|c| c.id).eq(here.iter().map(|c| c.id))+ {+ last.appearance.items.push(AppearanceItem::Stroke(st));+ self.merge = None;+ return;+ }+ }+ let n = Node::path(NodeId(0), PathData::from_bezpath(&bp), Appearance { items: vec![AppearanceItem::Stroke(st)], ..Appearance::default() });+ self.push(n, clips);+ }++ /// A new clip of `path` inside `clips`; `None` for a rectangle around the whole page, which+ /// clips nothing.+ pub(super) fn clip(&mut self, path: BezPath, rule: FillRule) -> Option<Arc<Clip>> {+ // Only a polygon that really covers the page: a diamond touching its edges has the page as+ // its bounding box but cuts its corners away (#1542).+ if path.elements().len() <= 6 && vectorcraft_geom::hit::polygon_covers_rect(&path, self.frame, 0.5) {+ return None;+ }+ self.next_clip += 1;+ Some(Arc::new(Clip { id: self.next_clip, region: Some((path, rule)) }))+ }+}++/// The smallest angle from `a` to `b` (radians, −π to π).+pub(super) fn turn(a: f64, b: f64) -> f64 {+ let d = (b - a).rem_euclid(std::f64::consts::TAU);+ if d > std::f64::consts::PI { d - std::f64::consts::TAU } else { d }+}++/// The angle from `a` counterclockwise to `b` (degrees, 0 to 360), worked out from what is left+/// of each after whole turns.+pub(super) fn ccw_turn(a: f64, b: f64) -> f64 {+ (b % 360.0 - a % 360.0).rem_euclid(360.0)+}