Files
vibemake-pcb-studio/common/plotters/PS_plotter.ts
T
likang 7e01147566
CI / typecheck + test + build (push) Has been cancelled
Initial commit: import VibeMake PCB Studio
2026-11-03 11:20:08 +08:00

1434 lines
56 KiB
TypeScript

// SPDX-License-Identifier: GPL-3.0-or-later
// Copyright (C) 2026 ZiroEDA and contributors.
// Portions derived from KiCad, copyright The KiCad Developers. See NOTICE.md.
/**
* PS_PLOTTER, the Adobe PostScript 3.0 plot back-end, transcribed from
* common/plotters/PS_plotter.cpp — both the PS_PLOTTER half and the
* PSLIKE_PLOTTER half that file also carries (SetColor, SetScaleAdjust,
* SetTextMode, encodeStringForPlotter, returnPostscriptTextWidth,
* computeTextParameters, the Helvetica AFM width tables and the pad flashes).
* PDF_PLOTTER and SVG_PLOTTER derive from the PSLIKE_PLOTTER here; the
* PLOTTER members all three lean on are in plotter.ts.
*
* PS is the sibling of PDF under PSLIKE_PLOTTER, but the file it writes could
* hardly be less alike: a PostScript document is a *program*, so StartPlot
* emits a prolog of macros and every later primitive is a handful of operands
* and a macro name. Four things carry the port.
*
* 1. The paint mode is baked into the macro name, not into an operator.
* `getFillId` maps a FILL_T onto 0/1/2 and the emitter concatenates it, so a
* filled circle is `cir1` and an unfilled one `cir0`. Anything that is
* neither NO_FILL nor FILLED_SHAPE — a hatch, a background fill — collapses
* onto id 2, whose macro is character-for-character the id 1 macro.
* 2. Numbers go out as fmt's `{:g}`, six *significant* digits with trailing
* zeros stripped, at every call site but one: `emitSetRGBColor` uses
* `{:.3g}`, three significant digits, above a comment that asks why. That
* difference is real and observable — 0.6666666 plots as `0.666667` in a
* coordinate and `0.667` in a colour — so `formatG` here takes a precision
* where the PDF port's hard-codes six.
* 3. The file is bytes with two encodings in it. `%%Creator` and
* `%%DocumentMedia` are `TO_UTF8`, while everything routed through
* `encodeStringForPlotter` — `%%Title`, `%%Page` and the phantom text — is
* written a `char` at a time from a `wchar_t`, i.e. Latin-1, after silently
* *dropping* every code point at or above 256. A string-then-encode
* implementation would quietly diverge on the first accented title.
* 4. Only StartPlot knows the page's orientation, and it un-swaps it: PAGE_INFO
* already keeps m_size the right way round for the current orientation, so
* a landscape sheet has its width and height swapped *back* before the
* `%%BoundingBox` and `%%DocumentMedia` comments, and the swap is undone
* again at draw time by `N 0 translate 90 rotate`.
*
* Faithfully reproduced oddities, none of which is to be "fixed":
* SetCurrentLineWidth's sentinel handling is an `else if` chain, so a
* USE_DEFAULT_LINE_WIDTH that resolves to a zero default pen stays zero here
* where PDF's separate `if` would clamp it to one — and Rect, Circle and
* PlotPoly all test `GetCurrentLineWidth() <= 0` *after* setting the pen, so
* that zero is exactly what silences them; `%%Pages: 1` is hard-coded however
* many pages follow; `PlotImage` declares `/pix` as one byte per pixel of width
* and then feeds `colorimage` three components per pixel, and its hex
* line-break counter is never reset between rows, so the breaks drift, and its
* alpha premultiply is done in C `float` and then *masked* with 0xFF rather
* than clamped, so an already-bright channel wraps round to dark;
* `computeTextParameters` hands `returnPostscriptTextWidth` the integer pen
* width in its `bool aBold` slot, so any non-zero pen widens the estimate to
* the bold table, and it rotates `tw`/`th` only to discard them; `PenTo` emits
* the `newpath` that opens a plume before deciding whether the plume moved at
* all; and `Arc` decides whether to swap its endpoints with
* `!m_plotMirror ^ ( aAngle < ANGLE_0 )`, a bool XOR whose left half is
* negated and whose right half is not.
*
* Deliberate gaps, each an injected dependency rather than an approximation:
* the raster image (`PsImage`, standing in for wxImage, with the per-pixel
* accessors upstream actually calls) and the font (PLOTTER's `PLOTTER_FONT`,
* standing in for KIFONT::FONT).
*/
import type { Vec2 } from '@ziroeda/kimath/src/math/vector2.js';
import { BOX2I } from '@ziroeda/kimath/src/math/box2.js';
import { SHAPE_RECT } from '@ziroeda/kimath/src/geometry/shape_rect.js';
import { EDA_ANGLE, ANGLE_0, ANGLE_90 } from '@ziroeda/kimath/src/geometry/eda_angle.js';
import { RotatePoint } from '@ziroeda/kimath/src/trigo.js';
import { KiROUND } from '@ziroeda/kimath/src/math/util.js';
import { ERROR_LOC } from '@ziroeda/kimath/src/convert_basic_shapes_to_polygon.js';
import {
SHAPE_POLY_SET,
TransformRoundChamferedRectToPolygon,
} from '@ziroeda/kimath/src/geometry/shape_poly_set.js';
import { GR_TEXT_H_ALIGN_T, GR_TEXT_V_ALIGN_T } from '../eda_text.js';
import { COLOR4D_WHITE, type Color4d } from '../gal/color4d.js';
import type { PlotterRenderSettings } from '../render_settings.js';
import {
DO_NOT_SET_LINE_WIDTH,
FILL_T,
LINE_STYLE,
PLOT_FORMAT,
PLOT_TEXT_MODE,
PLOTTER,
type PLOTTER_FONT,
type PLOTTER_TEXT_ATTRIBUTES,
type PEN_PLUME,
toVector2I,
USE_DEFAULT_LINE_WIDTH,
} from './plotter.js';
const colorEquals = (a: Color4d, b: Color4d): boolean =>
a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a;
/**
* `wxImage`, reduced to what PlotImage uses. The accessors are per pixel rather
* than a data buffer because that is literally what upstream calls: PS_PLOTTER
* reads `GetRed( x, y )` where PDF_PLOTTER walks `GetData()`.
*/
export interface PsImage {
GetWidth(): number;
GetHeight(): number;
GetRed(x: number, y: number): number;
GetGreen(x: number, y: number): number;
GetBlue(x: number, y: number): number;
HasAlpha(): boolean;
/** Only read when HasAlpha(). */
GetAlpha(x: number, y: number): number;
HasMask(): boolean;
GetMaskRed(): number;
GetMaskGreen(): number;
GetMaskBlue(): number;
}
// ===========================================================================
// Number formatting
// ===========================================================================
import { formatG } from './fmt.js';
/** The `{:.3g}` `emitSetRGBColor` alone asks for, above a comment asking why. */
export const RGB_G_PRECISION = 3;
// ===========================================================================
// Free functions
// ===========================================================================
/**
* `getFillId` (PS_plotter.cpp:49). Everything that is neither NO_FILL nor
* FILLED_SHAPE — a hatch, a background fill, a colour fill — lands on 2, and
* the prolog's `cir2`/`arc2`/`poly2`/`rect2` are identical to their `…1`
* siblings, so id 2 paints exactly like a plain filled shape.
*/
export function getFillId(aFill: FILL_T): number {
if (aFill === FILL_T.NO_FILL) return 0;
if (aFill === FILL_T.FILLED_SHAPE) return 1;
return 2;
}
/**
* `PSLIKE_PLOTTER::encodeStringForPlotter` (PS_plotter.cpp:227) — the base
* version, which PS uses and PDF overrides. The result is a *byte* string
* dressed as a JavaScript string: every code unit is in 0..255 and is written
* to the file as one byte, i.e. Latin-1.
*
* Two upstream details are load bearing. Any character at or above U+0100 is
* dropped outright — the `if( ch < 256 )` has no else — so a Cyrillic title
* reaches the file as an empty literal rather than as mojibake. And the escape
* arm falls through into the default arm, which is what makes `(` come out as
* `\(` and not as a bare backslash.
*
* Iterating code points rather than UTF-16 units matches the Linux wxString,
* where `aUnicode[i]` is a code point; an astral character is therefore one
* dropped element, not two.
*/
export function encodeStringForPlotter(aUnicode: string): string {
let converted = '(';
for (const c of aUnicode) {
const ch = c.codePointAt(0)!;
if (ch < 256) {
// These characters must be escaped
if (ch === 0x28 || ch === 0x29 || ch === 0x5c) converted += '\\';
converted += String.fromCharCode(ch);
}
}
return `${converted})`;
}
/**
* `ctime`, which is what `%%CreationDate` is handed verbatim — trailing newline
* included, which is why the format string that prints it has none of its own.
* The C locale form is `Www Mmm dd hh:mm:ss yyyy\n` with the day of the month
* blank-padded, not zero-padded, to two columns.
*/
export function psCreationDate(aNow: Date): string {
const days = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
const months = [
'Jan',
'Feb',
'Mar',
'Apr',
'May',
'Jun',
'Jul',
'Aug',
'Sep',
'Oct',
'Nov',
'Dec',
];
const pad = (aValue: number): string => String(aValue).padStart(2, '0');
return (
`${days[aNow.getDay()]} ${months[aNow.getMonth()]} ` +
`${String(aNow.getDate()).padStart(2, ' ')} ` +
`${pad(aNow.getHours())}:${pad(aNow.getMinutes())}:${pad(aNow.getSeconds())} ` +
`${aNow.getFullYear()}\n`
);
}
/**
* `PSMacro` (PS_plotter.cpp:731), the prolog every PostScript plot opens with.
* Byte for byte upstream's, indentation and all: the two-line `arc1`/`arc2` and
* `textshow` definitions really are wrapped where they are, and `reencodefont`
* really is indented two spaces where everything around it is indented four.
*/
export const PS_MACRO_PROLOG =
'%%BeginProlog\n' +
'/line { newpath moveto lineto stroke } bind def\n' +
'/cir0 { newpath 0 360 arc stroke } bind def\n' +
'/cir1 { newpath 0 360 arc gsave fill grestore stroke } bind def\n' +
'/cir2 { newpath 0 360 arc gsave fill grestore stroke } bind def\n' +
'/arc0 { newpath arc stroke } bind def\n' +
'/arc1 { newpath 4 index 4 index moveto arc closepath gsave fill\n' +
' grestore stroke } bind def\n' +
'/arc2 { newpath 4 index 4 index moveto arc closepath gsave fill\n' +
' grestore stroke } bind def\n' +
'/poly0 { stroke } bind def\n' +
'/poly1 { closepath gsave fill grestore stroke } bind def\n' +
'/poly2 { closepath gsave fill grestore stroke } bind def\n' +
'/rect0 { rectstroke } bind def\n' +
'/rect1 { rectfill } bind def\n' +
'/rect2 { rectfill } bind def\n' +
'/linemode0 { 0 setlinecap 0 setlinejoin 0 setlinewidth } bind def\n' +
'/linemode1 { 1 setlinecap 1 setlinejoin } bind def\n' +
'/dashedline { [200] 100 setdash } bind def\n' +
'/solidline { [] 0 setdash } bind def\n' +
'/phantomshow { moveto\n' +
' /KicadFont findfont 0.000001 scalefont setfont\n' +
' show } bind def\n' +
'/textshow { gsave\n' +
' findfont exch scalefont setfont concat 1 scale 0 0 moveto show\n' +
' } bind def\n' +
'/reencodefont {\n' +
' findfont dup length dict begin\n' +
' { 1 index /FID ne\n' +
' { def }\n' +
' { pop pop } ifelse\n' +
' } forall\n' +
' /Encoding ISOLatin1Encoding def\n' +
' currentdict\n' +
' end } bind def\n' +
'/KicadFont /Helvetica reencodefont definefont pop\n' +
'/KicadFont-Bold /Helvetica-Bold reencodefont definefont pop\n' +
'/KicadFont-Oblique /Helvetica-Oblique reencodefont definefont pop\n' +
'/KicadFont-BoldOblique /Helvetica-BoldOblique reencodefont definefont pop\n' +
'%%EndProlog\n';
/** `PSLIKE_PLOTTER::postscriptTextAscent`: the Helvetica AFM ascent. */
export const POSTSCRIPT_TEXT_ASCENT = 0.718;
/** `BIGPTsPERMIL`: big points (1/72 inch) per mil. */
const BIGPTsPERMIL = 0.072;
const TEXT_ENCODER = new TextEncoder();
// ===========================================================================
// Helvetica AFM character widths (PS_plotter.cpp:951 onwards)
// ===========================================================================
/** Character widths for Helvetica, as fractions of the em (Adobe AFM). */
const hv_widths: readonly number[] = [
0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278,
0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278,
0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.355, 0.556, 0.556, 0.889, 0.667, 0.191, 0.333, 0.333,
0.389, 0.584, 0.278, 0.333, 0.278, 0.278, 0.556, 0.556, 0.556, 0.556, 0.556, 0.556, 0.556, 0.556,
0.556, 0.556, 0.278, 0.278, 0.584, 0.584, 0.584, 0.556, 1.015, 0.667, 0.667, 0.722, 0.722, 0.667,
0.611, 0.778, 0.722, 0.278, 0.5, 0.667, 0.556, 0.833, 0.722, 0.778, 0.667, 0.778, 0.722, 0.667,
0.611, 0.722, 0.667, 0.944, 0.667, 0.667, 0.611, 0.278, 0.278, 0.278, 0.469, 0.556, 0.333, 0.556,
0.556, 0.5, 0.556, 0.556, 0.278, 0.556, 0.556, 0.222, 0.222, 0.5, 0.222, 0.833, 0.556, 0.556,
0.556, 0.556, 0.333, 0.5, 0.278, 0.556, 0.5, 0.722, 0.5, 0.5, 0.5, 0.334, 0.26, 0.334, 0.584,
0.278, 0.278, 0.278, 0.222, 0.556, 0.333, 1.0, 0.556, 0.556, 0.333, 1.0, 0.667, 0.333, 1.0, 0.278,
0.278, 0.278, 0.278, 0.222, 0.222, 0.333, 0.333, 0.35, 0.556, 1.0, 0.333, 1.0, 0.5, 0.333, 0.944,
0.278, 0.278, 0.667, 0.278, 0.333, 0.556, 0.556, 0.556, 0.556, 0.26, 0.556, 0.333, 0.737, 0.37,
0.556, 0.584, 0.333, 0.737, 0.333, 0.4, 0.584, 0.333, 0.333, 0.333, 0.556, 0.537, 0.278, 0.333,
0.333, 0.365, 0.556, 0.834, 0.834, 0.834, 0.611, 0.667, 0.667, 0.667, 0.667, 0.667, 0.667, 1.0,
0.722, 0.667, 0.667, 0.667, 0.667, 0.278, 0.278, 0.278, 0.278, 0.722, 0.722, 0.778, 0.778, 0.778,
0.778, 0.778, 0.584, 0.778, 0.722, 0.722, 0.722, 0.722, 0.667, 0.667, 0.611, 0.556, 0.556, 0.556,
0.556, 0.556, 0.556, 0.889, 0.5, 0.556, 0.556, 0.556, 0.556, 0.278, 0.278, 0.278, 0.278, 0.556,
0.556, 0.556, 0.556, 0.556, 0.556, 0.556, 0.584, 0.611, 0.556, 0.556, 0.556, 0.556, 0.5, 0.556,
0.5,
];
/** Character widths for Helvetica-Bold. */
const hvb_widths: readonly number[] = [
0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278,
0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278,
0.278, 0.278, 0.278, 0.278, 0.278, 0.333, 0.474, 0.556, 0.556, 0.889, 0.722, 0.238, 0.333, 0.333,
0.389, 0.584, 0.278, 0.333, 0.278, 0.278, 0.556, 0.556, 0.556, 0.556, 0.556, 0.556, 0.556, 0.556,
0.556, 0.556, 0.333, 0.333, 0.584, 0.584, 0.584, 0.611, 0.975, 0.722, 0.722, 0.722, 0.722, 0.667,
0.611, 0.778, 0.722, 0.278, 0.556, 0.722, 0.611, 0.833, 0.722, 0.778, 0.667, 0.778, 0.722, 0.667,
0.611, 0.722, 0.667, 0.944, 0.667, 0.667, 0.611, 0.333, 0.278, 0.333, 0.584, 0.556, 0.333, 0.556,
0.611, 0.556, 0.611, 0.556, 0.333, 0.611, 0.611, 0.278, 0.278, 0.556, 0.278, 0.889, 0.611, 0.611,
0.611, 0.611, 0.389, 0.556, 0.333, 0.611, 0.556, 0.778, 0.556, 0.556, 0.5, 0.389, 0.28, 0.389,
0.584, 0.278, 0.278, 0.278, 0.278, 0.556, 0.5, 1.0, 0.556, 0.556, 0.333, 1.0, 0.667, 0.333, 1.0,
0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.5, 0.5, 0.35, 0.556, 1.0, 0.333, 1.0, 0.556, 0.333,
0.944, 0.278, 0.278, 0.667, 0.278, 0.333, 0.556, 0.556, 0.556, 0.556, 0.28, 0.556, 0.333, 0.737,
0.37, 0.556, 0.584, 0.333, 0.737, 0.333, 0.4, 0.584, 0.333, 0.333, 0.333, 0.611, 0.556, 0.278,
0.333, 0.333, 0.365, 0.556, 0.834, 0.834, 0.834, 0.611, 0.722, 0.722, 0.722, 0.722, 0.722, 0.722,
1.0, 0.722, 0.667, 0.667, 0.667, 0.667, 0.278, 0.278, 0.278, 0.278, 0.722, 0.722, 0.778, 0.778,
0.778, 0.778, 0.778, 0.584, 0.778, 0.722, 0.722, 0.722, 0.722, 0.667, 0.667, 0.611, 0.556, 0.556,
0.556, 0.556, 0.556, 0.556, 0.889, 0.556, 0.556, 0.556, 0.556, 0.556, 0.278, 0.278, 0.278, 0.278,
0.611, 0.611, 0.611, 0.611, 0.611, 0.611, 0.611, 0.584, 0.611, 0.611, 0.611, 0.611, 0.611, 0.556,
0.611, 0.556,
];
/** Character widths for Helvetica-Oblique. Identical to hv_widths — an
* oblique face is a shear, so it shares its upright metrics. */
const hvo_widths: readonly number[] = [
0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278,
0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278,
0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.355, 0.556, 0.556, 0.889, 0.667, 0.191, 0.333, 0.333,
0.389, 0.584, 0.278, 0.333, 0.278, 0.278, 0.556, 0.556, 0.556, 0.556, 0.556, 0.556, 0.556, 0.556,
0.556, 0.556, 0.278, 0.278, 0.584, 0.584, 0.584, 0.556, 1.015, 0.667, 0.667, 0.722, 0.722, 0.667,
0.611, 0.778, 0.722, 0.278, 0.5, 0.667, 0.556, 0.833, 0.722, 0.778, 0.667, 0.778, 0.722, 0.667,
0.611, 0.722, 0.667, 0.944, 0.667, 0.667, 0.611, 0.278, 0.278, 0.278, 0.469, 0.556, 0.333, 0.556,
0.556, 0.5, 0.556, 0.556, 0.278, 0.556, 0.556, 0.222, 0.222, 0.5, 0.222, 0.833, 0.556, 0.556,
0.556, 0.556, 0.333, 0.5, 0.278, 0.556, 0.5, 0.722, 0.5, 0.5, 0.5, 0.334, 0.26, 0.334, 0.584,
0.278, 0.278, 0.278, 0.222, 0.556, 0.333, 1.0, 0.556, 0.556, 0.333, 1.0, 0.667, 0.333, 1.0, 0.278,
0.278, 0.278, 0.278, 0.222, 0.222, 0.333, 0.333, 0.35, 0.556, 1.0, 0.333, 1.0, 0.5, 0.333, 0.944,
0.278, 0.278, 0.667, 0.278, 0.333, 0.556, 0.556, 0.556, 0.556, 0.26, 0.556, 0.333, 0.737, 0.37,
0.556, 0.584, 0.333, 0.737, 0.333, 0.4, 0.584, 0.333, 0.333, 0.333, 0.556, 0.537, 0.278, 0.333,
0.333, 0.365, 0.556, 0.834, 0.834, 0.834, 0.611, 0.667, 0.667, 0.667, 0.667, 0.667, 0.667, 1.0,
0.722, 0.667, 0.667, 0.667, 0.667, 0.278, 0.278, 0.278, 0.278, 0.722, 0.722, 0.778, 0.778, 0.778,
0.778, 0.778, 0.584, 0.778, 0.722, 0.722, 0.722, 0.722, 0.667, 0.667, 0.611, 0.556, 0.556, 0.556,
0.556, 0.556, 0.556, 0.889, 0.5, 0.556, 0.556, 0.556, 0.556, 0.278, 0.278, 0.278, 0.278, 0.556,
0.556, 0.556, 0.556, 0.556, 0.556, 0.556, 0.584, 0.611, 0.556, 0.556, 0.556, 0.556, 0.5, 0.556,
0.5,
];
/** Character widths for Helvetica-BoldOblique. Identical to hvb_widths. */
const hvbo_widths: readonly number[] = [
0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278,
0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.278,
0.278, 0.278, 0.278, 0.278, 0.278, 0.333, 0.474, 0.556, 0.556, 0.889, 0.722, 0.238, 0.333, 0.333,
0.389, 0.584, 0.278, 0.333, 0.278, 0.278, 0.556, 0.556, 0.556, 0.556, 0.556, 0.556, 0.556, 0.556,
0.556, 0.556, 0.333, 0.333, 0.584, 0.584, 0.584, 0.611, 0.975, 0.722, 0.722, 0.722, 0.722, 0.667,
0.611, 0.778, 0.722, 0.278, 0.556, 0.722, 0.611, 0.833, 0.722, 0.778, 0.667, 0.778, 0.722, 0.667,
0.611, 0.722, 0.667, 0.944, 0.667, 0.667, 0.611, 0.333, 0.278, 0.333, 0.584, 0.556, 0.333, 0.556,
0.611, 0.556, 0.611, 0.556, 0.333, 0.611, 0.611, 0.278, 0.278, 0.556, 0.278, 0.889, 0.611, 0.611,
0.611, 0.611, 0.389, 0.556, 0.333, 0.611, 0.556, 0.778, 0.556, 0.556, 0.5, 0.389, 0.28, 0.389,
0.584, 0.278, 0.278, 0.278, 0.278, 0.556, 0.5, 1.0, 0.556, 0.556, 0.333, 1.0, 0.667, 0.333, 1.0,
0.278, 0.278, 0.278, 0.278, 0.278, 0.278, 0.5, 0.5, 0.35, 0.556, 1.0, 0.333, 1.0, 0.556, 0.333,
0.944, 0.278, 0.278, 0.667, 0.278, 0.333, 0.556, 0.556, 0.556, 0.556, 0.28, 0.556, 0.333, 0.737,
0.37, 0.556, 0.584, 0.333, 0.737, 0.333, 0.4, 0.584, 0.333, 0.333, 0.333, 0.611, 0.556, 0.278,
0.333, 0.333, 0.365, 0.556, 0.834, 0.834, 0.834, 0.611, 0.722, 0.722, 0.722, 0.722, 0.722, 0.722,
1.0, 0.722, 0.667, 0.667, 0.667, 0.667, 0.278, 0.278, 0.278, 0.278, 0.722, 0.722, 0.778, 0.778,
0.778, 0.778, 0.778, 0.584, 0.778, 0.722, 0.722, 0.722, 0.722, 0.667, 0.667, 0.611, 0.556, 0.556,
0.556, 0.556, 0.556, 0.556, 0.889, 0.556, 0.556, 0.556, 0.556, 0.556, 0.278, 0.278, 0.278, 0.278,
0.611, 0.611, 0.611, 0.611, 0.611, 0.611, 0.611, 0.584, 0.611, 0.611, 0.611, 0.611, 0.611, 0.556,
0.611, 0.556,
];
/**
* `PSLIKE_PLOTTER` (include/plotters/plotters_pslike.h, common/plotters/
* PS_plotter.cpp): the PostScript-like plotters' shared half — colour, text
* mode, fine scale adjustment, the pad flashes and the PostScript text metrics
* PS and PDF both use.
*/
export abstract class PSLIKE_PLOTTER extends PLOTTER {
/** Fine user scale adjust ( = 1.0 if no correction). */
protected plotScaleAdjX = 1;
protected plotScaleAdjY = 1;
/** How to draw text. */
protected m_textMode: PLOT_TEXT_MODE = PLOT_TEXT_MODE.PHANTOM;
/** Height of the postscript font (from the AFM). */
static readonly postscriptTextAscent = POSTSCRIPT_TEXT_ASCENT;
/** `PSLIKE_PLOTTER::SetTextMode`. DEFAULT means "leave the mode alone". */
override SetTextMode(aMode: PLOT_TEXT_MODE): void {
if (aMode !== PLOT_TEXT_MODE.DEFAULT) this.m_textMode = aMode;
}
GetTextMode(): PLOT_TEXT_MODE {
return this.m_textMode;
}
/** `PSLIKE_PLOTTER::SetScaleAdjust`, the fine scaling StartPlot folds in. */
SetScaleAdjust(aScaleX: number, aScaleY: number): void {
this.plotScaleAdjX = aScaleX;
this.plotScaleAdjY = aScaleY;
}
/** `PSLIKE_PLOTTER::FlashPadCircle`. */
FlashPadCircle(aPadPos: Vec2, aDiameter: number, _aData?: unknown): void {
this.Circle(aPadPos, aDiameter, FILL_T.FILLED_SHAPE, 0);
}
/**
* `PSLIKE_PLOTTER::FlashPadOval`. The pad is first normalised to a *vertical*
* tablet by swapping the axes and adding 90 degrees, then drawn as one thick
* segment between the two cap centres. `delta / 2` is integer division, so an
* odd-length oval loses half an IU off each cap.
*/
FlashPadOval(aPadPos: Vec2, aSize: Vec2, aPadOrient: EDA_ANGLE, aData?: unknown): void {
const size = { x: aSize.x, y: aSize.y };
let orient = aPadOrient;
// The pad is reduced to an oval by dy > dx
if (size.x > size.y) {
[size.x, size.y] = [size.y, size.x];
orient = orient.add(ANGLE_90);
}
const delta = size.y - size.x;
let a = { x: 0, y: Math.trunc(-delta / 2) };
let b = { x: 0, y: Math.trunc(delta / 2) };
a = RotatePoint(a, orient);
b = RotatePoint(b, orient);
this.ThickSegment(
{ x: a.x + aPadPos.x, y: a.y + aPadPos.y },
{ x: b.x + aPadPos.x, y: b.y + aPadPos.y },
size.x,
aData,
);
}
/**
* `PSLIKE_PLOTTER::FlashPadRect`. The corners are built anticlockwise from the
* bottom-left, rotated *about the pad centre*, and then the first is repeated
* to close the ring — which `poly1` would have closed anyway, so the fifth
* point is a duplicated `lineto` in the output.
*/
FlashPadRect(aPadPos: Vec2, aSize: Vec2, aPadOrient: EDA_ANGLE, aData?: unknown): void {
const dx = Math.trunc(aSize.x / 2);
const dy = Math.trunc(aSize.y / 2);
let cornerList: Vec2[] = [
{ x: aPadPos.x - dx, y: aPadPos.y + dy },
{ x: aPadPos.x - dx, y: aPadPos.y - dy },
{ x: aPadPos.x + dx, y: aPadPos.y - dy },
{ x: aPadPos.x + dx, y: aPadPos.y + dy },
];
cornerList = cornerList.map((corner) => RotatePoint(corner, aPadPos, aPadOrient));
cornerList.push(cornerList[0]!);
this.PlotPoly(cornerList, FILL_T.FILLED_SHAPE, 0, aData);
}
/** `PSLIKE_PLOTTER::FlashPadRoundRect`: the outline as one filled polygon. */
FlashPadRoundRect(
aPadPos: Vec2,
aSize: Vec2,
aCornerRadius: number,
aOrient: EDA_ANGLE,
aData?: unknown,
): void {
const outline = new SHAPE_POLY_SET();
TransformRoundChamferedRectToPolygon(
outline,
aPadPos,
aSize,
aOrient,
aCornerRadius,
0.0,
0,
0,
this.GetPlotterArcHighDef(),
ERROR_LOC.ERROR_INSIDE,
);
const cornerList: Vec2[] = [];
// TransformRoundRectToPolygon creates only one convex polygon
const poly = outline.Outline(0);
for (let ii = 0; ii < poly.PointCount(); ++ii) {
const p = poly.CPoint(ii);
cornerList.push({ x: p.x, y: p.y });
}
// Close polygon
cornerList.push(cornerList[0]!);
this.PlotPoly(cornerList, FILL_T.FILLED_SHAPE, 0, aData);
}
/** `PSLIKE_PLOTTER::FlashPadCustom`: each outline a filled polygon; holes too. */
FlashPadCustom(
_aPadPos: Vec2,
_aSize: Vec2,
_aOrient: EDA_ANGLE,
aPolygons: SHAPE_POLY_SET,
aData?: unknown,
): void {
for (let cnt = 0; cnt < aPolygons.OutlineCount(); ++cnt) {
const poly = aPolygons.Outline(cnt);
const cornerList: Vec2[] = [];
for (let ii = 0; ii < poly.PointCount(); ++ii) {
const p = poly.CPoint(ii);
cornerList.push({ x: p.x, y: p.y });
}
// Close polygon
cornerList.push(cornerList[0]!);
this.PlotPoly(cornerList, FILL_T.FILLED_SHAPE, 0, aData);
}
}
/**
* `PSLIKE_PLOTTER::FlashPadTrapez`. The corners rotate about the *origin* and
* only then translate by the pad position, so they arrive relative to the pad.
*/
FlashPadTrapez(
aPadPos: Vec2,
aCorners: readonly Vec2[],
aPadOrient: EDA_ANGLE,
aData?: unknown,
): void {
const cornerList: Vec2[] = [];
for (let ii = 0; ii < 4; ii++) cornerList.push({ x: aCorners[ii]!.x, y: aCorners[ii]!.y });
for (let ii = 0; ii < 4; ii++) {
const rotated = RotatePoint(cornerList[ii]!, aPadOrient);
cornerList[ii] = { x: rotated.x + aPadPos.x, y: rotated.y + aPadPos.y };
}
cornerList.push(cornerList[0]!);
this.PlotPoly(cornerList, FILL_T.FILLED_SHAPE, 0, aData);
}
/**
* `PSLIKE_PLOTTER::FlashRegularPolygon`. The whole body is `wxASSERT( 0 )`
* with the comment "Do nothing", so in a release build this draws nothing at
* all — which is the behaviour, not an omission.
*/
FlashRegularPolygon(
_aShapePos: Vec2,
_aRadius: number,
_aCornerCount: number,
_aOrient: EDA_ANGLE,
_aData?: unknown,
): void {
// Do nothing
}
/**
* `PSLIKE_PLOTTER::SetColor`. In mono mode only exact white survives as white
* — every other colour, alpha included in the comparison, becomes black, and
* the alpha is forced to 1.
*/
SetColor(aColor: Color4d): void {
if (this.m_colorMode) {
if (this.m_negativeMode)
this.emitSetRGBColor(1 - aColor.r, 1 - aColor.g, 1 - aColor.b, aColor.a);
else this.emitSetRGBColor(aColor.r, aColor.g, aColor.b, aColor.a);
} else {
// B/W mode: pcbnew relies on the two colours to draw holes white on black pads.
let k = 1; // White
if (!colorEquals(aColor, COLOR4D_WHITE)) k = 0;
if (this.m_negativeMode) this.emitSetRGBColor(1 - k, 1 - k, 1 - k, 1.0);
else this.emitSetRGBColor(k, k, k, 1.0);
}
}
/**
* `PSLIKE_PLOTTER::encodeStringForPlotter` — the free function below; PDF
* overrides it.
*/
protected encodeStringForPlotter(aUnicode: string): string {
return encodeStringForPlotter(aUnicode);
}
/** Virtual primitive for emitting the setrgbcolor operator. */
protected abstract emitSetRGBColor(r: number, g: number, b: number, a: number): void;
/**
* `PSLIKE_PLOTTER::returnPostscriptTextWidth`. The AFM widths are fractions of
* the em, so the tally is scaled by the requested x size and divided by the
* ascent — "widths are proportional to height, but height is enlarged by a
* scaling factor". Code points at or above 256 are simply not counted, which
* is why a Cyrillic string measures zero.
*/
returnPostscriptTextWidth(
aText: string,
aXSize: number,
aItalic: boolean,
aBold: boolean,
): number {
const width_table = aBold
? aItalic
? hvbo_widths
: hvb_widths
: aItalic
? hvo_widths
: hv_widths;
let tally = 0;
for (const c of aText) {
// Skip the negation marks and untabled points.
const asciiCode = c.codePointAt(0)!;
if (asciiCode < 256) tally += width_table[asciiCode]!;
}
// Widths are proportional to height, but height is enlarged by a scaling factor.
return KiROUND((aXSize * tally) / POSTSCRIPT_TEXT_ASCENT);
}
/**
* `PSLIKE_PLOTTER::computeTextParameters`, the shared PS/PDF text alignment
* core. PS_PLOTTER never calls it — only PDF_PLOTTER::Text does — but it lives
* in PS_plotter.cpp and belongs to the class being ported, and it is pure
* enough to check on its own.
*
* Two upstream faults are reproduced. The width estimate is asked for with
* `returnPostscriptTextWidth( aText, aSize.x, aItalic, aWidth )`, passing the
* integer pen width into the `bool aBold` parameter — so *any* non-zero pen
* selects the bold table regardless of `aBold`. And `tw`/`th` are rotated by
* the text angle and then never read again; the call is kept because removing
* it would be an edit, not a port.
*/
computeTextParameters(
aPos: Vec2,
aText: string,
aOrient: EDA_ANGLE,
aSize: Vec2,
aMirror: boolean,
aH_justify: GR_TEXT_H_ALIGN_T,
aV_justify: GR_TEXT_V_ALIGN_T,
aWidth: number,
aItalic: boolean,
_aBold: boolean,
): {
wideningFactor: number;
ctm_a: number;
ctm_b: number;
ctm_c: number;
ctm_d: number;
ctm_e: number;
ctm_f: number;
heightFactor: number;
} {
// Compute the starting position (compensated for alignment)
const start_pos = { x: aPos.x, y: aPos.y };
// This is an approximation of the text bounds (in IUs)
// NOTE: aWidth, an int, is handed to the bool aBold parameter.
const tw = this.returnPostscriptTextWidth(aText, aSize.x, aItalic, aWidth !== 0);
const th = aSize.y;
let dx = 0;
let dy = 0;
switch (aH_justify) {
case GR_TEXT_H_ALIGN_T.GR_TEXT_H_ALIGN_CENTER:
dx = Math.trunc(-tw / 2);
break;
case GR_TEXT_H_ALIGN_T.GR_TEXT_H_ALIGN_RIGHT:
dx = -tw;
break;
case GR_TEXT_H_ALIGN_T.GR_TEXT_H_ALIGN_LEFT:
dx = 0;
break;
}
switch (aV_justify) {
case GR_TEXT_V_ALIGN_T.GR_TEXT_V_ALIGN_CENTER:
dy = Math.trunc(th / 2);
break;
case GR_TEXT_V_ALIGN_T.GR_TEXT_V_ALIGN_TOP:
dy = th;
break;
case GR_TEXT_V_ALIGN_T.GR_TEXT_V_ALIGN_BOTTOM:
dy = 0;
break;
}
const d = RotatePoint({ x: dx, y: dy }, aOrient);
// tw/th are rotated upstream and then discarded; kept for fidelity.
RotatePoint({ x: tw, y: th }, aOrient);
start_pos.x += d.x;
start_pos.y += d.y;
const pos_dev = this.userToDeviceCoordinates(start_pos);
const sz_dev = this.userToDeviceSizeV(aSize);
// Now returns the final values... the widening factor
let wideningFactor = sz_dev.x / sz_dev.y;
// Mirrored texts must be plotted as mirrored!
if (this.m_plotMirror !== aMirror) wideningFactor = -wideningFactor;
// The CTM transformation matrix
const alpha = this.m_plotMirror ? aOrient.Invert().AsRadians() : aOrient.AsRadians();
const sinalpha = Math.sin(alpha);
const cosalpha = Math.cos(alpha);
return {
wideningFactor,
ctm_a: cosalpha,
ctm_b: sinalpha,
ctm_c: -sinalpha,
ctm_d: cosalpha,
ctm_e: pos_dev.x,
ctm_f: pos_dev.y,
// This is because the letters are less than 1 unit high
heightFactor: sz_dev.y / POSTSCRIPT_TEXT_ASCENT,
};
}
}
/**
* `PS_PLOTTER` (include/plotters/plotters_pslike.h, common/plotters/
* PS_plotter.cpp).
*
* Drive it exactly as upstream does: OpenFile / SetCreator / SetTitle /
* SetPageSettings / SetColorMode / SetViewport, then StartPlot, then geometry,
* then EndPlot. Read the finished document back with `bytes()`, or — since all
* but the two encoded-string call sites are ASCII — with `text()`.
*/
export class PS_PLOTTER extends PSLIKE_PLOTTER {
/** The output file, as bytes: the document mixes UTF-8 and Latin-1. */
private out: number[] = [];
constructor(aRenderSettings: PlotterRenderSettings | null = null) {
super();
// The phantom plot in postscript is an hack and reportedly
// crashes Adobe's own postscript interpreter!
this.m_textMode = PLOT_TEXT_MODE.STROKE;
this.m_renderSettings = aRenderSettings;
}
static GetDefaultFileExtension(): string {
return 'ps';
}
override GetPlotterType(): PLOT_FORMAT {
return PLOT_FORMAT.POST;
}
// =========================================================================
// Output buffer
// =========================================================================
/** `fmt::print( m_outputFile, … )` for markup and `TO_UTF8`-ed strings. */
private emit(aText: string): void {
for (const byte of TEXT_ENCODER.encode(aText)) this.out.push(byte);
}
/**
* An `encodeStringForPlotter` result, whose code units are already bytes.
* Writing these through `emit` would UTF-8 expand them and desynchronise the
* one thing PostScript counts on: the parenthesis nesting of a literal.
*/
private emitLatin1(aText: string): void {
for (let i = 0; i < aText.length; i++) this.out.push(aText.charCodeAt(i) & 0xff);
}
/** The plotted document. This, not `text()`, is what belongs on disk. */
bytes(): Uint8Array {
return Uint8Array.from(this.out);
}
/** The document decoded as Latin-1, so a test can read operators as prose. */
text(): string {
let result = '';
for (const byte of this.out) result += String.fromCharCode(byte);
return result;
}
// =========================================================================
// Setup
// =========================================================================
/**
* `PS_PLOTTER::SetViewport`. Unlike PDF's, this one *does* compute the paper
* size, and with two truncations: PAGE_INFO's mils are a VECTOR2D landing in
* a VECTOR2I member, and each `int *= double` truncates again.
*/
SetViewport(aOffset: Vec2, aIusPerDecimil: number, aScale: number, aMirror: boolean): void {
this.m_plotMirror = aMirror;
this.m_plotOffset = { x: aOffset.x, y: aOffset.y };
this.m_plotScale = aScale;
this.m_IUsPerDecimil = aIusPerDecimil;
this.m_iuPerDeviceUnit = 1.0 / aIusPerDecimil;
// Compute the paper size in IUs
const paperSize = toVector2I(this.PageSettings().GetSizeMils());
this.m_paperSize = {
x: Math.trunc(paperSize.x * (10.0 * aIusPerDecimil)),
y: Math.trunc(paperSize.y * (10.0 * aIusPerDecimil)),
};
}
// =========================================================================
// Coordinates
// =========================================================================
// =========================================================================
// Graphics state
// =========================================================================
/**
* `PS_PLOTTER::SetCurrentLineWidth`. The sentinel handling is an `else if`
* chain, and that is the whole difference from PDF's: a caller asking for
* USE_DEFAULT_LINE_WIDTH against a zero default pen keeps a *zero* pen here,
* where PDF's separate `if` would have clamped it to one. Every NO_FILL entry
* point below then tests `GetCurrentLineWidth() <= 0` and draws nothing, so
* the zero is not academic.
*
* `setlinewidth` is only written when the width *changes*, but the member is
* assigned either way — so DO_NOT_SET_LINE_WIDTH, which returns early, is the
* one path that leaves the member alone.
*/
SetCurrentLineWidth(aWidth: number, _aData?: unknown): void {
let width = aWidth;
if (width === DO_NOT_SET_LINE_WIDTH) return;
else if (width === USE_DEFAULT_LINE_WIDTH) width = this.renderSettings().GetDefaultPenWidth();
else if (width === 0) width = 1;
if (width !== this.GetCurrentLineWidth())
this.emit(`${formatG(this.userToDeviceSize(width))} setlinewidth\n`);
this.m_currentPenWidth = width;
}
/**
* `PS_PLOTTER::emitSetRGBColor`. PostScript treats every colour as opaque, so
* a translucent one is pre-blended against white paper. The three components
* are the only numbers in the whole back-end written at `{:.3g}` instead of
* `{:g}`; upstream's comment on the line is "XXX why %.3g ? shouldn't %g
* suffice? who cares...".
*/
protected override emitSetRGBColor(r: number, g: number, b: number, a: number): void {
let red = r;
let green = g;
let blue = b;
if (a < 1.0) {
red = red * a + (1 - a);
green = green * a + (1 - a);
blue = blue * a + (1 - a);
}
const p = RGB_G_PRECISION;
this.emit(`${formatG(red, p)} ${formatG(green, p)} ${formatG(blue, p)} setrgbcolor\n`);
}
/**
* `PS_PLOTTER::SetDash`. Each element is *truncated* to an int, so a pattern
* computed from a small pen collapses to `[0 0]` rather than falling back to
* solid — PDF guards against that, PostScript does not. SOLID and DEFAULT
* share the default arm, which calls the prolog's `solidline` macro instead
* of writing a `setdash` of its own.
*/
SetDash(aLineWidth: number, aLineStyle: LINE_STYLE): void {
const dash = (): number => Math.trunc(this.GetDashMarkLenIU(aLineWidth));
const dot = (): number => Math.trunc(this.GetDotMarkLenIU(aLineWidth));
const gap = (): number => Math.trunc(this.GetDashGapLenIU(aLineWidth));
switch (aLineStyle) {
case LINE_STYLE.DASH:
this.emit(`[${dash()} ${gap()}] 0 setdash\n`);
break;
case LINE_STYLE.DOT:
this.emit(`[${dot()} ${gap()}] 0 setdash\n`);
break;
case LINE_STYLE.DASHDOT:
this.emit(`[${dash()} ${gap()} ${dot()} ${gap()}] 0 setdash\n`);
break;
case LINE_STYLE.DASHDOTDOT:
this.emit(`[${dash()} ${gap()} ${dot()} ${gap()} ${dot()} ${gap()}] 0 setdash\n`);
break;
default:
this.emit('solidline\n');
}
}
// =========================================================================
// Entities
// =========================================================================
/**
* `PS_PLOTTER::Rect`. The pen is set *before* the "nothing to draw" test, so
* the test reads the resolved pen and not the caller's sentinel — and a
* zero-sized rectangle is emitted as-is, because `rectstroke` and `rectfill`
* both cope with a degenerate box where PDF had to special-case it.
*/
Rect(p1: Vec2, p2: Vec2, fill: FILL_T, width: number, aCornerRadius = 0): void {
this.SetCurrentLineWidth(width);
if (fill === FILL_T.NO_FILL && this.GetCurrentLineWidth() <= 0) return;
if (aCornerRadius > 0) {
const box = new BOX2I(p1, { x: p2.x - p1.x, y: p2.y - p1.y });
box.Normalize();
const rect = new SHAPE_RECT(box);
rect.SetRadius(aCornerRadius);
this.PlotPolyLineChain(rect.Outline(), fill, width, null);
return;
}
const p1_dev = this.userToDeviceCoordinates(p1);
const p2_dev = this.userToDeviceCoordinates(p2);
this.emit(
`${formatG(p1_dev.x)} ${formatG(p1_dev.y)}` +
` ${formatG(p2_dev.x - p1_dev.x)} ${formatG(p2_dev.y - p1_dev.y)}` +
` rect${getFillId(fill)}\n`,
);
}
/**
* `PS_PLOTTER::Circle`. PostScript has a real `arc` operator, so a circle is
* three numbers and a macro name — no Bézier approximation, and no thin-circle
* special case either: unlike PDF's, this one never promotes a hairline
* outline to a fill.
*/
Circle(pos: Vec2, diametre: number, fill: FILL_T, width: number): void {
this.SetCurrentLineWidth(width);
if (fill === FILL_T.NO_FILL && this.GetCurrentLineWidth() <= 0) return;
const pos_dev = this.userToDeviceCoordinates(pos);
const radius = this.userToDeviceSize(diametre / 2.0);
this.emit(
`${formatG(pos_dev.x)} ${formatG(pos_dev.y)} ${formatG(radius)} cir${getFillId(fill)}\n`,
);
}
/**
* `PS_PLOTTER::Arc`. The endpoints are computed in user space, pushed through
* the device transform and only *then* turned back into angles, so the paper
* flip is what decides which way round they come out. The correction is the
* XOR `!m_plotMirror ^ ( aAngle < ANGLE_0 )`: an unmirrored plot swaps for a
* positive sweep, a mirrored one for a negative sweep.
*
* Two more details. The pen is set after all of that but before the operator
* is written, so a `setlinewidth` line can appear between an arc's operands
* being computed and the arc itself being emitted; and there is no degenerate
* radius guard at all, so a zero radius plots a zero-radius `arc`.
*/
override Arc(
aCenter: Vec2,
aStartAngle: EDA_ANGLE,
aAngle: EDA_ANGLE,
aRadius: number,
aFill: FILL_T,
aWidth: number,
): void {
const center_device = this.userToDeviceCoordinates(aCenter);
const radius_device = this.userToDeviceSize(aRadius);
const endA = aStartAngle.add(aAngle);
const start = {
x: aRadius * aStartAngle.Cos() + aCenter.x,
y: aRadius * aStartAngle.Sin() + aCenter.y,
};
const end = { x: aRadius * endA.Cos() + aCenter.x, y: aRadius * endA.Sin() + aCenter.y };
const start_device = this.userToDeviceCoordinates(toVector2I(start));
const end_device = this.userToDeviceCoordinates(toVector2I(end));
let startAngle = EDA_ANGLE.fromVector({
x: start_device.x - center_device.x,
y: start_device.y - center_device.y,
});
let endAngle = EDA_ANGLE.fromVector({
x: end_device.x - center_device.x,
y: end_device.y - center_device.y,
});
// userToDeviceCoordinates gets our start/ends out of order
if (!this.m_plotMirror !== aAngle.lt(ANGLE_0)) [startAngle, endAngle] = [endAngle, startAngle];
this.SetCurrentLineWidth(aWidth);
this.emit(
`${formatG(center_device.x)} ${formatG(center_device.y)} ${formatG(radius_device)}` +
` ${formatG(startAngle.AsDegrees())} ${formatG(endAngle.AsDegrees())}` +
` arc${getFillId(aFill)}\n`,
);
}
/**
* `PS_PLOTTER::PlotPoly`. The three guards run in upstream's order — pen
* first, then the unfilled-hairline test, then the point count — which is
* observable: a one-point corner list still emits a `setlinewidth` before it
* gives up.
*
* The path is left open; the `poly1`/`poly2` macros close it themselves, and
* `poly0` is nothing but `stroke`, so an unfilled polygon is deliberately not
* closed at all.
*/
PlotPoly(
aCornerList: readonly Vec2[],
aFill: FILL_T,
aWidth: number = USE_DEFAULT_LINE_WIDTH,
_aData?: unknown,
): void {
this.SetCurrentLineWidth(aWidth);
if (aFill === FILL_T.NO_FILL && this.GetCurrentLineWidth() <= 0) return;
if (aCornerList.length <= 1) return;
let pos = this.userToDeviceCoordinates(aCornerList[0]!);
this.emit(`newpath\n${formatG(pos.x)} ${formatG(pos.y)} moveto\n`);
for (let ii = 1; ii < aCornerList.length; ii++) {
pos = this.userToDeviceCoordinates(aCornerList[ii]!);
this.emit(`${formatG(pos.x)} ${formatG(pos.y)} lineto\n`);
}
// Close/(fill) the path
this.emit(`poly${getFillId(aFill)}\n`);
}
// =========================================================================
// Thick primitives (PLOTTER)
// =========================================================================
// =========================================================================
// Pad flashes (PSLIKE_PLOTTER)
// =========================================================================
// =========================================================================
// Pen
// =========================================================================
/**
* `PS_PLOTTER::PenTo`. 'Z' strokes whatever path is open and parks the pen at
* (-1,-1), which is what makes the *next* plume start a fresh `newpath`.
*
* Note the order: the `newpath` is written as soon as the pen leaves rest,
* before the test that decides whether the plume actually moved — though the
* two never disagree, because a pen at rest is in state 'Z' and so always
* fails the `m_penState != plume` half of that test. What the ordering does
* buy is that a *mid-path* lift, where the state is already 'U' or 'D', gets
* no `newpath` and stays part of the same subpath.
*
* The suppression test compares the *user* position, so a repeated point
* writes nothing even though the device position might differ after a
* viewport change.
*/
PenTo(pos: Vec2, plume: PEN_PLUME): void {
if (plume === 'Z') {
if (this.m_penState !== 'Z') {
this.emit('stroke\n');
this.m_penState = 'Z';
this.m_penLastpos = { x: -1, y: -1 };
}
return;
}
if (this.m_penState === 'Z') this.emit('newpath\n');
if (
this.m_penState !== plume ||
pos.x !== this.m_penLastpos.x ||
pos.y !== this.m_penLastpos.y
) {
const pos_dev = this.userToDeviceCoordinates(pos);
this.emit(
`${formatG(pos_dev.x)} ${formatG(pos_dev.y)} ${plume === 'D' ? 'line' : 'move'}to\n`,
);
}
this.m_penState = plume;
this.m_penLastpos = { x: pos.x, y: pos.y };
}
// =========================================================================
// Images
// =========================================================================
/**
* `PS_PLOTTER::PlotImage`. The image is mapped onto the unit square by
* `translate` and `scale`, and the source matrix `[w 0 0 -h 0 h]` flips it
* back the right way up.
*
* Two upstream faults reach the file. `/pix` is declared as a string of
* *width* bytes, but in colour mode `colorimage` consumes three components
* per pixel, so each `readhexstring` returns a third of a scanline; and `jj`,
* the counter that breaks the hex dump every sixteen pixels, is never reset
* between rows, so the break positions drift across the image rather than
* lining up with it.
*
* The alpha premultiply carries two more. It is done in C `float`, not
* `double` — `float a` and a `float` multiply — which is why `Math.fround`
* appears here twice and why a half-transparent pixel gains 127 and not 128.
* And the sum is masked with `& 0xFF` instead of clamped, so a channel that
* was already near white wraps round to near black; a port that clamped would
* produce a nicer image than KiCad does.
*/
override PlotImage(aImage: PsImage, aPos: Vec2, aScaleFactor: number): void {
// size of the bitmap in pixels
const pix_size = { x: aImage.GetWidth(), y: aImage.GetHeight() };
// requested size of image
const drawsize = { x: aScaleFactor * pix_size.x, y: aScaleFactor * pix_size.y };
// calculate the bottom left corner position of bitmap
const start = {
x: Math.trunc(aPos.x - drawsize.x / 2), // left
y: Math.trunc(aPos.y + drawsize.y / 2), // bottom (Y axis reversed)
};
// calculate the top right corner position of bitmap
const end = {
x: Math.trunc(start.x + drawsize.x),
y: Math.trunc(start.y - drawsize.y),
};
this.emit('/origstate save def\n');
this.emit(`/pix ${pix_size.x} string def\n`);
// Locate lower-left corner of image
const start_dev = this.userToDeviceCoordinates(start);
this.emit(`${formatG(start_dev.x)} ${formatG(start_dev.y)} translate\n`);
// Map image size to device
const end_dev = this.userToDeviceCoordinates(end);
this.emit(
`${formatG(Math.abs(end_dev.x - start_dev.x))}` +
` ${formatG(Math.abs(end_dev.y - start_dev.y))} scale\n`,
);
// Dimensions of source image (in pixels)
this.emit(`${pix_size.x} ${pix_size.y} 8`);
// Map unit square to source
this.emit(` [${pix_size.x} 0 0 ${-pix_size.y} 0 ${pix_size.y}]\n`);
// include image data in ps file
this.emit('{currentfile pix readhexstring pop}\n');
if (this.m_colorMode) this.emit('false 3 colorimage\n');
else this.emit('image\n');
// Single data source, 3 colors, Output RGB data (hexadecimal)
// (or the same downscaled to gray)
let jj = 0;
for (let yy = 0; yy < pix_size.y; yy++) {
for (let xx = 0; xx < pix_size.x; xx++, jj++) {
if (jj >= 16) {
jj = 0;
this.emit('\n');
}
let red = aImage.GetRed(xx, yy) & 0xff;
let green = aImage.GetGreen(xx, yy) & 0xff;
let blue = aImage.GetBlue(xx, yy) & 0xff;
// PS doesn't support alpha, so premultiply against white background
if (aImage.HasAlpha()) {
const alpha = aImage.GetAlpha(xx, yy) & 0xff;
if (alpha < 0xff) {
// The `Math.fround` here mirrors C's `float a` and is provably
// unobservable: `(1 - alpha/255) * 255` is exactly `255 - alpha` in
// reals, and both the double and the float32 roundings of it land
// inside half an ULP of that integer, so the enclosing
// `Math.fround(a * 0xFF)` collapses them to the same value for all
// 255 x 256 (alpha, channel) pairs — checked exhaustively. Kept for
// the transcription, not for behaviour; no test can pin it.
const a = Math.fround(1.0 - alpha / 255.0);
red = Math.trunc(Math.fround(red + Math.fround(a * 0xff))) & 0xff;
green = Math.trunc(Math.fround(green + Math.fround(a * 0xff))) & 0xff;
blue = Math.trunc(Math.fround(blue + Math.fround(a * 0xff))) & 0xff;
}
}
if (aImage.HasMask()) {
if (
red === aImage.GetMaskRed() &&
green === aImage.GetMaskGreen() &&
blue === aImage.GetMaskBlue()
) {
red = 0xff;
green = 0xff;
blue = 0xff;
}
}
if (this.m_colorMode) {
this.emit(`${hex2(red)}${hex2(green)}${hex2(blue)}`);
} else {
// Greyscale conversion (CIE 1931)
const grey = KiROUND(red * 0.2126 + green * 0.7152 + blue * 0.0722) & 0xff;
this.emit(hex2(grey));
}
}
}
this.emit('\n');
this.emit('origstate restore\n');
}
// =========================================================================
// Document structure
// =========================================================================
/**
* `PS_PLOTTER::StartPlot`. The comments follow Adobe's Document Structuring
* Convention, and three of them are worth reading twice.
*
* `%%Pages: 1` is a constant, whatever the caller then plots. The bounding box
* rounds *up* with `ceil` while `%%DocumentMedia` rounds to nearest, so the
* two disagree by a point on most sheets — deliberate, per the comment about
* rounding the corners outwards. And both are computed from a page size that
* has been swapped *back* to portrait for a landscape sheet, because
* PAGE_INFO already stores its size the right way round and the rotation is
* applied later by `N 0 translate 90 rotate`.
*
* The `%%DocumentMedia` size really is written y-before-x; upstream's comment
* says "the order in which they are specified is not wrong!".
*/
StartPlot(aPageNumber: string, aNow: Date = new Date()): boolean {
if (!this.m_outputFile) throw new Error('PostScript plot started before OpenFile');
const pageInfo = this.PageSettings();
this.emit('%!PS-Adobe-3.0\n'); // Print header
this.emit(`%%Creator: ${this.m_creator}\n`);
/* A "newline" character ("\n") is not included in the following string,
because it is provided by the ctime() function. */
this.emit(`%%CreationDate: ${psCreationDate(aNow)}`);
this.emit('%%Title: ');
this.emitLatin1(this.encodeStringForPlotter(this.m_title));
this.emit('\n');
this.emit('%%Pages: 1\n');
this.emit('%%PageOrder: Ascend\n');
/* The coordinates of the lower left corner of the boundary
box need to be "rounded down", but the coordinates of its
upper right corner need to be "rounded up" instead. */
const sizeMils = toVector2I(pageInfo.GetSizeMils());
const psPaperSize = { x: sizeMils.x, y: sizeMils.y };
if (!pageInfo.IsPortrait()) {
psPaperSize.x = Math.trunc(pageInfo.GetHeightMils());
psPaperSize.y = Math.trunc(pageInfo.GetWidthMils());
}
this.emit(
`%%BoundingBox: 0 0 ${Math.trunc(Math.ceil(psPaperSize.x * BIGPTsPERMIL))}` +
` ${Math.trunc(Math.ceil(psPaperSize.y * BIGPTsPERMIL))}\n`,
);
// Specify the size of the sheet and the name associated with that size.
// (If the "User size" option has been selected for the sheet size,
// identify the sheet size as "Custom" (rather than as "User"), but
// otherwise use the name assigned by KiCad for each sheet size.)
let pageType = pageInfo.GetTypeAsString();
if (pageInfo.IsCustom()) pageType = 'Custom';
this.emit(
`%%DocumentMedia: ${pageType} ${KiROUND(psPaperSize.x * BIGPTsPERMIL)}` +
` ${KiROUND(psPaperSize.y * BIGPTsPERMIL)} 0 () ()\n`,
);
if (pageInfo.IsPortrait()) this.emit('%%Orientation: Portrait\n');
else this.emit('%%Orientation: Landscape\n');
this.emit('%%EndComments\n');
// Now specify various other details.
this.emit(PS_MACRO_PROLOG);
// The following strings are output here (rather than within PSMacro[])
// to highlight that it has been provided to ensure that the contents of
// the postscript file comply with the Document Structuring Convention.
this.emit('%%Page: ');
this.emitLatin1(this.encodeStringForPlotter(aPageNumber));
this.emit(' 1\n');
this.emit(
'%%BeginPageSetup\n' +
'gsave\n' +
'0.0072 0.0072 scale\n' + // Configure postscript for decimils coordinates
'linemode1\n',
);
// Rototranslate the coordinate to achieve the landscape layout
if (!pageInfo.IsPortrait()) this.emit(`${10 * psPaperSize.x} 0 translate 90 rotate\n`);
// Apply the user fine scale adjustments
if (this.plotScaleAdjX !== 1.0 || this.plotScaleAdjY !== 1.0)
this.emit(`${formatG(this.plotScaleAdjX)} ${formatG(this.plotScaleAdjY)} scale\n`);
// Set default line width
this.emit(
`${formatG(this.userToDeviceSize(this.renderSettings().GetDefaultPenWidth()))} setlinewidth\n`,
);
this.emit('%%EndPageSetup\n');
return true;
}
/**
* `PS_PLOTTER::EndPlot`. `grestore` unwinds StartPlot's `gsave`, and the file
* is closed — after which nothing may be drawn, which is what the reset of
* m_outputFile enforces here.
*/
EndPlot(): boolean {
if (!this.m_outputFile) throw new Error('PostScript plot ended before OpenFile');
this.emit('showpage\ngrestore\n%%EOF\n');
this.m_outputFile = false;
return true;
}
// =========================================================================
// Text
// =========================================================================
/**
* `PS_PLOTTER::Text`. The PostScript-native path is only the *phantom* one:
* an invisible `phantomshow` string that gives a PDF distiller something to
* search, drawn before the glyphs and only when the mode was set to PHANTOM —
* which PS_PLOTTER's constructor deliberately does not do.
*
* The visible text is then stroked by `PLOTTER::Text`, and note what is passed
* to it: `GetCurrentLineWidth()`, the pen this method has just resolved, not
* the caller's `aWidth`. A caller passing DO_NOT_SET_LINE_WIDTH therefore
* hands the base class whatever the live pen happens to be.
*/
override Text(
aPos: Vec2,
aColor: Color4d,
aText: string,
aOrient: EDA_ANGLE,
aSize: Vec2,
aH_justify: GR_TEXT_H_ALIGN_T,
aV_justify: GR_TEXT_V_ALIGN_T,
aWidth: number,
aItalic: boolean,
aBold: boolean,
aMultilineAllowed: boolean,
aFont: PLOTTER_FONT | null,
aFontMetrics?: unknown,
aData?: unknown,
): void {
this.SetCurrentLineWidth(aWidth);
this.SetColor(aColor);
// Draw the hidden postscript text (if requested)
if (this.m_textMode === PLOT_TEXT_MODE.PHANTOM) {
const pos_dev = this.userToDeviceCoordinates(aPos);
this.emitLatin1(this.encodeStringForPlotter(aText));
this.emit(` ${formatG(pos_dev.x)} ${formatG(pos_dev.y)} phantomshow\n`);
}
super.Text(
aPos,
aColor,
aText,
aOrient,
aSize,
aH_justify,
aV_justify,
this.GetCurrentLineWidth(),
aItalic,
aBold,
aMultilineAllowed,
aFont,
aFontMetrics,
aData,
);
}
/**
* `PS_PLOTTER::PlotText`. Same shape as Text, with one difference that is not
* cosmetic: the base `PLOTTER::PlotText` calls `SetCurrentLineWidth` once, up
* front, and its stroke callback does *not* re-issue it per segment. So a
* font whose polygon callback disturbed the pen would leave the rest of the
* string thin — where the Text path would have repaired it.
*/
override PlotText(
aPos: Vec2,
aColor: Color4d,
aText: string,
aAttributes: PLOTTER_TEXT_ATTRIBUTES,
aFont: PLOTTER_FONT | null,
aFontMetrics?: unknown,
aData?: unknown,
): void {
this.SetCurrentLineWidth(aAttributes.m_StrokeWidth);
this.SetColor(aColor);
// Draw the hidden postscript text (if requested)
if (this.m_textMode === PLOT_TEXT_MODE.PHANTOM) {
const pos_dev = this.userToDeviceCoordinates(aPos);
this.emitLatin1(this.encodeStringForPlotter(aText));
this.emit(` ${formatG(pos_dev.x)} ${formatG(pos_dev.y)} phantomshow\n`);
}
super.PlotText(aPos, aColor, aText, aAttributes, aFont, aFontMetrics, aData);
}
}
/** fmt's `{:02X}`: two upper-case hex digits, zero padded. */
function hex2(aValue: number): string {
return aValue.toString(16).toUpperCase().padStart(2, '0');
}