Files
likang 7e01147566
CI / typecheck + test + build (push) Has been cancelled
Initial commit: import VibeMake PCB Studio
2026-11-03 11:20:08 +08:00

2304 lines
77 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.
/**
* `GERBER_PLOTTER`, the RS-274X / Gerber X2 plot back-end: KiCad's
* `common/plotters/GERBER_plotter.cpp` with its headers
* `include/plotters/plotter_gerber.h`, `gbr_plotter_apertures.h` (`APERTURE`,
* `APER_MACRO_FREEPOLY`, `APER_MACRO_FREEPOLY_LIST`) and
* `gbr_plotter_aperture_macros.h` (the `%AM` macro texts), one unit under the
* `.cpp` name as common/STRUCTURE.md prescribes.
*
* Two deliberate differences from the C++:
*
* 1. **No temp file.** Upstream writes the body to a temporary `workFile`,
* then EndPlot copies it line by line into the real file and splices the
* aperture macros and the `%ADD` list in after the `G04 APERTURE LIST*`
* line. Here the body accumulates in memory and EndPlot runs the same
* line scan over it; `text()` / `bytes()` hand back the result.
* 2. **Our name, not KiCad's**, on the `G04 Created by` comment, for the reason
* `common/generator.ts` gives. The clock StartPlot reads is `SetDate`'s, so
* that the comment and `AddGerberX2Header`'s `TF.CreationDate` agree and a
* test can pin both.
*
* `aData`, a `void*` upstream, is a {@link GBR_METADATA} or nothing.
*/
import { GBR_APERTURE_METADATA, GBR_METADATA, FormatNetAttribute } from '../gbr_metadata.js';
import type { GBR_NETLIST_METADATA } from '../gbr_netlist_metadata.js';
import type { GR_TEXT_H_ALIGN_T, GR_TEXT_V_ALIGN_T } from '../eda_text.js';
import type { Color4d } from '../gal/color4d.js';
import { GENERATOR_APPLICATION } from '../generator.js';
import { GetBuildVersion } from '../build_version.js';
import { ERROR_LOC } from '@ziroeda/kimath/src/convert_basic_shapes_to_polygon.js';
import { ANGLE_0, ANGLE_90, ANGLE_180, EDA_ANGLE } from '@ziroeda/kimath/src/geometry/eda_angle.js';
import { SHAPE_ARC } from '@ziroeda/kimath/src/geometry/shape_arc.js';
import type { SHAPE_LINE_CHAIN } from '@ziroeda/kimath/src/geometry/shape_line_chain.js';
import {
SHAPE_POLY_SET,
TransformRoundChamferedRectToPolygon,
} from '@ziroeda/kimath/src/geometry/shape_poly_set.js';
import { KiROUND } from '@ziroeda/kimath/src/math/util.js';
import type { Vec2 } from '@ziroeda/kimath/src/math/vector2.js';
import { RotatePoint } from '@ziroeda/kimath/src/trigo.js';
import { fixed } from './fmt.js';
import {
DO_NOT_SET_LINE_WIDTH,
FILL_T,
type LINE_STYLE,
PLOT_FORMAT,
PLOTTER,
type PLOTTER_FONT,
type PLOTTER_TEXT_ATTRIBUTES,
type PEN_PLUME,
toVector2I,
USE_DEFAULT_LINE_WIDTH,
} from './plotter.js';
// ---------------------------------------------------------------------------
// gbr_plotter_apertures.h
// ---------------------------------------------------------------------------
/** D_CODE < 10 is a command, D_CODE >= 10 is a tool. */
export const FIRST_DCODE_VALUE = 10;
/** `APERTURE::APERTURE_TYPE`. */
export enum APERTURE_TYPE {
AT_CIRCLE = 1, // round aperture, to flash pads
AT_RECT = 2, // rect aperture, to flash pads
AT_PLOTTING = 3, // round aperture, to plot lines
AT_OVAL = 4, // oval aperture, to flash pads
AT_REGULAR_POLY = 5, // Regular polygon (n vertices, n = 3 .. 12, with rotation)
AT_REGULAR_POLY3, // Regular polygon 3 vertices, with rotation
AT_REGULAR_POLY4, // Regular polygon 4 vertices, with rotation
AT_REGULAR_POLY5, // Regular polygon 5 vertices, with rotation
AT_REGULAR_POLY6, // Regular polygon 6 vertices, with rotation
AT_REGULAR_POLY7, // Regular polygon 7 vertices, with rotation
AT_REGULAR_POLY8, // Regular polygon 8 vertices, with rotation
AT_REGULAR_POLY9, // Regular polygon 9 vertices, with rotation
AT_REGULAR_POLY10, // Regular polygon 10 vertices, with rotation
AT_REGULAR_POLY11, // Regular polygon 11 vertices, with rotation
AT_REGULAR_POLY12, // Regular polygon 12 vertices, with rotation
AM_ROUND_RECT, // Aperture macro for round rect pads
AM_ROT_RECT, // Aperture macro for rotated rect pads
APER_MACRO_OUTLINE4P, // Aperture macro for trapezoid pads (outline with 4 corners)
APER_MACRO_OUTLINE5P, // Aperture macro for pad polygons with 5 corners (chamfered pads)
APER_MACRO_OUTLINE6P, // Aperture macro for pad polygons with 6 corners (chamfered pads)
APER_MACRO_OUTLINE7P, // Aperture macro for pad polygons with 7 corners (chamfered pads)
APER_MACRO_OUTLINE8P, // Aperture macro for pad polygons with 8 corners (chamfered pads)
AM_ROTATED_OVAL, // Aperture macro for rotated oval pads
// (not rotated uses a primitive)
AM_FREE_POLYGON, // Aperture macro to create on the fly a free polygon, with
// only one parameter: rotation
}
/** Class to handle a D_CODE when plotting a board using Standard Aperture Templates. */
export class APERTURE {
static readonly AT_CIRCLE = APERTURE_TYPE.AT_CIRCLE;
static readonly AT_RECT = APERTURE_TYPE.AT_RECT;
static readonly AT_PLOTTING = APERTURE_TYPE.AT_PLOTTING;
static readonly AT_OVAL = APERTURE_TYPE.AT_OVAL;
// Type ( Line, rect , circulaire , ovale poly 3 to 12 vertices, aperture macro )
m_Type: APERTURE_TYPE = APERTURE_TYPE.AT_CIRCLE;
// horiz and Vert size
m_Size: Vec2 = { x: 0, y: 0 };
// list of corners for polygon shape
m_Corners: Vec2[] = [];
// Radius for polygon and round rect shape
m_Radius = 0;
// Rotation in degrees
m_Rotation: EDA_ANGLE = ANGLE_0;
// code number ( >= 10 )
m_DCode = 0;
// the attribute attached to this aperture
// Only one attribute is allowed by aperture
// 0 = no specific aperture attribute
m_ApertureAttribute = 0;
m_CustomAttribute = '';
SetSize(aSize: Vec2): void {
this.m_Size = aSize;
}
GetSize(): Vec2 {
return this.m_Size;
}
SetDiameter(aDiameter: number): void {
this.m_Radius = Math.trunc(aDiameter / 2);
}
GetDiameter(): number {
// For round primitive, the diameter is the m_Size.x ot m_Size.y
if (this.m_Type === APERTURE_TYPE.AT_CIRCLE || this.m_Type === APERTURE_TYPE.AT_PLOTTING)
return this.m_Size.x;
// For rounded shapes (macro apertures), return m_Radius * 2
// but usually they use the radius (m_Radius)
return this.m_Radius * 2;
}
SetRegPolyVerticeCount(aCount: number): void {
let count = aCount;
if (count < 3) count = 3;
else if (count > 12) count = 12;
this.m_Type = APERTURE_TYPE.AT_REGULAR_POLY3 - 3 + count;
}
GetRegPolyVerticeCount(): number {
return this.m_Type - APERTURE_TYPE.AT_REGULAR_POLY3 + 3;
}
SetRotation(aRotation: EDA_ANGLE): void {
this.m_Rotation = aRotation;
}
GetRotation(): EDA_ANGLE {
return this.m_Rotation;
}
}
const vecEq = (a: Vec2, b: Vec2): boolean => a.x === b.x && a.y === b.y;
// A helper function to compare 2 polygons: polygons are similar if they have the same
// number of vertices and each vertex coordinate are similar, i.e. if the difference
// between coordinates is small ( <= margin to accept rounding issues coming from polygon
// geometric transforms like rotation
function polyCompare(aPolygon: readonly Vec2[], aTestPolygon: readonly Vec2[]): boolean {
// fast test: polygon sizes must be the same:
if (aTestPolygon.length !== aPolygon.length) return false;
const margin = 2;
for (let jj = 0; jj < aPolygon.length; jj++) {
if (
Math.abs(aPolygon[jj]!.x - aTestPolygon[jj]!.x) > margin ||
Math.abs(aPolygon[jj]!.y - aTestPolygon[jj]!.y) > margin
)
return false;
}
return true;
}
const AM_FREEPOLY_BASENAME = 'FreePoly';
/** A class to define an aperture macros based on a free polygon, i.e. using a primitive 4. */
export class APER_MACRO_FREEPOLY {
m_Corners: Vec2[];
m_Id: number;
constructor(aPolygon: readonly Vec2[], aId: number) {
this.m_Corners = [...aPolygon];
this.m_Id = aId;
}
/** True if aPolygon is the same as this, i.e. the same as m_Corners. */
IsSamePoly(aPolygon: readonly Vec2[]): boolean {
return polyCompare(this.m_Corners, aPolygon);
}
/**
* Print the aperture macro definition.
*
* @param aIu2GbrMacroUnit is the scaling factor from coordinates value to
* the Gerber file macros units (always mm or inches)
*/
Format(aIu2GbrMacroUnit: number): string {
let out = '';
// Write aperture header
out += `%AM${AM_FREEPOLY_BASENAME}${this.m_Id}*\n`;
out += `4,1,${this.m_Corners.length},`;
// Insert a newline after curr_line_count_max coordinates.
let curr_line_corner_count = 0;
const curr_line_count_max = 20; // <= 0 to disable newlines
for (let ii = 0; ii <= this.m_Corners.length; ii++) {
let jj = ii;
if (ii >= this.m_Corners.length) jj = 0;
// Note: parameter values are always mm or inches
out += `${fixed(this.m_Corners[jj]!.x * aIu2GbrMacroUnit, 6)},${fixed((0 - this.m_Corners[jj]!.y) * aIu2GbrMacroUnit, 6)},`;
if (curr_line_count_max >= 0 && ++curr_line_corner_count >= curr_line_count_max) {
out += '\n';
curr_line_corner_count = 0;
}
}
// output rotation parameter
out += '$1*%\n';
return out;
}
CornersCount(): number {
return this.m_Corners.length;
}
}
export class APER_MACRO_FREEPOLY_LIST {
m_AMList: APER_MACRO_FREEPOLY[] = [];
ClearList(): void {
this.m_AMList = [];
}
AmCount(): number {
return this.m_AMList.length;
}
/** Append a new APER_MACRO_FREEPOLY containing the polygon aPolygon to the current list. */
Append(aPolygon: readonly Vec2[]): void {
this.m_AMList.push(new APER_MACRO_FREEPOLY(aPolygon, this.AmCount()));
}
/** The index in m_AMList of the APER_MACRO_FREEPOLY having the same polygon as aPolygon, or -1. */
FindAm(aPolygon: readonly Vec2[]): number {
for (let idx = 0; idx < this.AmCount(); idx++) {
if (this.m_AMList[idx]!.IsSamePoly(aPolygon)) return idx;
}
return -1;
}
/** Print the aperture macro list. */
Format(aIu2GbrMacroUnit: number): string {
let out = '';
for (let idx = 0; idx < this.AmCount(); idx++)
out += this.m_AMList[idx]!.Format(aIu2GbrMacroUnit);
return out;
}
}
// ---------------------------------------------------------------------------
// gbr_plotter_aperture_macros.h
// ---------------------------------------------------------------------------
// A aperture macro to define a rounded rect pad shape
// In many gerber readers, the rotation of the full shape is broken
// so we are using primitives that does not need a rotation around aperture origin.
// Note also the primitive 1 (circle) can use 4 or 5 parameters
// the 5th parameter is the rotation (not used by Kicad ) around aperture origin and is
// a recent optional parameter and can create compatibility issues with old
// Gerber viewer, so it is not output (default = 0).
export const APER_MACRO_ROUNDRECT_NAME = 'RoundRect';
export const APER_MACRO_ROUNDRECT_HEADER =
'%AMRoundRect*\n' +
'0 Rectangle with rounded corners*\n' +
'0 $1 Rounding radius*\n' +
'0 $2 $3 $4 $5 $6 $7 $8 $9 X,Y pos of 4 corners*\n' +
'0 Add a 4 corners polygon primitive as box body*\n' +
'4,1,4,$2,$3,$4,$5,$6,$7,$8,$9,$2,$3,0*\n' +
'0 Add four circle primitives for the rounded corners*\n' +
'1,1,$1+$1,$2,$3*\n' +
'1,1,$1+$1,$4,$5*\n' +
'1,1,$1+$1,$6,$7*\n' +
'1,1,$1+$1,$8,$9*\n' +
'0 Add four rect primitives between the rounded corners*\n' +
'20,1,$1+$1,$2,$3,$4,$5,0*\n' +
'20,1,$1+$1,$4,$5,$6,$7,0*\n' +
'20,1,$1+$1,$6,$7,$8,$9,0*\n' +
'20,1,$1+$1,$8,$9,$2,$3,0*' +
'%\n';
// A aperture macro to define a rotated rect pad shape
export const APER_MACRO_ROT_RECT_NAME = 'RotRect';
export const APER_MACRO_ROT_RECT_HEADER =
'%AMRotRect*\n' +
'0 Rectangle, with rotation*\n' +
'0 The origin of the aperture is its center*\n' +
'0 $1 length*\n' +
'0 $2 width*\n' +
'0 $3 Rotation angle, in degrees counterclockwise*\n' +
'0 Add horizontal line*\n' +
'21,1,$1,$2,0,0,$3*%\n';
// A aperture macro to define a oval pad shape
// In many gerber readers, the rotation of the full shape is broken
// so we are using a primitive that does not need a rotation to be
// plotted
export const APER_MACRO_SHAPE_OVAL_NAME = 'HorizOval';
export const APER_MACRO_SHAPE_OVAL_HEADER =
'%AMHorizOval*\n' +
'0 Thick line with rounded ends*\n' +
'0 $1 width*\n' +
'0 $2 $3 position (X,Y) of the first rounded end (center of the circle)*\n' +
'0 $4 $5 position (X,Y) of the second rounded end (center of the circle)*\n' +
'0 Add line between two ends*\n' +
'20,1,$1,$2,$3,$4,$5,0*\n' +
'0 Add two circle primitives to create the rounded ends*\n' +
'1,1,$1,$2,$3*\n' +
'1,1,$1,$4,$5*%\n';
// A aperture macro to define a trapezoid (polygon) by 4 corners
// and a rotation angle
export const APER_MACRO_OUTLINE4P_NAME = 'Outline4P';
export const APER_MACRO_OUTLINE4P_HEADER =
'%AMOutline4P*\n' +
'0 Free polygon, 4 corners , with rotation*\n' +
'0 The origin of the aperture is its center*\n' +
'0 number of corners: always 4*\n' +
'0 $1 to $8 corner X, Y*\n' +
'0 $9 Rotation angle, in degrees counterclockwise*\n' +
'0 create outline with 4 corners*\n' +
'4,1,4,$1,$2,$3,$4,$5,$6,$7,$8,$1,$2,$9*%\n';
// A aperture macro to define a polygon by 5 corners
// and a rotation angle (useful for chamfered rect pads)
export const APER_MACRO_OUTLINE5P_NAME = 'Outline5P';
export const APER_MACRO_OUTLINE5P_HEADER =
'%AMOutline5P*\n' +
'0 Free polygon, 5 corners , with rotation*\n' +
'0 The origin of the aperture is its center*\n' +
'0 number of corners: always 5*\n' +
'0 $1 to $10 corner X, Y*\n' +
'0 $11 Rotation angle, in degrees counterclockwise*\n' +
'0 create outline with 5 corners*\n' +
'4,1,5,$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$1,$2,$11*%\n';
// A aperture macro to define a polygon by 6 corners
// and a rotation angle (useful for chamfered rect pads)
export const APER_MACRO_OUTLINE6P_NAME = 'Outline6P';
export const APER_MACRO_OUTLINE6P_HEADER =
'%AMOutline6P*\n' +
'0 Free polygon, 6 corners , with rotation*\n' +
'0 The origin of the aperture is its center*\n' +
'0 number of corners: always 6*\n' +
'0 $1 to $12 corner X, Y*\n' +
'0 $13 Rotation angle, in degrees counterclockwise*\n' +
'0 create outline with 6 corners*\n' +
'4,1,6,$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$1,$2,$13*%\n';
// A aperture macro to define a polygon by 7 corners
// and a rotation angle (useful for chamfered rect pads)
export const APER_MACRO_OUTLINE7P_NAME = 'Outline7P';
export const APER_MACRO_OUTLINE7P_HEADER =
'%AMOutline7P*\n' +
'0 Free polygon, 7 corners , with rotation*\n' +
'0 The origin of the aperture is its center*\n' +
'0 number of corners: always 7*\n' +
'0 $1 to $14 corner X, Y*\n' +
'0 $15 Rotation angle, in degrees counterclockwise*\n' +
'0 create outline with 7 corners*\n' +
'4,1,7,$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$1,$2,$15*%\n';
// A aperture macro to define a polygon by 8 corners
// and a rotation angle (useful for chamfered rect pads)
export const APER_MACRO_OUTLINE8P_NAME = 'Outline8P';
export const APER_MACRO_OUTLINE8P_HEADER =
'%AMOutline8P*\n' +
'0 Free polygon, 8 corners , with rotation*\n' +
'0 The origin of the aperture is its center*\n' +
'0 number of corners: always 8*\n' +
'0 $1 to $16 corner X, Y*\n' +
'0 $17 Rotation angle, in degrees counterclockwise*\n' +
'0 create outline with 8 corners*\n' +
'4,1,8,$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$1,$2,$17*%\n';
// ---------------------------------------------------------------------------
// GERBER_plotter.cpp
// ---------------------------------------------------------------------------
// if GBR_USE_MACROS is defined, pads having a shape that is not a Gerber primitive
// will use a macro when possible
// Old code will be removed only after many tests
//
// Note also: setting m_gerberDisableApertMacros to true disable all aperture macros
// in Gerber files
//
// (GBR_USE_MACROS_FOR_CHAMFERED_ROUND_RECT, _CHAMFERED_RECT, _ROUNDRECT, _TRAPEZOID,
// _ROTATED_OVAL, _ROTATED_RECT and _CUSTOM_PAD are all defined upstream, so every
// `#ifdef` below is taken.)
// max count of corners to create a aperture macro for a custom shape.
// provided just in case a aperture macro type free polygon creates issues
// when the number of corners is too high.
// (1 corner = up to 24 chars)
// Gerber doc say max corners 5000. We use a slightly smaller value.
// if a custom shape needs more than GBR_MACRO_FOR_CUSTOM_PAD_MAX_CORNER_COUNT, it
// will be plot using a region.
const GBR_MACRO_FOR_CUSTOM_PAD_MAX_CORNER_COUNT = 4990;
const TEXT_ENCODER = new TextEncoder();
const pad2 = (n: number): string => String(n).padStart(2, '0');
/** `wxDateTime::FormatISOCombined( ' ' )`: local time, "YYYY-MM-DD HH:MM:SS". */
function formatISOCombined(aDate: Date): string {
return (
`${String(aDate.getFullYear()).padStart(4, '0')}-${pad2(aDate.getMonth() + 1)}-` +
`${pad2(aDate.getDate())} ${pad2(aDate.getHours())}:${pad2(aDate.getMinutes())}:` +
`${pad2(aDate.getSeconds())}`
);
}
/** `aData` of every call below: a `GBR_METADATA*` or nothing. */
const asMetadata = (aData: unknown): GBR_METADATA | null =>
aData instanceof GBR_METADATA ? aData : null;
export class GERBER_PLOTTER extends PLOTTER {
// the attributes dictionary created/modified by %TO, attached to objects, when they are created
// by D01, D03, G36/G37 commands
// standard attributes are .P, .C and .N
// this is used by gerber readers when creating a new object. Cleared by %TD command
// Note: m_objectAttributesDictionary can store more than one attribute
// the string stores the line(s) actually written to the gerber file
// it can store a .P, .C or .N attribute, or 2 or 3 attributes, separated by a \n char (EOL)
protected m_objectAttributesDictionary = '';
// The last aperture attribute generated (only one aperture attribute can be set)
protected m_apertureAttribute = 0;
/** Upstream's `workFile`: the body, before EndPlot splices the aperture list in. */
private m_work: string[] = [];
/** Upstream's `finalFile`: the finished document. */
private m_final = '';
/** `wxDateTime::Now()` for the `G04 Created by` line; see the file comment. */
private m_date: Date | null = null;
protected m_apertures: APERTURE[] = []; // The list of available apertures
protected m_currentApertureIdx = -1; // The index of the current aperture in m_apertures
protected m_hasApertureRoundRect = false; // true is at least one round rect aperture is in use
protected m_hasApertureRotOval = false; // true is at least one oval rotated aperture is in use
protected m_hasApertureRotRect = false; // true is at least one rect. rotated aperture is in use
protected m_hasApertureOutline4P = false; // true is at least one 4 corners outline (free polygon
// with 4 corners) aperture is in use
protected m_hasApertureChamferedRect = false; // true is at least one chamfered rect is in use
// (with no rounded corner)
// number of digits after the point (number of digits of the mantissa
// Be careful: the Gerber coordinates are stored in an integer
// so 6 digits (inches) or 5 digits (mm) is a good value
// To avoid overflow, 7 digits (inches) or 6 digits is a max.
// with lower values than 6 digits (inches) or 5 digits (mm),
// Creating self-intersecting polygons from non-intersecting polygons
// happen easily.
protected m_gerberUnitInch = false; // true if the gerber units are inches, false for mm
protected m_gerberUnitFmt = 6; // number of digits in mantissa.
// usually 6 in Inches and 5 or 6 in mm
protected m_gerberDisableApertMacros = false; // True to disable Aperture Macro (AM) command,
// for broken Gerber Readers
// Regions will be used instead of AM shapes
protected m_useX2format = true; // Add X2 file header attributes. If false, attributes
// will be added as comments.
protected m_useNetAttributes = true; // In recent gerber files, netlist info can be added.
// It will be added if this param is true, using X2 or
// X1 format
// A list of aperture macros defined "on the fly" because the number of parameters is not
// defined: this is the case of the macro using the primitive 4 to create a polygon.
// The number of vertices is not known for free polygonal shapes, and an aperture macro
// must be created for each specific polygon
protected m_am_freepoly_list = new APER_MACRO_FREEPOLY_LIST();
GetPlotterType(): PLOT_FORMAT {
return PLOT_FORMAT.GERBER;
}
static GetDefaultFileExtension(): string {
return 'gbr';
}
/** The clock StartPlot reads (upstream: `wxDateTime::Now()`). */
SetDate(aDate: Date): void {
this.m_date = aDate;
}
/** The plotted file, once EndPlot has run. */
text(): string {
return this.m_final;
}
bytes(): Uint8Array {
return TEXT_ENCODER.encode(this.m_final);
}
/** `fmt::print( m_outputFile, … )`. */
private print(aText: string): void {
this.m_work.push(aText);
}
/** `fmt::println( m_outputFile, … )`. */
private println(aText: string): void {
this.m_work.push(`${aText}\n`);
}
// RS274X has no dashing, nor colors
SetDash(_aLineWidth: number, _aLineStyle: LINE_STYLE): void {}
SetColor(_aColor: Color4d): void {}
// Currently, aScale and aMirror are not used in gerber plotter
SetViewport(aOffset: Vec2, aIusPerDecimil: number, _aScale: number, _aMirror: boolean): void {
// wxASSERT( aMirror == false );
this.m_plotMirror = false;
this.m_plotOffset = aOffset;
// wxASSERT( aScale == 1 ); // aScale parameter is not used in Gerber
this.m_plotScale = 1; // Plot scale is *always* 1.0
this.m_IUsPerDecimil = aIusPerDecimil;
// gives now a default value to iuPerDeviceUnit (because the units of the caller is now known)
// which could be modified later by calling SetGerberCoordinatesFormat()
this.m_iuPerDeviceUnit = 10.0 ** this.m_gerberUnitFmt / (this.m_IUsPerDecimil * 10000.0);
// We don't handle the filmbox, and it's more useful to keep the
// origin at the origin
this.m_paperSize = { x: 0, y: 0 };
}
/**
* Selection of Gerber units and resolution (number of digits in mantissa).
*
* Should be called only after SetViewport() is called.
*/
override SetGerberCoordinatesFormat(aResolution: number, aUseInches = false): void {
this.m_gerberUnitInch = aUseInches;
this.m_gerberUnitFmt = aResolution;
this.m_iuPerDeviceUnit = 10.0 ** this.m_gerberUnitFmt / (this.m_IUsPerDecimil * 10000.0);
if (!this.m_gerberUnitInch) this.m_iuPerDeviceUnit *= 25.4; // gerber output in mm
}
UseX2format(aEnable: boolean): void {
this.m_useX2format = aEnable;
}
UseX2NetAttributes(aEnable: boolean): void {
this.m_useNetAttributes = aEnable;
}
/**
* Disable Aperture Macro (AM) command, only for broken Gerber Readers.
*
* Regions will be used instead of AM shapes to draw complex shapes.
*/
DisableApertMacros(aDisable: boolean): void {
this.m_gerberDisableApertMacros = aDisable;
}
/**
* Emit a D-Code record, using proper conversions to format a leading zero omitted gerber
* coordinate.
*/
protected emitDcode(pt: Vec2, dcode: number): void {
this.println(`X${KiROUND(pt.x)}Y${KiROUND(pt.y)}D${pad2(dcode)}*`);
}
/**
* Remove (clear) all attributes from object attributes dictionary (TO. and TA commands)
* similar to clearNetAttribute(), this is an unconditional reset of TO. and TA. attributes.
*/
ClearAllAttributes(): void {
// Remove all attributes from object attributes dictionary (TO. and TA commands)
if (this.m_useX2format) this.println('%TD*%');
else this.println('G04 #@! TD*');
this.m_objectAttributesDictionary = '';
}
/**
* Clear a Gerber net attribute record (clear object attribute dictionary)
* and output the clear object attribute dictionary command to gerber file
* has effect only if a net attribute is stored in m_objectAttributesDictionary.
*/
protected clearNetAttribute(): void {
// disable a Gerber net attribute (exists only in X2 with net attributes mode).
if (this.m_objectAttributesDictionary === '')
// No net attribute or not X2 mode
return;
// Remove all net attributes from object attributes dictionary
if (this.m_useX2format) this.println('%TD*%');
else this.println('G04 #@! TD*');
this.m_objectAttributesDictionary = '';
}
/**
* Define the beginning of a group of drawing items (used in X2 format with netlist
* attributes).
*/
override StartBlock(aData?: unknown): void {
// Currently, it is the same as EndBlock(): clear all aperture net attributes
this.EndBlock(aData);
}
/** Define the end of a group of drawing items the group is started by StartBlock(). */
override EndBlock(_aData?: unknown): void {
// Remove all net attributes from object attributes dictionary
this.clearNetAttribute();
}
/**
* Print a Gerber net attribute object record.
*
* In a gerber file, a net attribute is owned by a graphic object formatNetAttribute must
* be called before creating the object. The generated string depends on the type of
* netlist info.
*/
protected formatNetAttribute(aData: GBR_NETLIST_METADATA | null): void {
// print a Gerber net attribute record.
// it is added to the object attributes dictionary
// On file, only modified or new attributes are printed.
if (aData === null) return;
if (!this.m_useNetAttributes) return;
const useX1StructuredComment = !this.m_useX2format;
const clearDict = { value: false };
const short_attribute_string = { value: '' };
const dictionary = { value: this.m_objectAttributesDictionary };
const formatted = FormatNetAttribute(
short_attribute_string,
dictionary,
aData,
clearDict,
useX1StructuredComment,
);
this.m_objectAttributesDictionary = dictionary.value;
if (!formatted) return;
// FormatNetAttribute has already stored the new dictionary (upstream passes
// m_objectAttributesDictionary by reference), so this prints `%TD*%` and
// then empties the dictionary it just filled - as upstream does.
if (clearDict.value) this.clearNetAttribute();
if (short_attribute_string.value !== '') this.print(short_attribute_string.value);
if (this.m_useX2format && aData.m_ExtraData !== '') this.print(aData.m_ExtraData);
}
StartPlot(_aPageNumber: string): boolean {
this.m_hasApertureRoundRect = false; // true is at least one round rect aperture is in use
this.m_hasApertureRotOval = false; // true is at least one oval rotated aperture is in use
this.m_hasApertureRotRect = false; // true is at least one rect. rotated aperture is in use
this.m_hasApertureOutline4P = false; // true is at least one rotated rect/trapezoid aperture
// is in use
this.m_hasApertureChamferedRect = false; // true is at least one chamfered rect is in use
this.m_am_freepoly_list.ClearList();
// wxASSERT( m_outputFile );
if (!this.m_outputFile) return false;
// The actual gerber file will be created later: the body goes to the work buffer.
this.m_work = [];
this.m_final = '';
for (const line of this.m_headerExtraLines) {
if (line !== '') this.println(line);
}
// Set coordinate format to 3.6 or 4.5 absolute, leading zero omitted
// the number of digits for the integer part of coordinates is needed
// in gerber format, but is not very important when omitting leading zeros
// It is fixed here to 3 (inch) or 4 (mm), but is not actually used
const leadingDigitCount = this.m_gerberUnitInch ? 3 : 4;
this.println(
`%FSLAX${leadingDigitCount}${this.m_gerberUnitFmt}Y${leadingDigitCount}${this.m_gerberUnitFmt}*%`,
);
this.println(
`G04 Gerber Fmt ${leadingDigitCount}.${this.m_gerberUnitFmt}, Leading zero omitted, Abs format (unit ${this.m_gerberUnitInch ? 'inch' : 'mm'})*`,
);
const Title = `${this.m_creator} ${GetBuildVersion()}`;
// In gerber files, ASCII7 chars only are allowed.
// So use a ISO date format (using a space as separator between date and time),
// not a localized date format
const date = this.m_date ?? new Date();
this.println(
`G04 Created by ${GENERATOR_APPLICATION} (${Title}) date ${formatISOCombined(date)}*`,
);
/* Mass parameter: unit = IN/MM */
if (this.m_gerberUnitInch) this.println('%MOIN*%');
else this.println('%MOMM*%');
// Be sure the usual dark polarity is selected:
this.println('%LPD*%');
// Set initial interpolation mode: always G01 (linear):
this.println('G01*');
// Add aperture list start point
this.println('G04 APERTURE LIST*');
// Give a minimal value to the default pen size, used to plot items in sketch mode
if (this.m_renderSettings) {
const pen_min = Math.trunc((0.1 * this.m_IUsPerDecimil * 10000) / 25.4); // for min width = 0.1 mm
this.m_renderSettings.SetDefaultPenWidth?.(
Math.max(this.m_renderSettings.GetDefaultPenWidth(), pen_min),
);
}
return true;
}
EndPlot(): boolean {
// wxASSERT( m_outputFile );
/* Outfile is actually a temporary file i.e. workFile */
this.println('M02*');
const work = this.m_work.join('');
this.m_work = [];
let out = '';
// Placement of apertures in RS274X. fgets() reads line by line, each line
// keeping its '\n'.
for (const line of work.match(/[^\n]*\n|[^\n]+$/g) ?? []) {
out += line;
// strtok( line, "\n\r" ): the first token, i.e. the line up to its first
// CR or LF, skipping any leading ones.
const substr = /[^\r\n]+/.exec(line)?.[0];
if (substr === 'G04 APERTURE LIST*') {
// Add aperture list macro:
if (
this.m_hasApertureRoundRect ||
this.m_hasApertureRotOval ||
this.m_hasApertureOutline4P ||
this.m_hasApertureRotRect ||
this.m_hasApertureChamferedRect ||
this.m_am_freepoly_list.AmCount()
) {
out += 'G04 Aperture macros list*\n';
if (this.m_hasApertureRoundRect) out += APER_MACRO_ROUNDRECT_HEADER;
if (this.m_hasApertureRotOval) out += APER_MACRO_SHAPE_OVAL_HEADER;
if (this.m_hasApertureRotRect) out += APER_MACRO_ROT_RECT_HEADER;
if (this.m_hasApertureOutline4P) out += APER_MACRO_OUTLINE4P_HEADER;
if (this.m_hasApertureChamferedRect) {
out += APER_MACRO_OUTLINE5P_HEADER;
out += APER_MACRO_OUTLINE6P_HEADER;
out += APER_MACRO_OUTLINE7P_HEADER;
out += APER_MACRO_OUTLINE8P_HEADER;
}
if (this.m_am_freepoly_list.AmCount()) {
// aperture sizes are in inch or mm, regardless the
// coordinates format
let fscale = (0.0001 * this.m_plotScale) / this.m_IUsPerDecimil; // inches
if (!this.m_gerberUnitInch) fscale *= 25.4; // size in mm
out += this.m_am_freepoly_list.Format(fscale);
}
out += 'G04 Aperture macros list end*\n';
}
out += this.writeApertureList();
out += 'G04 APERTURE END LIST*\n';
}
}
this.m_final = out;
this.m_outputFile = false;
return true;
}
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();
// wxASSERT_MSG( aWidth >= 0, "Plotter called to set negative pen width" );
const gbr_metadata = asMetadata(aData);
let aperture_attribute = 0;
let custom_attribute = '';
if (gbr_metadata) {
aperture_attribute = gbr_metadata.GetApertureAttrib();
custom_attribute = gbr_metadata.GetCustomAttribute();
}
this.selectAperture(
{ x: width, y: width },
0,
ANGLE_0,
APERTURE_TYPE.AT_PLOTTING,
aperture_attribute,
custom_attribute,
);
this.m_currentPenWidth = width;
}
/**
* @return an index to the aperture in aperture list which meets the size and type of tool
* if the aperture does not exist, it is created and entered in aperture list.
*/
GetOrCreateAperture(
aSize: Vec2,
aRadius: number,
aRotation: EDA_ANGLE,
aType: APERTURE_TYPE,
aApertureAttribute: number,
aCustomAttribute: string,
): number {
let last_D_code = 9;
// Search an existing aperture
for (let idx = 0; idx < this.m_apertures.length; ++idx) {
const tool = this.m_apertures[idx]!;
last_D_code = tool.m_DCode;
if (
tool.m_Type === aType &&
vecEq(tool.m_Size, aSize) &&
tool.m_Radius === aRadius &&
tool.m_Rotation.equals(aRotation) &&
tool.m_ApertureAttribute === aApertureAttribute &&
tool.m_CustomAttribute === aCustomAttribute
) {
return idx;
}
}
// Allocate a new aperture
const new_tool = new APERTURE();
new_tool.m_Size = { x: aSize.x, y: aSize.y };
new_tool.m_Type = aType;
new_tool.m_Radius = aRadius;
new_tool.m_Rotation = aRotation;
new_tool.m_DCode = last_D_code + 1;
new_tool.m_ApertureAttribute = aApertureAttribute;
new_tool.m_CustomAttribute = aCustomAttribute;
this.m_apertures.push(new_tool);
return this.m_apertures.length - 1;
}
/**
* The polygon overload: an index to the aperture in aperture list which meets the data and
* type of tool; if the aperture does not exist, it is created and entered in aperture list.
*/
GetOrCreateApertureCorners(
aCorners: readonly Vec2[],
aRotation: EDA_ANGLE,
aType: APERTURE_TYPE,
aApertureAttribute: number,
aCustomAttribute: string,
): number {
let last_D_code = 9;
// For APERTURE::AM_FREE_POLYGON aperture macros, we need to create the macro
// on the fly, because due to the fact the vertex count is not a constant we
// cannot create a static definition.
if (APERTURE_TYPE.AM_FREE_POLYGON === aType) {
const idx = this.m_am_freepoly_list.FindAm(aCorners);
if (idx < 0) this.m_am_freepoly_list.Append(aCorners);
}
// Search an existing aperture
for (let idx = 0; idx < this.m_apertures.length; ++idx) {
const tool = this.m_apertures[idx]!;
last_D_code = tool.m_DCode;
if (
tool.m_Type === aType &&
tool.m_Corners.length === aCorners.length &&
tool.m_Rotation.equals(aRotation) &&
tool.m_ApertureAttribute === aApertureAttribute &&
tool.m_CustomAttribute === aCustomAttribute
) {
// A candidate is found. the corner lists must be similar
const is_same = polyCompare(tool.m_Corners, aCorners);
if (is_same) return idx;
}
}
// Allocate a new aperture
const new_tool = new APERTURE();
new_tool.m_Corners = aCorners.map((c) => ({ x: c.x, y: c.y }));
new_tool.m_Size = { x: 0, y: 0 }; // Not used
new_tool.m_Type = aType;
new_tool.m_Radius = 0; // Not used
new_tool.m_Rotation = aRotation;
new_tool.m_DCode = last_D_code + 1;
new_tool.m_ApertureAttribute = aApertureAttribute;
new_tool.m_CustomAttribute = aCustomAttribute;
this.m_apertures.push(new_tool);
return this.m_apertures.length - 1;
}
/**
* Pick an existing aperture or create a new one, matching the size, type and attributes.
*
* Write the DCode selection on gerber file.
*/
protected selectAperture(
aSize: Vec2,
aRadius: number,
aRotation: EDA_ANGLE,
aType: APERTURE_TYPE,
aApertureAttribute: number,
aCustomAttribute: string,
): void {
const current = this.m_apertures[this.m_currentApertureIdx];
let change =
this.m_currentApertureIdx < 0 ||
current!.m_Type !== aType ||
!vecEq(current!.m_Size, aSize) ||
current!.m_Radius !== aRadius ||
!current!.m_Rotation.equals(aRotation);
if (!change) {
change =
current!.m_ApertureAttribute !== aApertureAttribute ||
current!.m_CustomAttribute !== aCustomAttribute;
}
if (change) {
// Pick an existing aperture or create a new one
this.m_currentApertureIdx = this.GetOrCreateAperture(
aSize,
aRadius,
aRotation,
aType,
aApertureAttribute,
aCustomAttribute,
);
this.println(`D${this.m_apertures[this.m_currentApertureIdx]!.m_DCode}*`);
}
}
/**
* Pick an existing aperture or create a new one, matching the corners, rotation,
* type and attributes (the polygon overload).
*
* Write the DCode selection on gerber file.
*/
protected selectApertureCorners(
aCorners: readonly Vec2[],
aRotation: EDA_ANGLE,
aType: APERTURE_TYPE,
aApertureAttribute: number,
aCustomAttribute: string,
): void {
const current = this.m_apertures[this.m_currentApertureIdx];
let change =
this.m_currentApertureIdx < 0 ||
current!.m_Type !== aType ||
current!.m_Corners.length !== aCorners.length ||
!current!.m_Rotation.equals(aRotation);
if (!change) {
// Compare corner lists
for (let ii = 0; ii < aCorners.length; ii++) {
if (!vecEq(aCorners[ii]!, current!.m_Corners[ii]!)) {
change = true;
break;
}
}
}
if (!change) {
change =
current!.m_ApertureAttribute !== aApertureAttribute ||
current!.m_CustomAttribute !== aCustomAttribute;
}
if (change) {
// Pick an existing aperture or create a new one
this.m_currentApertureIdx = this.GetOrCreateApertureCorners(
aCorners,
aRotation,
aType,
aApertureAttribute,
aCustomAttribute,
);
this.println(`D${this.m_apertures[this.m_currentApertureIdx]!.m_DCode}*`);
}
}
/** Pick an aperture or create a new one and emits the DCode. */
protected selectApertureWithAttributes(
aPos: Vec2,
aGbrMetadata: GBR_METADATA | null,
aSize: Vec2,
aRadius: number,
aAngle: EDA_ANGLE,
aType: APERTURE_TYPE,
): void {
const pos_dev = this.userToDeviceCoordinates(aPos);
let aperture_attribute = 0;
let custom_attribute = '';
if (aGbrMetadata) {
aperture_attribute = aGbrMetadata.GetApertureAttrib();
custom_attribute = aGbrMetadata.GetCustomAttribute();
}
this.selectAperture(aSize, aRadius, aAngle, aType, aperture_attribute, custom_attribute);
if (aGbrMetadata) this.formatNetAttribute(aGbrMetadata.m_NetlistMetadata);
this.emitDcode(pos_dev, 3);
}
/** Generate the table of D codes. */
protected writeApertureList(): string {
let out = '';
let useX1StructuredComment = false;
if (!this.m_useX2format) useX1StructuredComment = true;
// Init
for (const tool of this.m_apertures) {
// aperture sizes are in inch or mm, regardless the
// coordinates format
let fscale = (0.0001 * this.m_plotScale) / this.m_IUsPerDecimil; // inches
if (!this.m_gerberUnitInch) fscale *= 25.4; // size in mm
const attribute = tool.m_ApertureAttribute;
if (attribute !== this.m_apertureAttribute) {
out += GBR_APERTURE_METADATA.FormatAttribute(
attribute,
useX1StructuredComment,
tool.m_CustomAttribute,
);
}
out += `%ADD${tool.m_DCode}`;
/* Please note: the Gerber specs for mass parameters say that
exponential syntax is *not* allowed and the decimal point should
also be always inserted. So the %g format is ruled out, but %f is fine
(the # modifier forces the decimal point). Sadly the %f formatter
can't remove trailing zeros but that's not a problem, since nothing
forbid it (the file is only slightly longer) */
const f = (v: number): string => fixed(v, 6);
switch (tool.m_Type) {
case APERTURE_TYPE.AT_CIRCLE:
out += `C,${f(tool.GetDiameter() * fscale)}*%\n`;
break;
case APERTURE_TYPE.AT_RECT:
out += `R,${f(tool.m_Size.x * fscale)}X${f(tool.m_Size.y * fscale)}*%\n`;
break;
case APERTURE_TYPE.AT_PLOTTING:
out += `C,${f(tool.m_Size.x * fscale)}*%\n`;
break;
case APERTURE_TYPE.AT_OVAL:
out += `O,${f(tool.m_Size.x * fscale)}X${f(tool.m_Size.y * fscale)}*%\n`;
break;
case APERTURE_TYPE.AT_REGULAR_POLY:
case APERTURE_TYPE.AT_REGULAR_POLY3:
case APERTURE_TYPE.AT_REGULAR_POLY4:
case APERTURE_TYPE.AT_REGULAR_POLY5:
case APERTURE_TYPE.AT_REGULAR_POLY6:
case APERTURE_TYPE.AT_REGULAR_POLY7:
case APERTURE_TYPE.AT_REGULAR_POLY8:
case APERTURE_TYPE.AT_REGULAR_POLY9:
case APERTURE_TYPE.AT_REGULAR_POLY10:
case APERTURE_TYPE.AT_REGULAR_POLY11:
case APERTURE_TYPE.AT_REGULAR_POLY12:
out += `P,${f(tool.GetDiameter() * fscale)}X${tool.GetRegPolyVerticeCount()}X${f(tool.GetRotation().AsDegrees())}*%\n`;
break;
case APERTURE_TYPE.AM_ROUND_RECT: {
// Aperture macro for round rect pads
// The aperture macro needs coordinates of the centers of the 4 corners
const half_size = {
x: Math.trunc(tool.m_Size.x / 2) - tool.m_Radius,
y: Math.trunc(tool.m_Size.y / 2) - tool.m_Radius,
};
// Ensure half_size.x and half_size.y > minimal value to avoid shapes
// with null size (especially the rectangle with coordinates corners)
// Because the minimal value for a non nul Gerber coord in 10nm
// in format 4.5, use 10 nm as minimal value.
// (Even in 4.6 format, use 10 nm, because gerber viewers can have
// a internal unit bigger than 1 nm)
const min_size_value = 10;
half_size.x = Math.max(half_size.x, min_size_value);
half_size.y = Math.max(half_size.y, min_size_value);
// Rotate the corner coordinates:
const corners: Vec2[] = [
{ x: -half_size.x, y: -half_size.y },
{ x: half_size.x, y: -half_size.y },
{ x: half_size.x, y: half_size.y },
{ x: -half_size.x, y: half_size.y },
].map((c) => RotatePoint(c, tool.m_Rotation.negate()));
out += `${APER_MACRO_ROUNDRECT_NAME},${f(tool.m_Radius * fscale)}X`;
// Add each corner
for (let ii = 0; ii < 4; ii++)
out += `${f(corners[ii]!.x * fscale)}X${f(corners[ii]!.y * fscale)}X`;
out += '0*%\n';
break;
}
case APERTURE_TYPE.AM_ROT_RECT: // Aperture macro for rotated rect pads
out += `${APER_MACRO_ROT_RECT_NAME},${f(tool.m_Size.x * fscale)}X${f(tool.m_Size.y * fscale)}X${f(tool.m_Rotation.AsDegrees())}*%\n`;
break;
case APERTURE_TYPE.APER_MACRO_OUTLINE4P: // Aperture macro for trapezoid pads
case APERTURE_TYPE.APER_MACRO_OUTLINE5P: // Aperture macro for chamfered rect pads
case APERTURE_TYPE.APER_MACRO_OUTLINE6P: // Aperture macro for chamfered rect pads
case APERTURE_TYPE.APER_MACRO_OUTLINE7P: // Aperture macro for chamfered rect pads
case APERTURE_TYPE.APER_MACRO_OUTLINE8P: // Aperture macro for chamfered rect pads
switch (tool.m_Type) {
case APERTURE_TYPE.APER_MACRO_OUTLINE4P:
out += APER_MACRO_OUTLINE4P_NAME;
break;
case APERTURE_TYPE.APER_MACRO_OUTLINE5P:
out += APER_MACRO_OUTLINE5P_NAME;
break;
case APERTURE_TYPE.APER_MACRO_OUTLINE6P:
out += APER_MACRO_OUTLINE6P_NAME;
break;
case APERTURE_TYPE.APER_MACRO_OUTLINE7P:
out += APER_MACRO_OUTLINE7P_NAME;
break;
case APERTURE_TYPE.APER_MACRO_OUTLINE8P:
out += APER_MACRO_OUTLINE8P_NAME;
break;
default:
break;
}
// Add separator after aperture macro name
out += ',';
// Output all corners (should be 4 to 8 corners)
// Remember: the Y coordinate must be negated, due to the fact in Pcbnew
// the Y axis is from top to bottom
// (`-corner.y` negates an int, so a zero stays a positive zero.)
for (const corner of tool.m_Corners)
out += `${f(corner.x * fscale)}X${f((0 - corner.y) * fscale)}X`;
// close outline and output rotation
out += `${f(tool.m_Rotation.AsDegrees())}*%\n`;
break;
case APERTURE_TYPE.AM_ROTATED_OVAL: {
// Aperture macro for rotated oval pads
// (not rotated is a primitive)
// m_Size.x = full length; m_Size.y = width, and the macro aperture expects
// the position of ends
// the seg_len is the distance between the 2 circle centers
const seg_len = tool.m_Size.x - tool.m_Size.y;
// Center of the circle on the segment start point:
const start = RotatePoint({ x: Math.trunc(seg_len / 2), y: 0 }, tool.m_Rotation);
// Center of the circle on the segment end point:
const end = RotatePoint({ x: -Math.trunc(seg_len / 2), y: 0 }, tool.m_Rotation);
out +=
`${APER_MACRO_SHAPE_OVAL_NAME},${f(tool.m_Size.y * fscale)}X` + // width
`${f(start.x * fscale)}X${f((0 - start.y) * fscale)}X` + // X,Y corner start pos
`${f(end.x * fscale)}X${f((0 - end.y) * fscale)}X0*%\n`; // X,Y corner end pos
break;
}
case APERTURE_TYPE.AM_FREE_POLYGON: {
// Find the aperture macro name in the list of aperture macro
// created on the fly for this polygon:
const idx = this.m_am_freepoly_list.FindAm(tool.m_Corners);
// Write DCODE id ( "%ADDxx" is already in buffer) and rotation
// the full line is something like :%ADD12FreePoly1,45.000000*%
out += `${AM_FREEPOLY_BASENAME}${idx},${f(tool.m_Rotation.AsDegrees())}*%\n`;
break;
}
}
this.m_apertureAttribute = attribute;
// Currently reset the aperture attribute. Perhaps a better optimization
// is to store the last attribute
if (attribute) {
if (this.m_useX2format) out += '%TD*%\n';
else out += 'G04 #@! TD*\n';
this.m_apertureAttribute = 0;
}
}
return out;
}
PenTo(aPos: Vec2, plume: PEN_PLUME): void {
// wxASSERT( m_outputFile );
const pos_dev = this.userToDeviceCoordinates(aPos);
switch (plume) {
case 'Z':
break;
case 'U':
this.emitDcode(pos_dev, 2);
break;
case 'D':
this.emitDcode(pos_dev, 1);
}
this.m_penState = plume;
}
// Note: do not use Rect() to plot rounded-corner rectangles. Use PlotPolyAsRegion() instead.
Rect(p1: Vec2, p2: Vec2, fill: FILL_T, width: number, _aCornerRadius = 0): void {
// aCornerRadius > 0: wxFAIL_MSG( "GERBER_PLOTTER must use PlotPolyAsRegion() for
// rounded-corner rectangles!" ), and the square corners are plotted regardless.
const cornerList: Vec2[] = [];
// Build corners list
cornerList.push(p1);
cornerList.push({ x: p1.x, y: p2.y });
cornerList.push(p2);
cornerList.push({ x: p2.x, y: p1.y });
cornerList.push(p1);
this.PlotPoly(cornerList, fill, width, null);
}
Circle(aCenter: Vec2, aDiameter: number, aFill: FILL_T, aWidth: number): void {
const radius = Math.trunc(aDiameter / 2);
this.Arc(aCenter, ANGLE_0, ANGLE_180, radius, aFill, aWidth);
this.Arc(aCenter, ANGLE_180, ANGLE_180, radius, aFill, aWidth);
}
override Arc(
aCenter: Vec2,
aStartAngle: EDA_ANGLE,
aAngle: EDA_ANGLE,
aRadius: number,
aFill: FILL_T,
aWidth: number,
): void {
this.SetCurrentLineWidth(aWidth);
const arcLength = Math.abs(aRadius * aAngle.AsRadians());
if (arcLength < 100 || Math.abs(aAngle.AsDegrees()) < 0.1) {
// Prevent plotting very short arcs as full circles, especially with 4.5 mm precision.
// Also reduce the risk of integer overflow issues.
this.polyArc(aCenter, aStartAngle, aAngle, aRadius, aFill, this.GetCurrentLineWidth());
} else {
const endAngle = aStartAngle.add(aAngle);
// aFill is not used here.
this.plotArc(toVector2I(aCenter), aStartAngle, endAngle, aRadius, false);
}
}
/**
* Plot a Gerber arc (the SHAPE_ARC overload).
*
* If aPlotInRegion = true, the current pen position will not be initialized to the arc
* start position, and therefore the arc can be used to define a region outline item
* a line will be created from current position to arc start point. If aPlotInRegion
* = false, the current pen position will be initialized to the arc start position, to
* plot an usual arc item. The line thickness is not initialized in plotArc, and must
* be initialized before calling it if needed.
*/
protected plotArcShape(aArc: SHAPE_ARC, aPlotInRegion: boolean): void {
const start = aArc.GetP0();
const end = aArc.GetP1();
const center = aArc.GetCenter();
if (!aPlotInRegion) this.MoveTo(start);
else this.LineTo(start);
const devEnd = this.userToDeviceCoordinates(end);
// devRelCenter is the position on arc center relative to the arc start, in Gerber coord.
// Warning: it is **not** userToDeviceCoordinates( center - start ) when the plotter
// has an offset.
const devCenter = this.userToDeviceCoordinates(center);
const devStart = this.userToDeviceCoordinates(start);
const devRelCenter = { x: devCenter.x - devStart.x, y: devCenter.y - devStart.y };
// We need to know if the arc is CW or CCW in device coordinates, so build this arc.
const deviceArc = new SHAPE_ARC(
toVector2I(devStart),
toVector2I(this.userToDeviceCoordinates(aArc.GetArcMid())),
toVector2I(devEnd),
0,
);
this.println('G75*'); // Multiquadrant (360 degrees) mode
if (deviceArc.IsClockwise())
this.println('G02*'); // Active circular interpolation, CW
else this.println('G03*'); // Active circular interpolation, CCW
this.println(
`X${KiROUND(devEnd.x)}Y${KiROUND(devEnd.y)}I${KiROUND(devRelCenter.x)}J${KiROUND(devRelCenter.y)}D01*`,
);
this.println('G01*'); // Back to linear interpolate (perhaps useless here).
}
/** Plot a Gerber arc (the centre / angles overload). See {@link plotArcShape}. */
protected plotArc(
aCenter: Vec2,
aStartAngle: EDA_ANGLE,
aEndAngle: EDA_ANGLE,
aRadius: number,
aPlotInRegion: boolean,
): void {
const start = {
x: KiROUND(aCenter.x + aRadius * aStartAngle.Cos()),
y: KiROUND(aCenter.y + aRadius * aStartAngle.Sin()),
};
if (!aPlotInRegion) this.MoveTo(start);
else this.LineTo(start);
const end = {
x: KiROUND(aCenter.x + aRadius * aEndAngle.Cos()),
y: KiROUND(aCenter.y + aRadius * aEndAngle.Sin()),
};
const devEnd = this.userToDeviceCoordinates(end);
// devRelCenter is the position on arc center relative to the arc start, in Gerber coord.
const devCenter = this.userToDeviceCoordinates(aCenter);
const devStart = this.userToDeviceCoordinates(start);
const devRelCenter = { x: devCenter.x - devStart.x, y: devCenter.y - devStart.y };
this.println('G75*'); // Multiquadrant (360 degrees) mode
if (aStartAngle.gt(aEndAngle))
this.println('G03*'); // Active circular interpolation, CCW
else this.println('G02*'); // Active circular interpolation, CW
this.println(
`X${KiROUND(devEnd.x)}Y${KiROUND(devEnd.y)}I${KiROUND(devRelCenter.x)}J${KiROUND(devRelCenter.y)}D01*`,
);
this.println('G01*'); // Back to linear interpolate (perhaps useless here).
}
/**
* Plot a Gerber region (the SHAPE_LINE_CHAIN overload): similar to PlotPoly but plot only
* filled polygon, and add the TA.AperFunction if aGbrMetadata contains this attribute, and
* clear it after plotting.
*/
PlotGerberRegionLineChain(aPoly: SHAPE_LINE_CHAIN, aGbrMetadata: GBR_METADATA | null): void {
if (aPoly.PointCount() <= 2) return;
let clearTA_AperFunction = false; // true if a TA.AperFunction is used
if (aGbrMetadata) {
const attrib = aGbrMetadata.m_ApertureMetadata.FormatAttribute(!this.m_useX2format);
if (attrib !== '') {
this.print(attrib);
clearTA_AperFunction = true;
}
}
this.PlotPolyLineChain(aPoly, FILL_T.FILLED_SHAPE, 0, aGbrMetadata);
// Clear the TA attribute, to avoid the next item to inherit it:
if (clearTA_AperFunction) {
if (this.m_useX2format) this.println('%TD.AperFunction*%');
else this.println('G04 #@! TD.AperFunction*');
}
}
/**
* Plot a Gerber region: similar to PlotPoly but plot only filled polygon,
* and add the TA.AperFunction if aGbrMetadata contains this attribute, and clear it
* after plotting.
*/
PlotGerberRegion(aCornerList: readonly Vec2[], aGbrMetadata: GBR_METADATA | null): void {
if (aCornerList.length <= 2) return;
let clearTA_AperFunction = false; // true if a TA.AperFunction is used
if (aGbrMetadata) {
const attrib = aGbrMetadata.m_ApertureMetadata.FormatAttribute(!this.m_useX2format);
if (attrib !== '') {
this.print(attrib);
clearTA_AperFunction = true;
}
}
this.PlotPoly(aCornerList, FILL_T.FILLED_SHAPE, 0, aGbrMetadata);
// Clear the TA attribute, to avoid the next item to inherit it:
if (clearTA_AperFunction) {
if (this.m_useX2format) this.println('%TD.AperFunction*%');
else this.println('G04 #@! TD.AperFunction*');
}
}
/**
* Similar to PlotPoly(), plot a filled polygon using Gerber region,
* therefore adding X2 attributes to the region object, like TA.xxx
*/
PlotPolyAsRegion(
aPoly: SHAPE_LINE_CHAIN,
aFill: FILL_T,
aWidth: number,
aGbrMetadata: GBR_METADATA | null,
): void {
// plot a filled polygon using Gerber region, therefore adding X2 attributes
// to the solid polygon
if (aWidth || aFill === FILL_T.NO_FILL)
this.PlotPolyLineChain(aPoly, FILL_T.NO_FILL, aWidth, aGbrMetadata);
if (aFill !== FILL_T.NO_FILL) this.PlotGerberRegionLineChain(aPoly, aGbrMetadata);
}
/** `PlotPoly( const SHAPE_LINE_CHAIN&, … )`: arcs in the chain plot as Gerber arcs. */
override PlotPolyLineChain(
aPoly: SHAPE_LINE_CHAIN,
aFill: FILL_T,
aWidth: number,
aData?: unknown,
): void {
if (aPoly.CPoints().length <= 1) return;
// Gerber format does not know filled polygons with thick outline
// Therefore, to plot a filled polygon with outline having a thickness,
// one should plot outline as thick segments
const gbr_metadata = asMetadata(aData);
if (gbr_metadata) this.formatNetAttribute(gbr_metadata.m_NetlistMetadata);
const first = aPoly.CPoint(0);
const last = aPoly.CLastPoint();
if (aFill !== FILL_T.NO_FILL) {
this.println('G36*');
this.MoveTo(first);
this.println('G01*'); // Set linear interpolation.
for (let ii = 1; ii < aPoly.PointCount(); ii++) {
const arcindex = aPoly.ArcIndex(ii);
if (arcindex < 0) {
/// Plain point
this.LineTo(aPoly.CPoint(ii));
} else {
const arc = aPoly.Arc(arcindex);
this.plotArcShape(arc, true);
// skip points on arcs, since we plot the arc itself
while (ii + 1 < aPoly.PointCount() && arcindex === aPoly.ArcIndex(ii + 1)) ii++;
}
}
// If the polygon is not closed, close it:
if (!vecEq(first, last)) this.FinishTo(first);
this.println('G37*');
} else if (aWidth !== 0) {
// Draw the polyline/polygon outline
this.SetCurrentLineWidth(aWidth, gbr_metadata);
this.MoveTo(first);
for (let ii = 1; ii < aPoly.PointCount(); ii++) {
const arcindex = aPoly.ArcIndex(ii);
if (arcindex < 0) {
/// Plain point
this.LineTo(aPoly.CPoint(ii));
} else {
const arc = aPoly.Arc(arcindex);
this.plotArcShape(arc, true);
// skip points on arcs, since we plot the arc itself
while (ii + 1 < aPoly.PointCount() && arcindex === aPoly.ArcIndex(ii + 1)) ii++;
}
}
// Ensure the thick outline is closed for filled polygons
// (if not filled, could be only a polyline)
if (!vecEq(first, last) && (aPoly.IsClosed() || aFill !== FILL_T.NO_FILL)) this.LineTo(first);
this.PenFinish();
}
}
/**
* Gerber polygon: they can (and *should*) be filled with the
* appropriate G36/G37 sequence
*/
PlotPoly(aCornerList: readonly Vec2[], aFill: FILL_T, aWidth: number, aData?: unknown): void {
if (aCornerList.length <= 1) return;
// Gerber format does not know filled polygons with thick outline
// Therefore, to plot a filled polygon with outline having a thickness,
// one should plot outline as thick segments
const gbr_metadata = asMetadata(aData);
if (gbr_metadata) this.formatNetAttribute(gbr_metadata.m_NetlistMetadata);
const first = aCornerList[0]!;
const last = aCornerList[aCornerList.length - 1]!;
if (aFill !== FILL_T.NO_FILL) {
this.println('G36*');
this.MoveTo(first);
this.println('G01*'); // Set linear interpolation.
for (let ii = 1; ii < aCornerList.length; ii++) this.LineTo(aCornerList[ii]!);
// If the polygon is not closed, close it:
if (!vecEq(first, last)) this.FinishTo(first);
this.println('G37*');
}
if (aWidth !== 0 || aFill === FILL_T.NO_FILL) {
// Draw the polyline/polygon outline
this.SetCurrentLineWidth(aWidth, gbr_metadata);
this.MoveTo(first);
for (let ii = 1; ii < aCornerList.length; ii++) this.LineTo(aCornerList[ii]!);
// Ensure the thick outline is closed for filled polygons
// (if not filled, could be only a polyline)
if (aFill !== FILL_T.NO_FILL && !vecEq(last, first)) this.LineTo(first);
this.PenFinish();
}
}
override ThickSegment(start: Vec2, end: Vec2, width: number, aData?: unknown): void {
const gbr_metadata = asMetadata(aData);
if (gbr_metadata) this.formatNetAttribute(gbr_metadata.m_NetlistMetadata);
this.SetCurrentLineWidth(width, aData);
// A zero-length segment is plotted as a single flash of the segment's aperture.
// Falling through to PLOTTER::ThickSegment would emit a filled circle stroked with
// the (now sentinel) DO_NOT_SET_LINE_WIDTH width, creating a spurious 0-size aperture.
if (vecEq(start, end)) {
this.MoveTo(start);
this.FinishTo(end);
return;
}
super.ThickSegment(start, end, DO_NOT_SET_LINE_WIDTH, aData);
}
override ThickArc(
aCentre: Vec2,
aStartAngle: EDA_ANGLE,
aAngle: EDA_ANGLE,
aRadius: number,
aWidth: number,
aData?: unknown,
): void {
const gbr_metadata = asMetadata(aData);
if (gbr_metadata) this.formatNetAttribute(gbr_metadata.m_NetlistMetadata);
this.SetCurrentLineWidth(aWidth, aData);
super.ThickArc(aCentre, aStartAngle, aAngle, aRadius, DO_NOT_SET_LINE_WIDTH, aData);
}
override ThickRect(p1: Vec2, p2: Vec2, width: number, aData?: unknown): void {
const gbr_metadata = asMetadata(aData);
if (gbr_metadata) this.formatNetAttribute(gbr_metadata.m_NetlistMetadata);
this.SetCurrentLineWidth(width, aData);
super.ThickRect(p1, p2, DO_NOT_SET_LINE_WIDTH, aData);
}
override ThickCircle(pos: Vec2, diametre: number, width: number, aData?: unknown): void {
const gbr_metadata = asMetadata(aData);
if (gbr_metadata) this.formatNetAttribute(gbr_metadata.m_NetlistMetadata);
this.SetCurrentLineWidth(width, aData);
super.ThickCircle(pos, diametre, DO_NOT_SET_LINE_WIDTH, aData);
}
override FilledCircle(pos: Vec2, diametre: number, aData?: unknown): void {
// A filled circle is a graphic item, not a pad.
// So it is drawn, not flashed.
const gbr_metadata = asMetadata(aData);
if (gbr_metadata) this.formatNetAttribute(gbr_metadata.m_NetlistMetadata);
// Draw a circle of diameter = diameter/2 with a line thickness = radius,
// To create a filled circle
this.SetCurrentLineWidth(Math.trunc(diametre / 2), aData);
this.Circle(pos, Math.trunc(diametre / 2), FILL_T.NO_FILL, DO_NOT_SET_LINE_WIDTH);
}
override ThickPoly(aPoly: SHAPE_POLY_SET, aWidth: number, aData?: unknown): void {
const gbr_metadata = asMetadata(aData);
if (gbr_metadata) this.formatNetAttribute(gbr_metadata.m_NetlistMetadata);
this.SetCurrentLineWidth(aWidth, aData);
super.ThickPoly(aPoly, DO_NOT_SET_LINE_WIDTH, aData);
}
/** Filled circular flashes are stored as apertures. */
FlashPadCircle(pos: Vec2, diametre: number, aData?: unknown): void {
const size = { x: diametre, y: diametre };
const gbr_metadata = asMetadata(aData);
this.selectApertureWithAttributes(pos, gbr_metadata, size, 0, ANGLE_0, APERTURE_TYPE.AT_CIRCLE);
}
FlashPadOval(aPos: Vec2, aSize: Vec2, aOrient: EDA_ANGLE, aData?: unknown): void {
// wxASSERT( m_outputFile );
const size = { x: aSize.x, y: aSize.y };
let orient = aOrient.Clone();
orient.Normalize();
const gbr_metadata = asMetadata(aData);
// Flash a vertical or horizontal shape (this is a basic aperture).
if (orient.IsCardinal()) {
if (orient.IsCardinal90()) [size.x, size.y] = [size.y, size.x];
this.selectApertureWithAttributes(
aPos,
gbr_metadata,
size,
0,
ANGLE_0,
APERTURE_TYPE.AT_OVAL,
);
} else {
// Plot pad as region.
// Only regions and flashed items accept a object attribute TO.P for the pin name
if (!this.m_gerberDisableApertMacros) {
this.m_hasApertureRotOval = true;
// We are using a aperture macro that expect size.y < size.x
// i.e draw a horizontal line for rotation = 0.0
// size.x = length, size.y = width
if (size.x < size.y) {
[size.x, size.y] = [size.y, size.x];
orient = orient.add(ANGLE_90);
if (orient.gt(ANGLE_180)) orient = orient.sub(ANGLE_180);
}
this.selectApertureWithAttributes(
aPos,
gbr_metadata,
size,
0,
orient,
APERTURE_TYPE.AM_ROTATED_OVAL,
);
return;
}
// Draw the oval as round rect pad with a radius = 50% min size)
// In gerber file, it will be drawn as a region with arcs, and can be
// detected as pads (similar to a flashed pad)
this.FlashPadRoundRect(
aPos,
aSize,
Math.trunc(Math.min(aSize.x, aSize.y) / 2),
orient,
aData,
);
}
}
FlashPadRect(pos: Vec2, aSize: Vec2, aOrient: EDA_ANGLE, aData?: unknown): void {
// wxASSERT( m_outputFile );
const size = { x: aSize.x, y: aSize.y };
const gbr_metadata = asMetadata(aData);
// Horizontal / vertical rect can use a basic aperture (not a macro)
// so use it for rotation n*90 deg
if (aOrient.IsCardinal()) {
// Build the not rotated equivalent shape:
if (aOrient.IsCardinal90()) [size.x, size.y] = [size.y, size.x];
this.selectApertureWithAttributes(pos, gbr_metadata, size, 0, ANGLE_0, APERTURE_TYPE.AT_RECT);
} else if (!this.m_gerberDisableApertMacros) {
this.m_hasApertureRotRect = true;
this.selectApertureWithAttributes(
pos,
gbr_metadata,
size,
0,
aOrient,
APERTURE_TYPE.AM_ROT_RECT,
);
} else {
// plot pad shape as Gerber region
// coord[0] is assumed the lower left
// coord[1] is assumed the upper left
// coord[2] is assumed the upper right
// coord[3] is assumed the lower right
const hx = Math.trunc(size.x / 2);
const hy = Math.trunc(size.y / 2);
const coord: Vec2[] = [
{ x: -hx, y: hy }, // lower left
{ x: -hx, y: -hy }, // upper left
{ x: hx, y: -hy }, // upper right
{ x: hx, y: hy }, // lower right
];
this.FlashPadTrapez(pos, coord, aOrient, aData);
}
}
FlashPadRoundRect(
aPadPos: Vec2,
aSize: Vec2,
aCornerRadius: number,
aOrient: EDA_ANGLE,
aData?: unknown,
): void {
const gbr_metadata = asMetadata(aData);
if (!this.m_gerberDisableApertMacros) {
this.m_hasApertureRoundRect = true;
this.selectApertureWithAttributes(
aPadPos,
gbr_metadata,
aSize,
aCornerRadius,
aOrient,
APERTURE_TYPE.AM_ROUND_RECT,
);
return;
}
// A Pad RoundRect is plotted as a Gerber region.
// Initialize region metadata:
let clearTA_AperFunction = false; // true if a TA.AperFunction is used
if (gbr_metadata) {
this.formatNetAttribute(gbr_metadata.m_NetlistMetadata);
const attrib = gbr_metadata.m_ApertureMetadata.FormatAttribute(!this.m_useX2format);
if (attrib !== '') {
this.print(attrib);
clearTA_AperFunction = true;
}
}
// Plot the region using arcs in corners.
this.plotRoundRectAsRegion(aPadPos, aSize, aCornerRadius, aOrient);
// Clear the TA attribute, to avoid the next item to inherit it:
if (clearTA_AperFunction) {
if (this.m_useX2format) this.println('%TD.AperFunction*%');
else this.println('G04 #@! TD.AperFunction*');
}
}
/**
* Plot a round rect (a round rect shape in fact) as a Gerber region using lines and arcs
* for corners.
*
* @note Only the G36 ... G37 region is created.
*/
protected plotRoundRectAsRegion(
aRectCenter: Vec2,
aSize: Vec2,
aCornerRadius: number,
aOrient: EDA_ANGLE,
): void {
// The region outline is generated by 4 sides and 4 90 deg arcs
// 1 --- 2
// | c |
// 4 --- 3
// Note also in user coordinates the Y axis is from top to bottom
// for historical reasons.
// A helper structure to handle outlines coordinates (segments and arcs)
// in user coordinates
interface RR_EDGE {
m_start: Vec2;
m_end: Vec2;
m_center: Vec2;
m_arc_angle_start: EDA_ANGLE;
}
const hsizeX = Math.trunc(aSize.x / 2);
const hsizeY = Math.trunc(aSize.y / 2);
const rr_outline: RR_EDGE[] = [];
// Build outline coordinates, relative to rectangle center, rotation 0:
// Top left corner 1 (and 4 to 1 left vertical side @ x=-hsizeX)
rr_outline.push({
m_start: { x: -hsizeX, y: hsizeY - aCornerRadius },
m_end: { x: -hsizeX, y: -hsizeY + aCornerRadius },
m_center: { x: -hsizeX + aCornerRadius, y: -hsizeY + aCornerRadius },
m_arc_angle_start: aOrient.add(ANGLE_180),
});
// Top right corner 2 (and 1 to 2 top horizontal side @ y=-hsizeY)
rr_outline.push({
m_start: { x: -hsizeX + aCornerRadius, y: -hsizeY },
m_end: { x: hsizeX - aCornerRadius, y: -hsizeY },
m_center: { x: hsizeX - aCornerRadius, y: -hsizeY + aCornerRadius },
m_arc_angle_start: aOrient.add(ANGLE_90),
});
// bottom right corner 3 (and 2 to 3 right vertical side @ x=hsizeX)
rr_outline.push({
m_start: { x: hsizeX, y: -hsizeY + aCornerRadius },
m_end: { x: hsizeX, y: hsizeY - aCornerRadius },
m_center: { x: hsizeX - aCornerRadius, y: hsizeY - aCornerRadius },
m_arc_angle_start: aOrient.add(ANGLE_0),
});
// bottom left corner 4 (and 3 to 4 bottom horizontal side @ y=hsizeY)
const curr_edge: RR_EDGE = {
m_start: { x: hsizeX - aCornerRadius, y: hsizeY },
m_end: { x: -hsizeX + aCornerRadius, y: hsizeY },
m_center: { x: -hsizeX + aCornerRadius, y: hsizeY - aCornerRadius },
m_arc_angle_start: aOrient.sub(ANGLE_90),
};
rr_outline.push(curr_edge);
// Move relative coordinates to the actual location and rotation:
let arc_last_center: Vec2 = { x: 0, y: 0 };
const arc_last_angle = curr_edge.m_arc_angle_start.sub(ANGLE_90);
for (const rr_edge of rr_outline) {
const s = RotatePoint(rr_edge.m_start, aOrient);
const e = RotatePoint(rr_edge.m_end, aOrient);
const c = RotatePoint(rr_edge.m_center, aOrient);
rr_edge.m_start = { x: s.x + aRectCenter.x, y: s.y + aRectCenter.y };
rr_edge.m_end = { x: e.x + aRectCenter.x, y: e.y + aRectCenter.y };
rr_edge.m_center = { x: c.x + aRectCenter.x, y: c.y + aRectCenter.y };
arc_last_center = rr_edge.m_center;
}
// Ensure the region is a closed polygon, i.e. the end point of last segment
// (end of arc) is the same as the first point. Rounding issues can create a
// small difference, mainly for rotated pads.
// calculate last point (end of last arc):
const last_pt = {
x: arc_last_center.x + KiROUND(aCornerRadius * arc_last_angle.Cos()),
y: arc_last_center.y - KiROUND(aCornerRadius * arc_last_angle.Sin()),
};
this.println('G36*'); // Start region
this.println('G01*'); // Set linear interpolation.
const first_pt = last_pt;
this.MoveTo(first_pt); // Start point of region, must be same as end point
for (const rr_edge of rr_outline) {
if (aCornerRadius) {
// Guard: ensure we do not create arcs with radius = 0
// LineTo( rr_edge.m_end ); // made in plotArc()
this.plotArc(
rr_edge.m_center,
rr_edge.m_arc_angle_start.negate(),
rr_edge.m_arc_angle_start.negate().add(ANGLE_90),
aCornerRadius,
true,
);
} else {
this.LineTo(rr_edge.m_end);
}
}
this.println('G37*'); // Close region
}
FlashPadCustom(
aPadPos: Vec2,
_aSize: Vec2,
aOrient: EDA_ANGLE,
aPolygons: SHAPE_POLY_SET,
aData?: unknown,
): void {
// A Pad custom is plotted as polygon (a region in Gerber language).
const source = asMetadata(aData);
const gbr_metadata = source ? source.Clone() : new GBR_METADATA();
const polyshape = aPolygons.CloneDropTriangulation();
for (let cnt = 0; cnt < polyshape.OutlineCount(); ++cnt) {
const poly = polyshape.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]!);
if (
this.m_gerberDisableApertMacros ||
cornerList.length > GBR_MACRO_FOR_CUSTOM_PAD_MAX_CORNER_COUNT
) {
this.PlotGerberRegion(cornerList, gbr_metadata);
} else {
// An AM will be created. the shape must be in position 0,0 and orientation 0
// to be able to reuse the same AM for pads having the same shape
for (let ii = 0; ii < cornerList.length; ii++) {
const rel = { x: cornerList[ii]!.x - aPadPos.x, y: cornerList[ii]!.y - aPadPos.y };
cornerList[ii] = RotatePoint(rel, aOrient.negate());
}
const pos_dev = this.userToDeviceCoordinates(aPadPos);
this.selectApertureCorners(
cornerList,
aOrient,
APERTURE_TYPE.AM_FREE_POLYGON,
gbr_metadata.GetApertureAttrib(),
gbr_metadata.GetCustomAttribute(),
);
this.formatNetAttribute(gbr_metadata.m_NetlistMetadata);
this.emitDcode(pos_dev, 3);
}
}
}
/**
* Flash a chamfered round rect pad.
*
* @param aChamferPositions is the identifier of the corners to chamfer:
* 0 = no chamfer, 1 = TOP_LEFT, 2 = TOP_RIGHT, 4 = BOTTOM_LEFT, 8 = BOTTOM_RIGHT
*/
FlashPadChamferRoundRect(
aShapePos: Vec2,
aPadSize: Vec2,
aCornerRadius: number,
aChamferRatio: number,
aChamferPositions: number,
aPadOrient: EDA_ANGLE,
aData?: unknown,
): void {
const source = asMetadata(aData);
const gbr_metadata = source ? source.Clone() : new GBR_METADATA();
const pos_device = this.userToDeviceCoordinates(aShapePos);
const outline = new SHAPE_POLY_SET();
const cornerList: Vec2[] = [];
const hasRoundedCorner = aCornerRadius !== 0 && aChamferPositions !== 15;
// Round rect shape or Apert Macros disabled
if (hasRoundedCorner || this.m_gerberDisableApertMacros) {
TransformRoundChamferedRectToPolygon(
outline,
aShapePos,
aPadSize,
aPadOrient,
aCornerRadius,
aChamferRatio,
aChamferPositions,
0,
this.GetPlotterArcHighDef(),
ERROR_LOC.ERROR_INSIDE,
);
// Build the corner list
const corners = outline.Outline(0);
for (let ii = 0; ii < corners.PointCount(); ii++) {
const p = corners.CPoint(ii);
cornerList.push({ x: p.x, y: p.y });
}
// Close the polygon
cornerList.push(cornerList[0]!);
if (this.m_gerberDisableApertMacros) {
this.PlotGerberRegion(cornerList, gbr_metadata);
} else {
// An AM will be created. the shape must be in position 0,0 and orientation 0
// to be able to reuse the same AM for pads having the same shape
for (let ii = 0; ii < cornerList.length; ii++) {
const rel = {
x: cornerList[ii]!.x - aShapePos.x,
y: cornerList[ii]!.y - aShapePos.y,
};
cornerList[ii] = RotatePoint(rel, aPadOrient.negate());
}
this.selectApertureCorners(
cornerList,
aPadOrient,
APERTURE_TYPE.AM_FREE_POLYGON,
gbr_metadata.GetApertureAttrib(),
gbr_metadata.GetCustomAttribute(),
);
this.formatNetAttribute(gbr_metadata.m_NetlistMetadata);
this.emitDcode(pos_device, 3);
}
return;
}
// Build the chamfered polygon (4 to 8 corners )
TransformRoundChamferedRectToPolygon(
outline,
{ x: 0, y: 0 },
aPadSize,
ANGLE_0,
0,
aChamferRatio,
aChamferPositions,
0,
this.GetPlotterArcHighDef(),
ERROR_LOC.ERROR_INSIDE,
);
// Build the corner list
const corners = outline.Outline(0);
// Generate the polygon (4 to 8 corners )
for (let ii = 0; ii < corners.PointCount(); ii++) {
const p = corners.CPoint(ii);
cornerList.push({ x: p.x, y: p.y });
}
const type: Partial<Record<number, APERTURE_TYPE>> = {
4: APERTURE_TYPE.APER_MACRO_OUTLINE4P,
5: APERTURE_TYPE.APER_MACRO_OUTLINE5P,
6: APERTURE_TYPE.APER_MACRO_OUTLINE6P,
7: APERTURE_TYPE.APER_MACRO_OUTLINE7P,
8: APERTURE_TYPE.APER_MACRO_OUTLINE8P,
};
const apertureType = type[cornerList.length];
if (apertureType === undefined) {
// wxLogMessage( "FlashPadChamferRoundRect(): Unexpected number of corners (%d)" )
} else {
if (cornerList.length === 4) this.m_hasApertureOutline4P = true;
else this.m_hasApertureChamferedRect = true;
this.selectApertureCorners(
cornerList,
aPadOrient,
apertureType,
gbr_metadata.GetApertureAttrib(),
gbr_metadata.GetCustomAttribute(),
);
}
this.formatNetAttribute(gbr_metadata.m_NetlistMetadata);
this.emitDcode(pos_device, 3);
}
FlashPadTrapez(
aPadPos: Vec2,
aCorners: readonly Vec2[],
aPadOrient: EDA_ANGLE,
aData?: unknown,
): void {
// polygon corners list
const cornerList: Vec2[] = [aCorners[0]!, aCorners[1]!, aCorners[2]!, aCorners[3]!].map((c) => {
// Draw the polygon and fill the interior as required
const r = RotatePoint(c, aPadOrient);
return { x: r.x + aPadPos.x, y: r.y + aPadPos.y };
});
// Close the polygon
cornerList.push(cornerList[0]!);
const gbr_metadata = asMetadata(aData);
const metadata = gbr_metadata ? gbr_metadata.Clone() : new GBR_METADATA();
// Plot a filled polygon:
if (!this.m_gerberDisableApertMacros) {
this.m_hasApertureOutline4P = true;
const pos_dev = this.userToDeviceCoordinates(aPadPos);
// polygon corners list
const corners: Vec2[] = [aCorners[0]!, aCorners[1]!, aCorners[2]!, aCorners[3]!];
let aperture_attribute = 0;
let custom_attribute = '';
if (gbr_metadata) {
aperture_attribute = gbr_metadata.GetApertureAttrib();
custom_attribute = gbr_metadata.GetCustomAttribute();
}
this.selectApertureCorners(
corners,
aPadOrient,
APERTURE_TYPE.APER_MACRO_OUTLINE4P,
aperture_attribute,
custom_attribute,
);
if (gbr_metadata) this.formatNetAttribute(gbr_metadata.m_NetlistMetadata);
this.emitDcode(pos_dev, 3);
return;
}
this.PlotGerberRegion(cornerList, metadata);
}
FlashRegularPolygon(
aShapePos: Vec2,
aDiameter: number,
aCornerCount: number,
aOrient: EDA_ANGLE,
aData?: unknown,
): void {
const gbr_metadata = asMetadata(aData);
const apert_type: APERTURE_TYPE = APERTURE_TYPE.AT_REGULAR_POLY3 + aCornerCount - 3;
// wxASSERT( apert_type >= AT_REGULAR_POLY3 && apert_type <= AT_REGULAR_POLY12 );
this.selectApertureWithAttributes(
aShapePos,
gbr_metadata,
{ x: 0, y: 0 },
Math.trunc(aDiameter / 2),
aOrient,
apert_type,
);
}
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 {
const gbr_metadata = asMetadata(aData);
if (gbr_metadata) this.formatNetAttribute(gbr_metadata.m_NetlistMetadata);
super.Text(
aPos,
aColor,
aText,
aOrient,
aSize,
aH_justify,
aV_justify,
aWidth,
aItalic,
aBold,
aMultilineAllowed,
aFont,
aFontMetrics,
aData,
);
}
override PlotText(
aPos: Vec2,
aColor: Color4d,
aText: string,
aAttributes: PLOTTER_TEXT_ATTRIBUTES,
aFont: PLOTTER_FONT | null,
aFontMetrics?: unknown,
aData?: unknown,
): void {
const gbr_metadata = asMetadata(aData);
if (gbr_metadata) this.formatNetAttribute(gbr_metadata.m_NetlistMetadata);
super.PlotText(aPos, aColor, aText, aAttributes, aFont, aFontMetrics, aData);
}
/**
* Change the plot polarity and begin a new layer.
*
* Used to 'scratch off' silk screen away from solder mask.
*/
override SetLayerPolarity(aPositive: boolean): void {
if (aPositive) this.println('%LPD*%');
else this.println('%LPC*%');
}
}