|
| 1 | +package com.demcha.compose.document.svg; |
| 2 | + |
| 3 | +import com.demcha.compose.document.style.DocumentPathSegment; |
| 4 | + |
| 5 | +import java.util.ArrayList; |
| 6 | +import java.util.List; |
| 7 | + |
| 8 | +/** |
| 9 | + * Parsed SVG path data (<code><path d="…"></code>), lowered to the |
| 10 | + * canonical {@link DocumentPathSegment} set and normalized into the unit |
| 11 | + * box with the y-axis flipped to the PDF orientation. |
| 12 | + * |
| 13 | + * <p>The full SVG 1.1 path grammar is supported: absolute and relative |
| 14 | + * {@code M L H V C S Q T A Z}, implicit command repetition (including the |
| 15 | + * lineto chain after a moveto), quadratic curves (converted exactly to |
| 16 | + * cubics), smooth shorthands ({@code S}/{@code T} control-point |
| 17 | + * reflection), and elliptical arcs (converted deterministically to cubic |
| 18 | + * spans of at most 90° each via the W3C endpoint-to-center algorithm). |
| 19 | + * Everything a vector editor exports as a {@code d} string lands here as |
| 20 | + * lines, cubics and closes — ready for native PDF curve rendering.</p> |
| 21 | + * |
| 22 | + * <p>Normalization uses the supplied viewBox when one is given (the usual |
| 23 | + * icon workflow, keeping the icon's designed padding) or the tight bounding |
| 24 | + * box of the parsed geometry otherwise. SVG's y-down user space is flipped |
| 25 | + * to the y-up convention of {@code DocumentPathSegment}; fills keep SVG's |
| 26 | + * default non-zero winding semantics.</p> |
| 27 | + * |
| 28 | + * <pre>{@code |
| 29 | + * SvgPath heart = SvgPath.parse(MATERIAL_HEART_D, 0, 0, 24, 24); |
| 30 | + * flow.addPath(path -> path |
| 31 | + * .size(64, 64 / heart.aspectRatio()) |
| 32 | + * .svg(heart) |
| 33 | + * .fillColor(crimson)); |
| 34 | + * }</pre> |
| 35 | + * |
| 36 | + * @author Artem Demchyshyn |
| 37 | + * @since 1.8.0 |
| 38 | + */ |
| 39 | +public final class SvgPath { |
| 40 | + |
| 41 | + private static final double EPS = 1e-9; |
| 42 | + |
| 43 | + private final List<DocumentPathSegment> segments; |
| 44 | + private final double sourceWidth; |
| 45 | + private final double sourceHeight; |
| 46 | + |
| 47 | + private SvgPath(List<DocumentPathSegment> segments, double sourceWidth, double sourceHeight) { |
| 48 | + this.segments = List.copyOf(segments); |
| 49 | + this.sourceWidth = sourceWidth; |
| 50 | + this.sourceHeight = sourceHeight; |
| 51 | + } |
| 52 | + |
| 53 | + /** |
| 54 | + * Parses SVG path data and normalizes it against the tight bounding box |
| 55 | + * of the parsed geometry (anchor and control points). |
| 56 | + * |
| 57 | + * @param d SVG path data, e.g. {@code "M0 0 C20 40 40 40 60 0 Z"} |
| 58 | + * @return parsed, normalized path |
| 59 | + * @throws IllegalArgumentException if the data is empty, does not start |
| 60 | + * with a moveto, or contains a syntax |
| 61 | + * error (the message carries the |
| 62 | + * character position) |
| 63 | + */ |
| 64 | + public static SvgPath parse(String d) { |
| 65 | + List<double[]> ops = new SvgPathParser(d).parse(); |
| 66 | + double[] box = tightBox(ops); |
| 67 | + return normalize(ops, box[0], box[1], box[2], box[3]); |
| 68 | + } |
| 69 | + |
| 70 | + /** |
| 71 | + * Parses SVG path data and normalizes it against the given viewBox — |
| 72 | + * the usual workflow for icons, where the viewBox preserves the icon's |
| 73 | + * designed padding inside its frame. |
| 74 | + * |
| 75 | + * @param d SVG path data |
| 76 | + * @param minX viewBox min-x |
| 77 | + * @param minY viewBox min-y |
| 78 | + * @param width viewBox width; must be finite and positive |
| 79 | + * @param height viewBox height; must be finite and positive |
| 80 | + * @return parsed, normalized path |
| 81 | + * @throws IllegalArgumentException on syntax errors or a non-positive box |
| 82 | + */ |
| 83 | + public static SvgPath parse(String d, double minX, double minY, double width, double height) { |
| 84 | + if (!(width > 0) || Double.isInfinite(width) || !(height > 0) || Double.isInfinite(height)) { |
| 85 | + throw new IllegalArgumentException( |
| 86 | + "viewBox must have finite positive dimensions: " + width + " x " + height); |
| 87 | + } |
| 88 | + return normalize(new SvgPathParser(d).parse(), minX, minY, width, height); |
| 89 | + } |
| 90 | + |
| 91 | + /** |
| 92 | + * Returns the normalized segments (unit box, y-up), ready for |
| 93 | + * {@code PathBuilder.svg(...)} or a {@code PathNode}. |
| 94 | + * |
| 95 | + * @return immutable normalized segment list |
| 96 | + */ |
| 97 | + public List<DocumentPathSegment> segments() { |
| 98 | + return segments; |
| 99 | + } |
| 100 | + |
| 101 | + /** |
| 102 | + * Returns the source box width in SVG user units (viewBox width or tight |
| 103 | + * bounding-box width). |
| 104 | + * |
| 105 | + * @return source width |
| 106 | + */ |
| 107 | + public double sourceWidth() { |
| 108 | + return sourceWidth; |
| 109 | + } |
| 110 | + |
| 111 | + /** |
| 112 | + * Returns the source box height in SVG user units. |
| 113 | + * |
| 114 | + * @return source height |
| 115 | + */ |
| 116 | + public double sourceHeight() { |
| 117 | + return sourceHeight; |
| 118 | + } |
| 119 | + |
| 120 | + /** |
| 121 | + * Returns the width-to-height ratio of the source box, for sizing the |
| 122 | + * target {@code PathNode} proportionally. |
| 123 | + * |
| 124 | + * @return {@code sourceWidth() / sourceHeight()} |
| 125 | + */ |
| 126 | + public double aspectRatio() { |
| 127 | + return sourceWidth / sourceHeight; |
| 128 | + } |
| 129 | + |
| 130 | + // ------------------------------------------------------------------ |
| 131 | + // Normalization (y-flip into the unit box) |
| 132 | + // ------------------------------------------------------------------ |
| 133 | + |
| 134 | + /** Op encoding: [0]=kind (0 move, 1 line, 2 cubic, 3 close), then coords. */ |
| 135 | + private static SvgPath normalize(List<double[]> ops, |
| 136 | + double minX, double minY, double width, double height) { |
| 137 | + // Degenerate extents (a purely horizontal or vertical path with a |
| 138 | + // tight box) keep coordinates finite by centring on the flat axis. |
| 139 | + boolean flatX = width < EPS; |
| 140 | + boolean flatY = height < EPS; |
| 141 | + double w = flatX ? 1.0 : width; |
| 142 | + double h = flatY ? 1.0 : height; |
| 143 | + double topY = minY + height; |
| 144 | + |
| 145 | + List<DocumentPathSegment> out = new ArrayList<>(ops.size()); |
| 146 | + for (double[] op : ops) { |
| 147 | + switch ((int) op[0]) { |
| 148 | + case 0 -> out.add(DocumentPathSegment.moveTo(nx(op[1], minX, w, flatX), ny(op[2], topY, h, flatY))); |
| 149 | + case 1 -> out.add(DocumentPathSegment.lineTo(nx(op[1], minX, w, flatX), ny(op[2], topY, h, flatY))); |
| 150 | + case 2 -> out.add(DocumentPathSegment.cubicTo( |
| 151 | + nx(op[1], minX, w, flatX), ny(op[2], topY, h, flatY), |
| 152 | + nx(op[3], minX, w, flatX), ny(op[4], topY, h, flatY), |
| 153 | + nx(op[5], minX, w, flatX), ny(op[6], topY, h, flatY))); |
| 154 | + default -> out.add(DocumentPathSegment.close()); |
| 155 | + } |
| 156 | + } |
| 157 | + return new SvgPath(out, width < EPS ? 1.0 : width, height < EPS ? 1.0 : height); |
| 158 | + } |
| 159 | + |
| 160 | + private static double nx(double x, double minX, double w, boolean flat) { |
| 161 | + return flat ? 0.5 : (x - minX) / w; |
| 162 | + } |
| 163 | + |
| 164 | + private static double ny(double y, double topY, double h, boolean flat) { |
| 165 | + return flat ? 0.5 : (topY - y) / h; |
| 166 | + } |
| 167 | + |
| 168 | + private static double[] tightBox(List<double[]> ops) { |
| 169 | + double minX = Double.POSITIVE_INFINITY; |
| 170 | + double minY = Double.POSITIVE_INFINITY; |
| 171 | + double maxX = Double.NEGATIVE_INFINITY; |
| 172 | + double maxY = Double.NEGATIVE_INFINITY; |
| 173 | + for (double[] op : ops) { |
| 174 | + for (int i = 1; i + 1 < op.length; i += 2) { |
| 175 | + minX = Math.min(minX, op[i]); |
| 176 | + maxX = Math.max(maxX, op[i]); |
| 177 | + minY = Math.min(minY, op[i + 1]); |
| 178 | + maxY = Math.max(maxY, op[i + 1]); |
| 179 | + } |
| 180 | + } |
| 181 | + if (minX > maxX) { |
| 182 | + throw new IllegalArgumentException("SVG path data contains no drawable geometry"); |
| 183 | + } |
| 184 | + return new double[]{minX, minY, maxX - minX, maxY - minY}; |
| 185 | + } |
| 186 | +} |
0 commit comments