Commit Graph
144 Commits
Author SHA1 Message Date
dotCooCoo 7ff63a6cd7 Merge main into feat/line-segment-common-tangent 2026-11-15 18:40:40 -08:00
BFlat 765334b9a6 Merge pull request #8010 from dotCooCoo/feat/tangent-circle
Path Precision Tools: Tangent Circle draws the circles that touch two or three shapes
2026-11-16 09:33:03 +07:00
dotCooCoo 4ad75291cb Path Precision Tools: Tangent Circle draws the circles that touch two or three shapes
Object › Plug-ins › Path Precision Tools › Tangent Circle…
(`addon.pathtools.tangentCircle`) draws the circles that touch two
selected paths or compound paths at a set radius, or that touch three of
them. A circle touches a shape when it meets the outline without
crossing it, with the whole outline outside the circle or inside it: at
a smooth point it is tangent there, and at a corner or an open end it
passes through that point. Circles, ellipses at any angle and other
closed or open paths all work; the members of a compound path count as
one outline.

When every shape is a circle, the circles are found in closed form (up
to eight for three circles, the problem of Apollonius) and then moved
onto the drawn Bézier circles, which differ from true circles by up to
0.0273% of the radius. Other shapes are searched on a grid, and the
centers left are refined with Newton's method on the curves. With three
shapes, circles up to 64 times the diagonal of the box around the
shapes' anchors and handles are found.

The circles are listed by radius, then top to bottom, then left to
right. The dialog takes the radius (with two shapes; 36 pt to start)
and previews every circle found or one picked by number; OK draws them
with the current paint as one undo step, selected. No circle, more than
64 circles (shapes touched along a whole curve, such as two concentric
circles), shapes at one point or too small for the radius, more than
2000 segments and a search past its limits are errors that leave the
document unchanged.

The Tangent Circle and Circle: rows are in every catalog, and the
command's messages in the catalogs that translate messages.

Docs: docs/mcp.md (Path Precision Tools add-on),
docs/target-app-parity.md, docs/ui-parity.md and ROADMAP.
2026-11-15 16:37:17 -08:00
dotCooCoo 88d94ef78f Path Precision Tools: Common Tangents refuses a path with a short inward bend
The convexity check looked at 32 points along each segment, so a cubic
that bends the other way for a short stretch between two of those points
was taken as convex. Each segment is now also checked whole: the cross
product of its first and second derivatives, a quadratic in t, must not
turn against the way the outline turns anywhere on the segment.
2026-11-15 16:14:50 -08:00
dotCooCoo 0189417e24 Path Precision Tools: Common Tangents draws the lines touching two closed paths
Object › Plug-ins › Path Precision Tools › Common Tangents…
(`addon.pathtools.commonTangents`) adds the common tangent lines of two
selected convex closed paths as separate open paths: external (both
paths on the same side of the line), internal (the lines between them)
or all, and with Centerline the line joining the two centers. An
ellipse drawn with the Ellipse tool is measured as an exact ellipse at
any rotation and scale; any other path must be closed, have one outline
and bend the same way all around, with at most 10000 segments.

Each line runs between the points where it touches the two paths, or
covers a straight side that lies along it. Separate paths have four
tangents, overlapping paths only external ones (two for ellipses), and
a path inside the other none. Paths that touch, from outside or from inside, share
one tangent instead: a line centered on the point where they touch and
as long as the narrower path is wide along it. When there is no tangent
of the kind asked for, nothing changes and the result carries a warning
that says why. The lines take the current stroke and no fill, go
directly above the upper path and are selected, as one undo step. The
dialog has Preview.

The geometry is in vectorcraft-pathops: the tangents are the zeros of
the difference of the two outlines' support values over the normal's
angle, sampled at 720 even steps and at every angle where either
path's touching point passes to another segment, then refined, so the
work per pair is bounded.

Catalog rows for the menu item, the dialog and the messages are in
every catalog.

Docs: docs/mcp.md (Path Precision Tools add-on), docs/target-app-parity.md
and ROADMAP.
2026-11-15 13:48:21 -08:00
dotCooCoo 5bba196c4f Path Precision Tools: Trim at Crossings shows the stretch a click would remove
Hovering with the Trim at Crossings Tool draws in red the stretch a click
there would remove, on the same paths and by the same rules as the click,
and nothing over empty canvas or hidden and locked paths. A drag draws
every stretch its rectangle or freehand line would remove while it
reaches at most 32 paths. In isolation mode only paths inside the
isolated object are highlighted.

What a pick removes moves from the command into
vectorcraft_tools::addons::trim::plan, which the command and the tool
both use. A preview spends at most a twentieth of the crossing work a
click may (Work::share); past that it shows nothing, and the click or
release still removes what it reaches. The tool keeps the crossings it
found for the document as it is, so moving along one path does not
search again, and kept crossings still count against a pick's work
budget. Work::spent_since and Work::draw in vectorcraft-pathops measure
and charge that work.

Docs: docs/mcp.md, docs/ui-parity.md, docs/target-app-parity.md.
2026-11-15 11:24:17 -08:00
dotCooCoo a5493a1cd0 Paths: editing one anchor of a long path keeps one chunk of anchors for undo
A subpath's anchors are now an `Anchors` list held in chunks of up to
256 anchors behind `Arc`s. Copying a path copies the chunk table and
shares the chunks, and editing one anchor copies only the chunk that
holds it, so the undo step of a one-anchor edit no longer keeps a copy
of every anchor of the path. Inserting or removing an anchor copies the
chunk it is in and rebuilds the table. Reads and edits follow the Vec
and slice methods the code used; files write and read each subpath's
anchors as one list, as before, within the same anchor read budget.

The undo memory estimate counts only the chunks the other version of
the path does not hold, and the renderer's kept paths compare only the
chunks an edit copied when they look for moved anchors.

Moving one anchor of an open path of 10,000 or 200,000 anchors
(path.moveAnchor, path.setHandle, path.moveAnchors, a nudge) keeps at
most 48 KiB in its undo and redo steps, where it kept 56 bytes per
anchor.
2026-11-14 21:25:15 -08:00
dotCooCoo 76f07a626e Path ops: Offset Path turn test describes the cases it checks
The comment on the zigzag cases said the open zigzag grown by 1.5 leaves
stroker loops whose faces the distance test drops. With the turned branch's
distance test measuring points in the turned frame, or dropping no face at
all, the three zigzag cases still pass and only the plate case fails (201
contours instead of 101). The comment now says what the zigzag cases check:
one turn for the low path, none for the path stood on end, and the same
region from both. The plate comment says its narrow holes are dropped by
the distance test measured at points turned back into the plate's frame.
2026-11-13 21:59:20 -08:00
dotCooCoo 380f03345f Merge main into feat/smooth-free-end-tangent 2026-11-13 14:01:37 -08:00
BFlat d15a725626 Merge pull request #7216 from dotCooCoo/feat/trim-at-crossings
Path Precision Tools: Trim at Crossings removes the stretch of a path between crossings
2026-11-14 04:30:27 +07:00
dotCooCoo 1567957482 Smooth tool: an open path's end turns with the smoothing when a drag reaches it
When a Smooth tool drag refits the stretch at the first or last anchor
of an open path, the curve there now leaves or arrives along the
smoothed path within the tool's reach instead of along the first or
last segment, so a jagged end no longer keeps its jag. The end point
stays where it is. An end where the smoothed path turns back by 90
degrees or more keeps its segment's direction, and a stretch that ends
inside the path keeps the direction of the part outside the drag.

- pathops: SimplifyOptions gains free_start and free_end, off by
  default; closed subpaths and simplify_part ignore them, so Simplify
  and Object > Path > Smooth give the same output as before.
- engine: path.smoothRegion sets them for the ends of an open path
  that a run's refit reaches.

Docs: docs/mcp.md, docs/target-app-parity.md.
2026-11-13 11:51:02 -08:00
dotCooCoo ec907e75c6 Path Precision Tools: a place at the end of a closed path's last segment is on the stretch at its first anchor
`span_at` read the end of a closed subpath's closing segment as past
every stretch, so a click that landed there could leave the path
unchanged. It now reads that place as the first anchor.
2026-11-13 11:00:06 -08:00
BFlat f520e6f8c5 Merge pull request #7184 from dotCooCoo/fix/cleanup-one-pass
Artwork Cleanup: remove quadratic work from three path repairs
2026-11-14 00:48:45 +07:00
dotCooCoo 3a336fd32f Path Precision Tools: Trim at Crossings removes the stretch of a path between crossings
The new Trim at Crossings Tool removes stretches of paths between the
places where they are crossed by another path or by themselves. A click
removes the stretch under the pointer, a drag removes every stretch its
rectangle touches, and an Alt-drag removes every stretch its freehand
line crosses. It works on every path that can be edited, selected or
not, and each gesture is one undo step.

- `addon.pathtools.trim {at, tolerance?}`, `{rect}` or `{points}` is the
  command behind the tool. A closed path that loses a stretch becomes
  open, an open path that loses a middle stretch becomes two paths with
  its appearance in its place in the stacking order, and a path that
  nothing crosses is removed whole. The stretches that stay get no new
  anchors.
- Hidden and locked paths, guides and clipping paths are not trimmed and
  do not count as crossing. Only the paths the gesture reaches are
  searched for crossings, and one work limit covers every path the
  command trims.
- `crossings_on` and `crossings_on_within` in `vectorcraft-pathops` find
  the crossings on one path and compare it only with the segments in
  its box.
- The new tool shares the crossing search with Add Points at Crossings
  and Split at Crossings, so those change too: two segments of a path
  that meet at an anchor, directly or across segments with no length,
  now count as crossing where they cross again away from that anchor,
  and do not count as crossing at the anchor itself. With Self
  Crossings, a curved segment that loops over itself counts as crossing
  itself. Before, both crossings were missed.
- The tool is an add-on tool: Object › Plug-ins › Path Precision Tools
  and the All Tools drawer list it, it has no shortcut, and neither
  shipped toolbar shows it.

Docs: docs/mcp.md, docs/ui-parity.md, docs/target-app-parity.md.
2026-11-13 09:24:53 -08:00
BFlat e74c2d04df Merge pull request #7083 from dotCooCoo/fix/simplify-line-keeps-tangent
Simplify: a refitted curve becomes a line only when its joins stay smooth
2026-11-13 23:31:37 +07:00
BFlat 43d0b50760 Merge pull request #7157 from dotCooCoo/fix/remove-anchors-one-pass
Paths: Remove Anchor Points removes many anchors of a subpath in one pass
2026-11-13 23:15:10 +07:00
BFlat d26413c3fb Merge pull request #7117 from dotCooCoo/fix/smooth-tool-smooths
Smooth tool: each drag smooths the path under it, and repeated drags keep smoothing
2026-11-13 23:04:21 +07:00
dotCooCoo 3e53884b7e Artwork Cleanup: remove quadratic work from three path repairs
Three repairs in crates/pathops/src/addons/cleanup.rs grew with the square
of the input. Each now gives the same results as before, bit for bit.

- Collinear anchors: removing an anchor called Vec::remove, so a straight
  run of n anchors took O(n^2) moves. The repair now tests each anchor once
  against the nearest kept neighbors, with the same test order, neighbors
  and stop rule, and moves the kept anchors into place once.
- Nearly Coincident Anchors (near_point_groups): every pair of anchors in
  touching grid cells was compared, so a cluster of A anchors cost O(A^2)
  checks. Groups now grow one anchor at a time and look only at anchors no
  group has taken, by exact position, skipping quarter-cell squares that
  lie out of reach.
- Rejoin Path Pieces (rejoin): every pair of ends within the gap was listed
  and sorted, O(P^2 log P) for P pieces meeting at one place. Each end now
  finds its first partner in the same order (turn, distance, then end
  order), searching by direction among the ends still free, and two ends
  that are each other's first partner meet.

Tests compare each repair with a copy of the old algorithm on generated
and focused inputs, count the work on dense cases (20,000-anchor runs,
4,000-anchor clusters, 2,000 pieces meeting at one point), and check Health
Check, Show and Fix on a 5,001-anchor path.
2026-11-13 07:58:36 -08:00
dotCooCoo 4fae51023e Paths: Remove Anchor Points removes many anchors of a subpath in one pass
Object > Path > Remove Anchor Points removed each selected anchor with
its own Vec::remove, shifting the rest of the subpath every time, so
removing k anchors from an n-anchor subpath took O(k*n) moves.

- pathops: remove_anchors removes a subpath's anchors the last first,
  reading each anchor's current neighbors, handles, length and closed
  state as removing them one at a time does, and compacts the anchor
  list once. remove_anchor and remove_anchors share one refit, so the
  result is bit for bit the same.
- engine: the command groups the selected anchors by subpath, works out
  the next selected anchor with each subpath reading only its own
  selected anchors, and takes emptied paths out of the selection
  together (Selection::remove_all).
- Tests compare remove_anchors bit for bit with remove_anchor over 600
  generated subpaths and focused cases, count the anchors moved (2001
  anchors, every other one removed: at most one move per anchor left,
  500,500 one at a time), and compare the next-anchor selection and
  the command on many paths and subpaths with removing one at a time.
2026-11-13 06:54:55 -08:00
dotCooCoo 349034dda2 Smooth tool: each drag smooths the path under it, and repeated drags keep smoothing
Part of #2224.

A Smooth tool drag only refitted the anchors in its reach within
Fidelity, so a wobble wider than Fidelity stayed, and a second drag over
the same place changed nothing. Repeated refits also drifted away from
the path, and a drag over a whole closed path left a corner at its first
anchor.

- path.smoothRegion now smooths the stretch in reach along its length
  with a Gaussian whose spread is a third of the reach, then refits it
  within Fidelity. The run's outer end points and handles stay fixed.
- Each refit stays within twice the distance the smoothing moved the
  path (at least a tenth of Fidelity), so repeated drags do not drift
  (SimplifyOptions::smooth_moved_only).
- A whole closed path is smoothed across its start as a loop, so a
  bump at the first anchor is smoothed like any other and no corner is
  left. Object > Path > Smooth smooths a closed path across its start
  the same way.
2026-11-13 04:44:12 -08:00
dotCooCoo ab75b67f85 Simplify: the join at the start of a smoothed loop turns by at most 0.5°
A smoothed loop with no corner is refitted along one direction across
its start. The first and the last fitted curve were each compared with
that direction, so when both became lines, the two lines could turn by
up to 1° where they meet at the loop's start.

`refit_part` now compares the last curve of such a loop with the
direction the loop's first segment leaves along. When the line would
turn by more than 0.5° from it, the last piece stays a flat curve.

Test: `simplify_keeps_the_join_at_the_start_of_a_smoothed_loop_smooth`
(`crates/pathops/tests/it/ops.rs`).
2026-11-13 04:33:23 -08:00
dotCooCoo 727a26d5a6 Path ops: Offset Path sweeps long, low paths along their length
Offset Path now turns the overlap sweep the way Outline Stroke and
Unite do. When the estimate for its fill, the ring stroked around it
and the outline of its open subpaths is under two thirds as large for
the parts turned a quarter turn, the faces are found on the turned
parts, the faces within the offset distance of the path are dropped by
testing their points turned back, and the result is turned back.

On an open path of 10,000 anchors in rows of 1,000, offsetting by 2 pt
takes 1.0 s of processor time instead of 1.8 s in a release build.
The offset of a long, low path has as many subpaths as the offset of
the same path stood on end, and the area where the two differ is no
larger than the refit precision times the outline's length.
2026-11-13 04:26:14 -08:00
dotCooCoo eee96556e6 Simplify: a refitted curve becomes a line only when its joins stay smooth
Simplify, Object > Path > Smooth, the Smooth tool and freehand strokes
turned every refitted curve whose handles lay near its chord into a
straight line. A short curve whose end directions were off the chord
passed that test, and the anchor between it and the next curve became a
corner the path did not have: a Smooth tool drag along a line jagged by
up to 6 pt left corners of 7.7 to 40.6 degrees.

A curve now becomes a line only when the line runs within 0.5 degrees
of the directions the path arrives and leaves along. A nearly straight
piece that would turn more stays a flat curve. Convert to Straight Lines
is unchanged.
2026-11-13 01:09:38 -08:00
BFlat 267555bc54 Merge pull request #6982 from jayzed80/fix/offset-inset-open-path-6427
Offset Path: an inset keeps the outline of open paths
2026-11-13 07:09:25 +07:00
jayzed80 44f0c98c40 Offset Path: an inset keeps the outline of open paths (#6427)
A negative offset kept only the faces inside the closed fill, so the stroke of every open subpath was dropped and an open line inset to nothing. Inset the closed subpaths, outline the open ones with a 2|delta| butt stroke as a positive offset does, and unite the two.
2026-11-12 20:08:06 +00:00
BFlat 86f8a6dcbd Merge pull request #6927 from dotCooCoo/fix/roughen-size-zero
Effects: Roughen at size 0 keeps the outline
2026-11-13 02:46:39 +07:00
dotCooCoo 91e1412d77 Effects: Roughen at size 0 keeps the outline
With Size 0, Roughen moved no point but still replaced each segment
with its Detail's points joined by straight lines (Corner) or by a
smoothed curve through them (Smooth), so a curved path lost its shape.

At Size 0 each segment is now split at the Detail spacing into pieces
of equal length on the segment itself, with `pathtools::insert_at`: a
straight segment gets corner points without handles, and a curve gets
smooth points whose handles follow it. The path keeps its outline with
Smooth or Corner points alike. The params text of `distort.roughen`
describes size 0.

`insert_at` now counts the anchors added before each returned mark in
one pass. It counted them again for every split segment, which took
quadratic time on a path with many split segments. Its results are
unchanged.

Existing documents with a Roughen of Size 0 on a curved path, or with
Smooth points, draw differently.

This is VectorCraft's own rule. What Roughen does is described in
https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/distort-and-transform-effects-in-illustrator.html
2026-11-12 08:55:07 -08:00
dotCooCoo 71fcd584b0 Cutting Tools: limits count hidden clip art, and joined art is not refused
- Weed Box and Lines counts the outline points a nested clip group hides when
  it tests pieces for being inside a region, and counts the work of every clip
  group in the selection together, so a selection cannot run far past the
  limit.
- Stencil Bridges refuses art when its measuring budget runs out only while an
  island is still unjoined, and a refusal for size or detail says so.
2026-11-12 02:35:35 -08:00
dotCooCoo 2a494dec50 Cutting Tools: Stencil Bridges keeps the islands of a stencil attached
Object › Plug-ins › Cutting Tools › Stencil Bridges… (`addon.cutting.bridges`)
cuts strips of a set width out of the selected art so that a stencil cut
from it holds together: every island (the inside of an O, A or 8, a hole in
a shape) stays joined to the sheet, directly or through another island.
Bridges take the shortest crossings that fit first, then spread around each
island up to the count asked for, at least two widths apart. They run
vertically, horizontally or along the shortest crossing among 12
directions 15° apart.

- The art is measured by the area its outlines enclose, whatever their
  paint, with hidden objects left out; type by its glyph outlines, without
  converting the type. The result is one compound path with the strips cut
  out, painted as the topmost selected shape with outlines, in the place of
  the topmost selected object with outlines. Selected objects with no
  outlines in the art stay where they are.
- Keep Original (on by default) moves the selected objects that make up the
  art to a new hidden layer, Stencil Original; off replaces them.
- Art with no islands, or none a bridge of the width fits, is left as it is
  with a message and no undo step. Islands the cut result still encloses
  are counted in `unbridged`, with a message. Otherwise the run is one undo
  step.
- Curves are followed within a twentieth of the width (0.002 to 0.25 pt).
  Art that reaches more than 10000000 pt from the origin or has more than
  200000 anchors is refused before it is combined. Art is also refused when
  its combined area has more than 4000 outlines, when its outlines need
  more than 200000 straight segments, or when placing the outlines or
  joining every island takes more work than a fixed budget allows; when
  the budget runs out while extra bridges are added, the bridges found so
  far are kept.

Tests in vectorcraft-pathops, vectorcraft-engine and vectorcraft-ui-egui,
command_sweep cases, catalog rows in all 27 languages, docs/mcp.md, the
evidence list in docs/target-app-parity.md and the ROADMAP progress log.
2026-11-11 22:17:43 -08:00
BFlat ea3a4ec373 Merge pull request #3145 from adambelis/feat/width-smooth-profile
Width profiles run smooth between their points
2026-11-12 11:41:15 +07:00
BFlat feac9b5175 Merge pull request #6672 from dotCooCoo/fix/simplify-flat-loop-split-limit
Simplify: a flat closed loop keeps its outline when splitting reaches its limit
2026-11-12 09:13:25 +07:00
adambelis ff18e8c733 Width profiles: the edge fit stops once it is within tolerance (#3145) 2026-11-12 00:35:01 +01:00
dotCooCoo 1618686224 Path ops: rejoining split curves tests only the input curves around the run
exact_merge looked at every input curve on each merge attempt, so tidying
the output of a sweep cost the number of input curves for each joint it
tried to remove. It now takes its candidates from Tidy::curves_around,
the bounds index that repair already uses, and tests only the curves
whose bounds hold both ends of the run.

A new test cuts one curve of a 1,000-curve row in three and checks that
the merge rebuilds it while testing at most four curves; before the
change it tested 1,002.
2026-11-11 14:57:19 -08:00
dotCooCoo 883c24a3a8 Simplify: lines between samples of a flat loop stay within the tolerance
When the room left in the result limit is too small for the lines of a
curved segment to stay within the tolerance, the loop stays as it is
instead of taking fewer lines that can pass it.
2026-11-11 14:39:25 -08:00
dotCooCoo 0d600449d1 Simplify: the samples of a flat loop count its line segments in the limit
When a flat closed loop becomes the lines between samples of its curved
segments, the line segments it keeps now count toward the 2,097,152-line
limit before the rest is shared among the curved segments. When that
leaves no line for some curved segment, the loop stays as it is.
2026-11-11 14:31:33 -08:00
dotCooCoo 3edc1640fd Simplify: a flat closed loop keeps its outline when splitting reaches its limit
Follows #6651. When the refits of a closed subpath enclose no area,
Simplify splits its curves until straight lines between the pieces
enclose one. That split stopped at 65,536 pieces in all, and a loop
with many anchors then came back as the flat refit, with no outline.

- Only curved segments are split; line segments stay one piece each.
- When no split within the limits encloses an area, the loop stays as
  it is. With Convert to Straight Lines, each curved segment becomes
  the lines between its samples instead.
2026-11-11 13:17:39 -08:00
adambelis a9fd0eb7c0 Merge remote-tracking branch 'origin/main' into feat/width-smooth-profile
# Conflicts:
#	docs/target-app-parity.md
2026-11-11 22:13:44 +01:00
adambelis a08937661b Width profiles: near-outline sampling and review fixes (#3145) 2026-11-11 22:09:10 +01:00
dotCooCoo 796e2a7ebc Simplify: a closed subpath whose refits enclose no area keeps its outline
Follows #6614. When a closed subpath's refit in two and in three parts is
still lines that enclose no area, for example an S curve closed by a
straight edge whose cut points all lie on that edge, Simplify now splits
each segment in 2, 4, 8 and so on (up to 1,024 pieces, 65,536 in all)
until every piece is within the tolerance of the line between its ends
and those lines enclose an area. With Convert to Straight Lines those
lines are the result; without it the subpath stays as it is. A subpath
whose points are all in line keeps the refit's lines, so its extra
anchors are still removed. Lines count as enclosing no area when every
point is within 1e-6 pt of one line.
2026-11-11 11:00:51 -08:00
dotCooCoo 9ce1558c5e Simplify: a closed subpath whose refit is one curve stays in the path
A closed subpath that refits to a single curve has one anchor, which is
not a subpath, so Simplify dropped it: a small circle inside a compound
path was lost and the result ended hundreds of points from the original,
and a small closed path on its own came out empty. Such a subpath is now
refitted in two parts, cut at the point farthest from its start, or in
three when two parts would still enclose no area (two lines that retrace
each other with Convert to Straight Lines). A closed subpath of a single
segment stays as it is.
2026-11-11 08:21:15 -08:00
adambelis 1c43204d15 PR 3145: fixes gradient and stroke outline issues; resolves review items 2026-11-10 13:08:47 +01:00
dotCooCoo 4060f14ce0 Path ops: Unite sweeps a single path again when two segments lie within twice the sweep tolerance
The second sweep of `unite_all` joins contours that lie within the sweep
tolerance of each other, and the first sweep can leave such contours
apart. `solid::tests::meets_within_twice_the_boolean_tolerance` needs
that join. A single input now skips the second sweep only when no two
of its segments lie within twice the tolerance. The check compares at
most 512 pairs per segment and runs the second sweep past that.

`unite_parts` tests the single-input case before it builds the combined
path, and it takes `parts` and `inputs` by value so that both are freed
before the second sweep.
2026-11-09 16:19:01 -08:00
dotCooCoo 10909656d9 Path ops: Unite sweeps a single path once when its own sweep leaves its segments as they are
`unite_all` and `try_unite_all` swept each input under its own fill rule
and then swept all the resulting contours again under NonZero. With one
input whose sweep split and dropped none of its segments, the second
sweep ran over the same simple contours and doubled the time. Such an
input is now refit from the first sweep's contours. Inputs that cross
themselves and unions of several inputs are still swept again, and the
input paths are converted once instead of twice.
2026-11-09 13:20:20 -08:00
dotCooCoo 0945eaf2b3 Merge main into perf/contours-cover-lists 2026-11-08 15:00:56 -08:00
dotCooCoo be0e9347b8 Path ops: Merge finds every fill's faces in a few contour passes instead of one per fill
Squashed from #6191 onto main.
2026-11-09 00:30:43 +07:00
dotCooCoo f74c7e8056 Path ops: region building lists the shapes covering each region instead of a flag per shape
Squashed from #6144 onto main.
2026-11-09 00:28:12 +07:00
dotCooCoo 9f629418e9 Merge main into perf/contours-cover-lists 2026-11-08 00:21:42 -08:00
dotCooCoo 96252edb74 Flattening: stop building a group's regions at the first one past the region limit
With an unclipped raster/vector balance between 0 and 100, a group that
splits into more than 10^(balance/20) regions is rasterized whole and
none of its regions are used. The region build now stops at the first
region past that limit (pathops `regions_within`) instead of building
every region and then discarding them. Groups at or under the limit,
and every group with Clip Complex Regions on, still build every region.

Flatten Transparency, the flattened document and EPS export come out
the same as with every region built, for groups under the limit, at it,
just over it and far over it.
2026-11-08 12:47:59 +07:00
dotCooCoo 8a7011a9d3 Path ops: stroke outlining and unions sweep long, low paths along their length
The overlap sweep moves a horizontal line down the page, and its time
per event grows with the number of segments on that line. A long, low
path, such as rows of a zigzag, puts a whole row on the line at once.

stroke_region, unite_all_with and try_unite_all_with now estimate how
many segments the sweep holds at once in each direction, from up to
4,096 segment boxes (one from each run of segments, at a position that
changes from run to run). When the estimate for the input turned a
quarter turn is under two thirds of the upright one (2,048 segments or
more), the operation runs on the turned input and the result is turned
back. A quarter turn swaps and negates coordinates, so no point moves
by rounding. Offset Path is not turned. Callers of unite_all,
try_unite_all and outline_stroke take the turned sweep through these
functions.

Tidy's lookups of the input curves around a piece and of the kept
anchors can search along y: once lookups with more than 64 candidates
along x have scanned 16 per item, a lookup sorts the list along y once
and uses that window when it holds fewer candidates (under a quarter as
many for curves). Where the y window rarely helps, only one lookup in
32 measures it. is_kept counts the few points within its tolerance
directly instead of searching for the window's end.

In the sweep_axis tests, a turned result has as many subpaths as the
result without the turn, and the area where the two differ is no
larger than the refit precision times the outline's length.

On one open path of 200,000 anchors in rows of 1,000, Outline Stroke
takes 17.3 s of processor time instead of 31.3 s and Unite 2.9 s
instead of 6.5 s in a release build. Unite of 2,000 circles takes the
same time as before.
2026-11-08 12:22:04 +07:00
dotCooCoo 500f74b700 Tests: the index read count includes entries read from more than one cell
RectIndex::at notes its reads before it sorts and removes repeats, so an
entry filed under several of the cells a lookup spans counts once per cell.
2026-11-08 11:42:47 +07:00