1401 lines
47 KiB
TypeScript
1401 lines
47 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.
|
|
/**
|
|
* `BRDITEMS_PLOTTER` — `pcbnew/plot_brditems_plotter.cpp`, declared in
|
|
* `pcbplot.h`: plots one board item at a time through a PLOTTER, attaching
|
|
* the Gerber X2 aperture and object attributes (`GBR_METADATA`) each item
|
|
* carries.
|
|
*/
|
|
|
|
import {
|
|
COLOR4D_BLACK,
|
|
COLOR4D_WHITE,
|
|
type Color4d,
|
|
LEGACY_COLORS,
|
|
} from '@ziroeda/common/gal/color4d.js';
|
|
import { CALLBACK_GAL } from '@ziroeda/common/callback_gal.js';
|
|
import type { EDA_TEXT } from '@ziroeda/common/eda_text.js';
|
|
import { FONT } from '@ziroeda/common/font/font.js';
|
|
import { METRICS } from '@ziroeda/common/font/font_metrics.js';
|
|
import { TEXT_ATTRIBUTES } from '@ziroeda/common/font/text_attributes.js';
|
|
import { GBR_APERTURE_ATTRIB, GBR_METADATA } from '@ziroeda/common/gbr_metadata.js';
|
|
import { GBR_NETINFO_TYPE } from '@ziroeda/common/gbr_netlist_metadata.js';
|
|
import { IsCopperLayer, IsExternalCopperLayer, PCB_LAYER_ID } from '@ziroeda/common/layer_id.js';
|
|
import { LSET } from '@ziroeda/common/lset.js';
|
|
import {
|
|
DXF_OUTLINE_MODE,
|
|
FILL_T,
|
|
LINE_STYLE,
|
|
PLOT_FORMAT,
|
|
PLOT_TEXT_MODE,
|
|
type PLOTTER,
|
|
plotterFont,
|
|
} from '@ziroeda/common/plotters/plotter.js';
|
|
import type { GERBER_PLOTTER } from '@ziroeda/common/plotters/GERBER_plotter.js';
|
|
import { RENDER_SETTINGS } from '@ziroeda/common/render_settings.js';
|
|
import { STROKE_PARAMS } from '@ziroeda/common/stroke_params.js';
|
|
import { printableCharCount, unescapeString, wxStringSplit } from '@ziroeda/common/string_utils.js';
|
|
import { SHAPE_T } from '@ziroeda/common/eda_shape.js';
|
|
import { KICAD_T } from '@ziroeda/core/typeinfo.js';
|
|
import { ERROR_LOC } from '@ziroeda/kimath/src/convert_basic_shapes_to_polygon.js';
|
|
import { ANGLE_0, ANGLE_90, type EDA_ANGLE } from '@ziroeda/kimath/src/geometry/eda_angle.js';
|
|
import type { SHAPE_LINE_CHAIN } from '@ziroeda/kimath/src/geometry/shape_line_chain.js';
|
|
import { SHAPE_POLY_SET, CornerStrategy } from '@ziroeda/kimath/src/geometry/shape_poly_set.js';
|
|
import { SHAPE_RECT } from '@ziroeda/kimath/src/geometry/shape_rect.js';
|
|
import { SHAPE_SEGMENT } from '@ziroeda/kimath/src/geometry/shape_segment.js';
|
|
import type { SHAPE_CIRCLE } from '@ziroeda/kimath/src/geometry/shape_circle.js';
|
|
import { SHAPE_TYPE } from '@ziroeda/kimath/src/geometry/shape.js';
|
|
import { BOX2I } from '@ziroeda/kimath/src/math/box2.js';
|
|
import { KiROUND } from '@ziroeda/kimath/src/math/util.js';
|
|
import { ARC_LOW_DEF } from '@ziroeda/kimath/src/base_units.js';
|
|
import type { VECTOR2I } from '@ziroeda/kimath/src/math/vector2.js';
|
|
import { RotatePoint } from '@ziroeda/kimath/src/trigo.js';
|
|
import { pcbIUScale } from '@ziroeda/common/eda_units.js';
|
|
import { ADVANCED_CFG } from '@ziroeda/common/advanced_config.js';
|
|
import type { BOARD } from './board.js';
|
|
import type { BOARD_ITEM } from './board_item.js';
|
|
import type { FOOTPRINT } from './footprint.js';
|
|
import type { PAD } from './pad.js';
|
|
import { PAD_ATTRIB, PAD_DRILL_SHAPE, PAD_PROP, PAD_SHAPE, PADSTACK } from './padstack.js';
|
|
import { PCB_PLOT_PARAMS, DRILL_MARKS } from './pcb_plot_params.js';
|
|
import { PCB_SHAPE } from './pcb_shape.js';
|
|
import type { PCB_TEXT } from './pcb_text.js';
|
|
import type { PCB_TEXTBOX } from './pcb_textbox.js';
|
|
import type { PCB_TABLE } from './pcb_table.js';
|
|
import type { PCB_DIMENSION_BASE } from './pcb_dimension.js';
|
|
import type { PCB_TARGET } from './pcb_target.js';
|
|
import type { PCB_BARCODE } from './pcb_barcode.js';
|
|
import type { PCB_VIA } from './pcb_track.js';
|
|
import type { ZONE } from './zone.js';
|
|
|
|
const WHITE = COLOR4D_WHITE;
|
|
/** The EDA_TEXT half of every text item BRDITEMS_PLOTTER::PlotText is handed. */
|
|
type PLOTTED_TEXT = Pick<
|
|
EDA_TEXT,
|
|
| 'GetDrawFont'
|
|
| 'GetShownText'
|
|
| 'GetTextPos'
|
|
| 'GetAttributes'
|
|
| 'GetEffectiveTextPenWidth'
|
|
| 'GetDrawRotation'
|
|
| 'GetRenderCache'
|
|
| 'IsMultilineAllowed'
|
|
| 'GetLinePositions'
|
|
>;
|
|
|
|
/** `LIGHTGRAY`, the `EDA_COLOR_T` palette entry (color4d.cpp). */
|
|
const LIGHTGRAY: Color4d = LEGACY_COLORS.LIGHTGRAY;
|
|
|
|
const colorEquals = (a: Color4d, b: Color4d): boolean =>
|
|
a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a;
|
|
|
|
/** Plots board items through a PLOTTER, with Gerber attributes. */
|
|
export class BRDITEMS_PLOTTER extends PCB_PLOT_PARAMS {
|
|
private m_plotter: PLOTTER;
|
|
private m_board: BOARD;
|
|
private m_layerMask = new LSET();
|
|
|
|
constructor(aPlotter: PLOTTER, aBoard: BOARD, aPlotOpts: PCB_PLOT_PARAMS) {
|
|
super();
|
|
this.assign(aPlotOpts);
|
|
this.m_plotter = aPlotter;
|
|
this.m_board = aBoard;
|
|
}
|
|
|
|
getFineWidthAdj(): number {
|
|
if (this.GetFormat() === PLOT_FORMAT.POST) return this.GetWidthAdjust();
|
|
else return 0;
|
|
}
|
|
|
|
// Basic functions to plot a board item
|
|
SetLayerSet(aLayerMask: LSET): void {
|
|
this.m_layerMask = aLayerMask;
|
|
}
|
|
|
|
private hideDNPItems(aLayer: PCB_LAYER_ID): boolean {
|
|
return (
|
|
this.GetHideDNPFPsOnFabLayers() &&
|
|
(aLayer === PCB_LAYER_ID.F_Fab || aLayer === PCB_LAYER_ID.B_Fab)
|
|
);
|
|
}
|
|
|
|
private crossoutDNPItems(aLayer: PCB_LAYER_ID): boolean {
|
|
return (
|
|
this.GetCrossoutDNPFPsOnFabLayers() &&
|
|
(aLayer === PCB_LAYER_ID.F_Fab || aLayer === PCB_LAYER_ID.B_Fab)
|
|
);
|
|
}
|
|
|
|
/** `m_plotter->RenderSettings()` as the RENDER_SETTINGS the text calls take. */
|
|
private renderSettings(): RENDER_SETTINGS | null {
|
|
const settings = this.m_plotter.RenderSettings();
|
|
return settings instanceof RENDER_SETTINGS ? settings : null;
|
|
}
|
|
|
|
/** `getMetadata()`: the Gerber metadata, the DXF plot options, or nothing. */
|
|
private metadata(aGbrMetadata: GBR_METADATA): unknown {
|
|
const type = this.m_plotter.GetPlotterType();
|
|
|
|
if (type === PLOT_FORMAT.GERBER) return aGbrMetadata;
|
|
if (type === PLOT_FORMAT.DXF) return this;
|
|
|
|
return null;
|
|
}
|
|
|
|
private gerber(): GERBER_PLOTTER | null {
|
|
return this.m_plotter.GetPlotterType() === PLOT_FORMAT.GERBER
|
|
? (this.m_plotter as GERBER_PLOTTER)
|
|
: null;
|
|
}
|
|
|
|
getColor(aLayer: number): Color4d {
|
|
let color = this.ColorSettings().GetColor(aLayer);
|
|
|
|
// A hack to avoid plotting a white item in white color on white paper
|
|
if (colorEquals(color, WHITE)) color = LIGHTGRAY;
|
|
|
|
return color;
|
|
}
|
|
|
|
PlotPadNumber(aPad: PAD, aColor: Color4d): void {
|
|
const padNumber = unescapeString(aPad.GetNumber());
|
|
|
|
if (padNumber === '') return;
|
|
|
|
const padBBox = aPad.GetBoundingBox();
|
|
let position = padBBox.Centre();
|
|
const padsize = { ...padBBox.GetSize() };
|
|
|
|
// TODO(JE) padstacks
|
|
if (aPad.GetShape(PADSTACK.ALL_LAYERS) === PAD_SHAPE.CUSTOM) {
|
|
// See if we have a number box
|
|
for (const primitive of aPad.GetPrimitives(PADSTACK.ALL_LAYERS)) {
|
|
if (primitive.IsProxyItem() && primitive.GetShape() === SHAPE_T.RECTANGLE) {
|
|
position = RotatePoint(primitive.GetCenter(), aPad.GetOrientation());
|
|
const shapePos = aPad.ShapePos(PADSTACK.ALL_LAYERS);
|
|
position = { x: position.x + shapePos.x, y: position.y + shapePos.y };
|
|
|
|
padsize.x = Math.abs(primitive.GetBotRight().x - primitive.GetTopLeft().x);
|
|
padsize.y = Math.abs(primitive.GetBotRight().y - primitive.GetTopLeft().y);
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (aPad.GetShape(PADSTACK.ALL_LAYERS) !== PAD_SHAPE.CUSTOM) {
|
|
// Don't allow a 45° rotation to bloat a pad's bounding box unnecessarily
|
|
const size = aPad.GetSize(PADSTACK.ALL_LAYERS);
|
|
const limit = KiROUND(Math.min(size.x, size.y) * 1.1);
|
|
|
|
if (padsize.x > limit && padsize.y > limit) {
|
|
padsize.x = limit;
|
|
padsize.y = limit;
|
|
}
|
|
}
|
|
|
|
const textAttrs = new TEXT_ATTRIBUTES();
|
|
|
|
textAttrs.m_Mirrored = this.m_plotter.GetPlotMirrored();
|
|
|
|
if (padsize.x < padsize.y * 0.95) {
|
|
textAttrs.m_Angle = ANGLE_90;
|
|
[padsize.x, padsize.y] = [padsize.y, padsize.x];
|
|
}
|
|
|
|
// approximate the size of the pad number text:
|
|
// We use a size for at least 3 chars, to give a good look even for short numbers
|
|
let tsize = KiROUND(padsize.x / Math.max(printableCharCount(padNumber), 3));
|
|
tsize = Math.min(tsize, padsize.y);
|
|
|
|
// enforce a max size
|
|
tsize = Math.min(tsize, pcbIUScale.mmToIU(5.0));
|
|
|
|
textAttrs.m_Size = { x: tsize, y: tsize };
|
|
|
|
// use a somewhat spindly font to go with the outlined pads
|
|
textAttrs.m_StrokeWidth = KiROUND(tsize / 12.0);
|
|
|
|
// `PlotText( position, aColor, padNumber, textAttrs )`: the font and metrics
|
|
// default to `nullptr` and `METRICS::Default()`, and a null font is
|
|
// `FONT::GetFont( m_renderSettings->GetDefaultFont() )`, the stroke font.
|
|
this.m_plotter.PlotText(
|
|
position,
|
|
aColor,
|
|
padNumber,
|
|
textAttrs,
|
|
plotterFont(FONT.GetFont(), METRICS.Default()),
|
|
);
|
|
}
|
|
|
|
PlotPad(aPad: PAD, aLayer: PCB_LAYER_ID, aColor: Color4d, aSketchMode: boolean): void {
|
|
const shape_pos = aPad.ShapePos(aLayer);
|
|
const metadata = new GBR_METADATA();
|
|
|
|
const plotOnCopperLayer = this.m_layerMask.and(LSET.AllCuMask()).any();
|
|
const plotOnExternalCopperLayer = this.m_layerMask.and(LSET.ExternalCuMask()).any();
|
|
|
|
// Pad not on the solder mask layer cannot be soldered.
|
|
// therefore it can have a specific aperture attribute.
|
|
// Not yet in use.
|
|
// bool isPadOnBoardTechLayers = ( aPad->GetLayerSet() & LSET::AllBoardTechMask() ).any();
|
|
|
|
metadata.SetCmpReference(aPad.GetParentFootprint()!.GetReference());
|
|
|
|
if (plotOnCopperLayer) {
|
|
metadata.SetNetAttribType(
|
|
GBR_NETINFO_TYPE.GBR_NETINFO_PAD |
|
|
GBR_NETINFO_TYPE.GBR_NETINFO_NET |
|
|
GBR_NETINFO_TYPE.GBR_NETINFO_CMP,
|
|
);
|
|
metadata.SetCopper(true);
|
|
|
|
// Gives a default attribute, for instance for pads used as tracks in net ties:
|
|
// Connector pads and SMD pads are on external layers
|
|
// if on internal layers, they are certainly used as net tie
|
|
// and are similar to tracks: just conductor items
|
|
metadata.SetApertureAttrib(GBR_APERTURE_ATTRIB.GBR_APERTURE_ATTRIB_CONDUCTOR);
|
|
|
|
const useUTF8 = false;
|
|
const useQuoting = false;
|
|
metadata.SetPadName(aPad.GetNumber(), useUTF8, useQuoting);
|
|
|
|
if (aPad.GetNumber() !== '')
|
|
metadata.SetPadPinFunction(aPad.GetPinFunction(), useUTF8, useQuoting);
|
|
|
|
metadata.SetNetName(aPad.GetNetname());
|
|
|
|
// Some pads are mechanical pads ( through hole or smd )
|
|
// when this is the case, they have no pad name and/or are not plated.
|
|
// In this case gerber files have slightly different attributes.
|
|
if (aPad.GetAttribute() === PAD_ATTRIB.NPTH || aPad.GetNumber() === '')
|
|
metadata.m_NetlistMetadata.m_NotInNet = true;
|
|
|
|
if (!plotOnExternalCopperLayer) {
|
|
// the .P object attribute (GBR_NETLIST_METADATA::GBR_NETINFO_PAD)
|
|
// is used on outer layers, unless the component is embedded
|
|
// or a "etched" component (fp only drawn, not a physical component)
|
|
// Currently, Pcbnew does not handle embedded component, so we disable the .P
|
|
// attribute on internal layers
|
|
// Note the Gerber doc is not really clear about through holes pads about the .P
|
|
metadata.SetNetAttribType(
|
|
GBR_NETINFO_TYPE.GBR_NETINFO_NET | GBR_NETINFO_TYPE.GBR_NETINFO_CMP,
|
|
);
|
|
}
|
|
|
|
// Some attributes are reserved to the external copper layers:
|
|
// GBR_APERTURE_ATTRIB_CONNECTORPAD and GBR_APERTURE_ATTRIB_SMDPAD_CUDEF
|
|
// for instance.
|
|
// Pad with type PAD_ATTRIB::CONN or PAD_ATTRIB::SMD that is not on outer layer
|
|
// has its aperture attribute set to GBR_APERTURE_ATTRIB_CONDUCTOR
|
|
switch (aPad.GetAttribute()) {
|
|
case PAD_ATTRIB.NPTH: // Mechanical pad through hole
|
|
metadata.SetApertureAttrib(GBR_APERTURE_ATTRIB.GBR_APERTURE_ATTRIB_WASHERPAD);
|
|
break;
|
|
|
|
case PAD_ATTRIB.PTH: // Pad through hole, a hole is also expected
|
|
metadata.SetApertureAttrib(GBR_APERTURE_ATTRIB.GBR_APERTURE_ATTRIB_COMPONENTPAD);
|
|
break;
|
|
|
|
case PAD_ATTRIB.CONN: // Connector pads, no solder paste but with solder mask.
|
|
if (plotOnExternalCopperLayer)
|
|
metadata.SetApertureAttrib(GBR_APERTURE_ATTRIB.GBR_APERTURE_ATTRIB_CONNECTORPAD);
|
|
break;
|
|
|
|
case PAD_ATTRIB.SMD: // SMD pads (on external copper layer only)
|
|
// with solder paste and mask
|
|
if (plotOnExternalCopperLayer)
|
|
metadata.SetApertureAttrib(GBR_APERTURE_ATTRIB.GBR_APERTURE_ATTRIB_SMDPAD_CUDEF);
|
|
break;
|
|
}
|
|
|
|
// Fabrication properties can have specific GBR_APERTURE_METADATA options
|
|
// that replace previous aperture attribute:
|
|
switch (aPad.GetProperty()) {
|
|
case PAD_PROP.BGA: // Only applicable to outer layers
|
|
if (plotOnExternalCopperLayer)
|
|
metadata.SetApertureAttrib(GBR_APERTURE_ATTRIB.GBR_APERTURE_ATTRIB_BGAPAD_CUDEF);
|
|
break;
|
|
|
|
case PAD_PROP.FIDUCIAL_GLBL:
|
|
metadata.SetApertureAttrib(GBR_APERTURE_ATTRIB.GBR_APERTURE_ATTRIB_FIDUCIAL_GLBL);
|
|
break;
|
|
|
|
case PAD_PROP.FIDUCIAL_LOCAL:
|
|
metadata.SetApertureAttrib(GBR_APERTURE_ATTRIB.GBR_APERTURE_ATTRIB_FIDUCIAL_LOCAL);
|
|
break;
|
|
|
|
case PAD_PROP.TESTPOINT: // Only applicable to outer layers
|
|
if (plotOnExternalCopperLayer)
|
|
metadata.SetApertureAttrib(GBR_APERTURE_ATTRIB.GBR_APERTURE_ATTRIB_TESTPOINT);
|
|
break;
|
|
|
|
case PAD_PROP.HEATSINK:
|
|
metadata.SetApertureAttrib(GBR_APERTURE_ATTRIB.GBR_APERTURE_ATTRIB_HEATSINKPAD);
|
|
break;
|
|
|
|
case PAD_PROP.CASTELLATED:
|
|
metadata.SetApertureAttrib(GBR_APERTURE_ATTRIB.GBR_APERTURE_ATTRIB_CASTELLATEDPAD);
|
|
break;
|
|
|
|
default: // PRESSFIT (used only in drill files), NONE, MECHANICAL
|
|
break;
|
|
}
|
|
|
|
// Ensure NPTH pads have *always* the GBR_APERTURE_ATTRIB_WASHERPAD attribute
|
|
if (aPad.GetAttribute() === PAD_ATTRIB.NPTH)
|
|
metadata.SetApertureAttrib(GBR_APERTURE_ATTRIB.GBR_APERTURE_ATTRIB_WASHERPAD);
|
|
} else {
|
|
metadata.SetNetAttribType(GBR_NETINFO_TYPE.GBR_NETINFO_CMP);
|
|
}
|
|
|
|
// Set plot color (change WHITE to LIGHTGRAY because
|
|
// the white items are not seen on a white paper or screen
|
|
this.m_plotter.SetColor(!colorEquals(aColor, WHITE) ? aColor : LIGHTGRAY);
|
|
|
|
if (aSketchMode) {
|
|
switch (aPad.GetShape(aLayer)) {
|
|
case PAD_SHAPE.CIRCLE:
|
|
this.m_plotter.ThickCircle(
|
|
shape_pos,
|
|
aPad.GetSize(aLayer).x,
|
|
this.GetSketchPadLineWidth(),
|
|
null,
|
|
);
|
|
break;
|
|
|
|
case PAD_SHAPE.OVAL:
|
|
this.m_plotter.ThickOval(
|
|
shape_pos,
|
|
aPad.GetSize(aLayer),
|
|
aPad.GetOrientation(),
|
|
this.GetSketchPadLineWidth(),
|
|
null,
|
|
);
|
|
break;
|
|
|
|
default: {
|
|
// RECTANGLE, ROUNDRECT, TRAPEZOID, CHAMFERED_RECT, CUSTOM
|
|
const outline = new SHAPE_POLY_SET();
|
|
aPad.TransformShapeToPolygon(
|
|
outline,
|
|
aLayer,
|
|
0,
|
|
this.m_plotter.GetPlotterArcHighDef(),
|
|
ERROR_LOC.ERROR_INSIDE,
|
|
false,
|
|
);
|
|
|
|
this.m_plotter.ThickPoly(outline, this.GetSketchPadLineWidth(), null);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
switch (aPad.GetShape(aLayer)) {
|
|
case PAD_SHAPE.CIRCLE:
|
|
this.m_plotter.FlashPadCircle(shape_pos, aPad.GetSize(aLayer).x, metadata);
|
|
break;
|
|
|
|
case PAD_SHAPE.OVAL:
|
|
this.m_plotter.FlashPadOval(
|
|
shape_pos,
|
|
aPad.GetSize(aLayer),
|
|
aPad.GetOrientation(),
|
|
metadata,
|
|
);
|
|
break;
|
|
|
|
case PAD_SHAPE.RECTANGLE:
|
|
this.m_plotter.FlashPadRect(
|
|
shape_pos,
|
|
aPad.GetSize(aLayer),
|
|
aPad.GetOrientation(),
|
|
metadata,
|
|
);
|
|
break;
|
|
|
|
case PAD_SHAPE.ROUNDRECT:
|
|
this.m_plotter.FlashPadRoundRect(
|
|
shape_pos,
|
|
aPad.GetSize(aLayer),
|
|
aPad.GetRoundRectCornerRadius(aLayer),
|
|
aPad.GetOrientation(),
|
|
metadata,
|
|
);
|
|
break;
|
|
|
|
case PAD_SHAPE.TRAPEZOID: {
|
|
// Build the pad polygon in coordinates relative to the pad
|
|
// (i.e. for a pad at pos 0,0, rot 0.0). Needed to use aperture macros,
|
|
// to be able to create a pattern common to all trapezoid pads having the same shape
|
|
// Order is lower left, lower right, upper right, upper left.
|
|
const size = aPad.GetSize(aLayer);
|
|
const delta = aPad.GetDelta(aLayer);
|
|
const half_size = { x: Math.trunc(size.x / 2), y: Math.trunc(size.y / 2) };
|
|
const trap_delta = { x: Math.trunc(delta.x / 2), y: Math.trunc(delta.y / 2) };
|
|
|
|
const coord: VECTOR2I[] = [
|
|
{ x: -half_size.x - trap_delta.y, y: half_size.y + trap_delta.x },
|
|
{ x: half_size.x + trap_delta.y, y: half_size.y - trap_delta.x },
|
|
{ x: half_size.x - trap_delta.y, y: -half_size.y + trap_delta.x },
|
|
{ x: -half_size.x + trap_delta.y, y: -half_size.y - trap_delta.x },
|
|
];
|
|
|
|
this.m_plotter.FlashPadTrapez(shape_pos, coord, aPad.GetOrientation(), metadata);
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
const gerberPlotter = this.gerber();
|
|
|
|
if (aPad.GetShape(aLayer) === PAD_SHAPE.CHAMFERED_RECT && gerberPlotter) {
|
|
gerberPlotter.FlashPadChamferRoundRect(
|
|
shape_pos,
|
|
aPad.GetSize(aLayer),
|
|
aPad.GetRoundRectCornerRadius(aLayer),
|
|
aPad.GetChamferRectRatio(aLayer),
|
|
aPad.GetChamferPositions(aLayer),
|
|
aPad.GetOrientation(),
|
|
metadata,
|
|
);
|
|
break;
|
|
}
|
|
|
|
// KI_FALLTHROUGH: CUSTOM, and CHAMFERED_RECT on a non-Gerber plotter
|
|
const polygons = aPad.GetEffectivePolygon(aLayer, ERROR_LOC.ERROR_INSIDE);
|
|
|
|
if (polygons.OutlineCount())
|
|
this.m_plotter.FlashPadCustom(
|
|
shape_pos,
|
|
aPad.GetSize(aLayer),
|
|
aPad.GetOrientation(),
|
|
polygons,
|
|
metadata,
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
PlotFootprintTextItems(aFootprint: FOOTPRINT): void {
|
|
if (!this.GetPlotFPText()) return;
|
|
|
|
const variantName = this.m_board ? this.m_board.GetCurrentVariant() : '';
|
|
const dnp = aFootprint.GetDNPForVariant(variantName);
|
|
|
|
const reference = aFootprint.Reference();
|
|
const refLayer = reference.GetLayer();
|
|
|
|
// Reference and value have special controls for forcing their plotting
|
|
if (
|
|
this.GetPlotReference() &&
|
|
this.m_layerMask.test(refLayer) &&
|
|
reference.IsVisible() &&
|
|
!(dnp && this.hideDNPItems(refLayer))
|
|
) {
|
|
this.PlotText(
|
|
reference,
|
|
refLayer,
|
|
reference.IsKnockout(),
|
|
reference.GetFontMetrics(),
|
|
dnp && this.crossoutDNPItems(refLayer),
|
|
);
|
|
}
|
|
|
|
const value = aFootprint.Value();
|
|
const valueLayer = value.GetLayer();
|
|
|
|
if (
|
|
this.GetPlotValue() &&
|
|
this.m_layerMask.test(valueLayer) &&
|
|
value.IsVisible() &&
|
|
!(dnp && this.hideDNPItems(valueLayer))
|
|
) {
|
|
this.PlotText(value, valueLayer, value.IsKnockout(), value.GetFontMetrics(), false);
|
|
}
|
|
|
|
const texts: PCB_TEXT[] = [];
|
|
|
|
// Skip the reference and value texts that are handled specially
|
|
for (const field of aFootprint.GetFields()) {
|
|
if (!field) continue;
|
|
|
|
if (field.IsReference() || field.IsValue()) continue;
|
|
|
|
if (field.IsVisible()) texts.push(field);
|
|
}
|
|
|
|
for (const item of aFootprint.GraphicalItems()) {
|
|
// dynamic_cast<PCB_TEXT*>: PCB_TEXT and everything derived from it
|
|
if (item.Type() === KICAD_T.PCB_TEXT_T || item.Type() === KICAD_T.PCB_FIELD_T)
|
|
texts.push(item as unknown as PCB_TEXT);
|
|
}
|
|
|
|
for (const text of texts) {
|
|
const textLayer = text.GetLayer();
|
|
let strikeout = false;
|
|
|
|
if (textLayer === PCB_LAYER_ID.Edge_Cuts || textLayer >= PCB_LAYER_ID.PCB_LAYER_ID_COUNT)
|
|
continue;
|
|
|
|
if (dnp && this.hideDNPItems(textLayer)) continue;
|
|
|
|
if (!this.m_layerMask.test(textLayer) || aFootprint.GetPrivateLayers().test(textLayer))
|
|
continue;
|
|
|
|
if (text.GetText() === '${REFERENCE}') {
|
|
if (!this.GetPlotReference()) continue;
|
|
|
|
strikeout = dnp && this.crossoutDNPItems(textLayer);
|
|
}
|
|
|
|
if (text.GetText() === '${VALUE}') {
|
|
if (!this.GetPlotValue()) continue;
|
|
}
|
|
|
|
this.PlotText(text, textLayer, text.IsKnockout(), text.GetFontMetrics(), strikeout);
|
|
}
|
|
}
|
|
|
|
PlotBoardGraphicItem(item: BOARD_ITEM): void {
|
|
switch (item.Type()) {
|
|
case KICAD_T.PCB_SHAPE_T:
|
|
this.PlotShape(item as PCB_SHAPE);
|
|
break;
|
|
|
|
case KICAD_T.PCB_TEXT_T: {
|
|
const text = item as unknown as PCB_TEXT;
|
|
this.PlotText(text, text.GetLayer(), text.IsKnockout(), text.GetFontMetrics());
|
|
break;
|
|
}
|
|
|
|
case KICAD_T.PCB_TEXTBOX_T: {
|
|
this.m_plotter.SetTextMode(PLOT_TEXT_MODE.STROKE);
|
|
|
|
const textbox = item as unknown as PCB_TEXTBOX;
|
|
this.PlotText(textbox, textbox.GetLayer(), textbox.IsKnockout(), textbox.GetFontMetrics());
|
|
|
|
if (textbox.IsBorderEnabled()) this.PlotShape(textbox);
|
|
|
|
this.m_plotter.SetTextMode(this.GetTextMode());
|
|
break;
|
|
}
|
|
|
|
case KICAD_T.PCB_BARCODE_T:
|
|
this.PlotBarCode(item as unknown as PCB_BARCODE);
|
|
break;
|
|
|
|
case KICAD_T.PCB_TABLE_T: {
|
|
const table = item as unknown as PCB_TABLE;
|
|
|
|
this.m_plotter.SetTextMode(PLOT_TEXT_MODE.STROKE);
|
|
|
|
for (const cell of table.GetCells())
|
|
this.PlotText(cell, cell.GetLayer(), cell.IsKnockout(), cell.GetFontMetrics());
|
|
|
|
this.PlotTableBorders(table);
|
|
|
|
this.m_plotter.SetTextMode(this.GetTextMode());
|
|
break;
|
|
}
|
|
|
|
case KICAD_T.PCB_DIM_ALIGNED_T:
|
|
case KICAD_T.PCB_DIM_CENTER_T:
|
|
case KICAD_T.PCB_DIM_RADIAL_T:
|
|
case KICAD_T.PCB_DIM_ORTHOGONAL_T:
|
|
case KICAD_T.PCB_DIM_LEADER_T:
|
|
this.m_plotter.SetTextMode(PLOT_TEXT_MODE.STROKE);
|
|
|
|
this.PlotDimension(item as unknown as PCB_DIMENSION_BASE);
|
|
|
|
this.m_plotter.SetTextMode(this.GetTextMode());
|
|
break;
|
|
|
|
case KICAD_T.PCB_TARGET_T:
|
|
this.PlotPcbTarget(item as unknown as PCB_TARGET);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
PlotDimension(aDim: PCB_DIMENSION_BASE): void {
|
|
if (!this.m_layerMask.test(aDim.GetLayer())) return;
|
|
|
|
const color = this.getColor(aDim.GetLayer());
|
|
|
|
// Set plot color (change WHITE to LIGHTGRAY because
|
|
// the white items are not seen on a white paper or screen
|
|
this.m_plotter.SetColor(!colorEquals(color, WHITE) ? color : LIGHTGRAY);
|
|
|
|
this.PlotText(aDim, aDim.GetLayer(), false, aDim.GetFontMetrics());
|
|
|
|
const temp_item = new PCB_SHAPE(null);
|
|
|
|
temp_item.SetStroke(new STROKE_PARAMS(aDim.GetLineThickness(), LINE_STYLE.SOLID));
|
|
temp_item.SetLayer(aDim.GetLayer());
|
|
|
|
for (const shape of aDim.GetShapes()) {
|
|
switch (shape.Type()) {
|
|
case SHAPE_TYPE.SH_SEGMENT: {
|
|
const seg = (shape as SHAPE_SEGMENT).GetSeg();
|
|
|
|
temp_item.SetShape(SHAPE_T.SEGMENT);
|
|
temp_item.SetStart(seg.A);
|
|
temp_item.SetEnd(seg.B);
|
|
|
|
this.PlotShape(temp_item);
|
|
break;
|
|
}
|
|
|
|
case SHAPE_TYPE.SH_CIRCLE: {
|
|
const start = shape.Centre();
|
|
const radius = (shape as SHAPE_CIRCLE).GetRadius();
|
|
|
|
temp_item.SetShape(SHAPE_T.CIRCLE);
|
|
temp_item.SetFilled(false);
|
|
temp_item.SetStart(start);
|
|
temp_item.SetEnd({ x: start.x + radius, y: start.y });
|
|
|
|
this.PlotShape(temp_item);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
PlotPcbTarget(aMire: PCB_TARGET): void {
|
|
if (!this.m_layerMask.test(aMire.GetLayer())) return;
|
|
|
|
this.m_plotter.SetColor(this.getColor(aMire.GetLayer()));
|
|
|
|
const temp_item = new PCB_SHAPE(null);
|
|
|
|
temp_item.SetShape(SHAPE_T.CIRCLE);
|
|
temp_item.SetFilled(false);
|
|
temp_item.SetStroke(new STROKE_PARAMS(aMire.GetWidth(), LINE_STYLE.SOLID));
|
|
temp_item.SetLayer(aMire.GetLayer());
|
|
temp_item.SetStart(aMire.GetPosition());
|
|
let radius = Math.trunc(aMire.GetSize() / 3);
|
|
|
|
if (aMire.GetShape())
|
|
// temp_item X
|
|
radius = Math.trunc(aMire.GetSize() / 2);
|
|
|
|
// Draw the circle
|
|
temp_item.SetEnd({ x: temp_item.GetStart().x + radius, y: temp_item.GetStart().y });
|
|
|
|
this.PlotShape(temp_item);
|
|
|
|
temp_item.SetShape(SHAPE_T.SEGMENT);
|
|
|
|
radius = Math.trunc(aMire.GetSize() / 2);
|
|
let dx1 = radius;
|
|
let dy1 = 0;
|
|
let dx2 = 0;
|
|
let dy2 = radius;
|
|
|
|
if (aMire.GetShape()) {
|
|
// Shape X
|
|
dx1 = dy1 = radius;
|
|
dx2 = dx1;
|
|
dy2 = -dy1;
|
|
}
|
|
|
|
const mirePos = aMire.GetPosition();
|
|
|
|
// Draw the X or + temp_item:
|
|
temp_item.SetStart({ x: mirePos.x - dx1, y: mirePos.y - dy1 });
|
|
temp_item.SetEnd({ x: mirePos.x + dx1, y: mirePos.y + dy1 });
|
|
this.PlotShape(temp_item);
|
|
|
|
temp_item.SetStart({ x: mirePos.x - dx2, y: mirePos.y - dy2 });
|
|
temp_item.SetEnd({ x: mirePos.x + dx2, y: mirePos.y + dy2 });
|
|
this.PlotShape(temp_item);
|
|
}
|
|
|
|
PlotFootprintGraphicItems(aFootprint: FOOTPRINT): void {
|
|
const variantName = this.m_board ? this.m_board.GetCurrentVariant() : '';
|
|
const dnp = aFootprint.GetDNPForVariant(variantName);
|
|
|
|
for (const item of aFootprint.GraphicalItems()) {
|
|
const itemLayer = item.GetLayer();
|
|
|
|
if (aFootprint.GetPrivateLayers().test(itemLayer)) continue;
|
|
|
|
if (dnp && this.hideDNPItems(itemLayer)) continue;
|
|
|
|
if (!this.m_layerMask.and(item.GetLayerSet()).any()) continue;
|
|
|
|
switch (item.Type()) {
|
|
case KICAD_T.PCB_SHAPE_T:
|
|
this.PlotShape(item as PCB_SHAPE);
|
|
break;
|
|
|
|
case KICAD_T.PCB_TEXTBOX_T: {
|
|
const textbox = item as unknown as PCB_TEXTBOX;
|
|
|
|
this.m_plotter.SetTextMode(PLOT_TEXT_MODE.STROKE);
|
|
|
|
this.PlotText(
|
|
textbox,
|
|
textbox.GetLayer(),
|
|
textbox.IsKnockout(),
|
|
textbox.GetFontMetrics(),
|
|
);
|
|
|
|
if (textbox.IsBorderEnabled()) this.PlotShape(textbox);
|
|
|
|
this.m_plotter.SetTextMode(this.GetTextMode());
|
|
break;
|
|
}
|
|
|
|
case KICAD_T.PCB_BARCODE_T:
|
|
this.PlotBarCode(item as unknown as PCB_BARCODE);
|
|
break;
|
|
|
|
case KICAD_T.PCB_TABLE_T: {
|
|
const table = item as unknown as PCB_TABLE;
|
|
|
|
this.m_plotter.SetTextMode(PLOT_TEXT_MODE.STROKE);
|
|
|
|
for (const cell of table.GetCells())
|
|
this.PlotText(cell, cell.GetLayer(), cell.IsKnockout(), cell.GetFontMetrics());
|
|
|
|
this.PlotTableBorders(table);
|
|
|
|
this.m_plotter.SetTextMode(this.GetTextMode());
|
|
break;
|
|
}
|
|
|
|
case KICAD_T.PCB_DIM_ALIGNED_T:
|
|
case KICAD_T.PCB_DIM_CENTER_T:
|
|
case KICAD_T.PCB_DIM_RADIAL_T:
|
|
case KICAD_T.PCB_DIM_ORTHOGONAL_T:
|
|
case KICAD_T.PCB_DIM_LEADER_T:
|
|
this.PlotDimension(item as unknown as PCB_DIMENSION_BASE);
|
|
break;
|
|
|
|
case KICAD_T.PCB_TEXT_T:
|
|
// Plotted in PlotFootprintTextItems()
|
|
break;
|
|
|
|
case KICAD_T.PCB_REFERENCE_IMAGE_T:
|
|
// Not plotted at all
|
|
break;
|
|
|
|
default:
|
|
// UNIMPLEMENTED_FOR( item->GetClass() )
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
PlotText(
|
|
aText: PLOTTED_TEXT,
|
|
aLayer: PCB_LAYER_ID,
|
|
aIsKnockout: boolean,
|
|
aFontMetrics: METRICS,
|
|
aStrikeout = false,
|
|
): void {
|
|
const maxError = this.m_board.GetDesignSettings().m_MaxError;
|
|
const font = aText.GetDrawFont(this.renderSettings());
|
|
const shownText = aText.GetShownText(true);
|
|
|
|
// A knockout text box plots its box even with no text (10.0.6).
|
|
const asItem = aText as unknown as { Type?(): KICAD_T };
|
|
const knockoutBox = aIsKnockout && asItem.Type?.() === KICAD_T.PCB_TEXTBOX_T;
|
|
|
|
if (shownText === '' && !knockoutBox) return;
|
|
|
|
if (!this.m_layerMask.test(aLayer)) return;
|
|
|
|
const gbr_metadata = new GBR_METADATA();
|
|
|
|
if (IsCopperLayer(aLayer))
|
|
gbr_metadata.SetApertureAttrib(GBR_APERTURE_ATTRIB.GBR_APERTURE_ATTRIB_NONCONDUCTOR);
|
|
|
|
const color = this.getColor(aLayer);
|
|
this.m_plotter.SetColor(color);
|
|
|
|
const pos = aText.GetTextPos();
|
|
|
|
const attrs = Object.assign(new TEXT_ATTRIBUTES(), aText.GetAttributes());
|
|
attrs.m_StrokeWidth = aText.GetEffectiveTextPenWidth();
|
|
attrs.m_Angle = aText.GetDrawRotation();
|
|
attrs.m_Multiline = false;
|
|
|
|
this.m_plotter.SetCurrentLineWidth(attrs.m_StrokeWidth);
|
|
|
|
const strikeoutText = (text: PCB_TEXT): void => {
|
|
const textPoly = new SHAPE_POLY_SET();
|
|
|
|
text.TransformTextToPolySet(textPoly, 0, ARC_LOW_DEF, ERROR_LOC.ERROR_INSIDE);
|
|
textPoly.Rotate(text.GetDrawRotation().negate(), text.GetDrawPos());
|
|
|
|
const rect = textPoly.BBox();
|
|
let start = {
|
|
x: rect.GetLeft() - attrs.m_StrokeWidth,
|
|
y: Math.trunc((rect.GetTop() + rect.GetBottom()) / 2),
|
|
};
|
|
let end = {
|
|
x: rect.GetRight() + attrs.m_StrokeWidth,
|
|
y: Math.trunc((rect.GetTop() + rect.GetBottom()) / 2),
|
|
};
|
|
|
|
start = RotatePoint(start, text.GetDrawPos(), text.GetDrawRotation());
|
|
end = RotatePoint(end, text.GetDrawPos(), text.GetDrawRotation());
|
|
|
|
this.m_plotter.ThickSegment(start, end, attrs.m_StrokeWidth, this.metadata(gbr_metadata));
|
|
};
|
|
|
|
if (aIsKnockout) {
|
|
const finalPoly = new SHAPE_POLY_SET();
|
|
const withPolys = aText as unknown as {
|
|
TransformTextToPolySet?(
|
|
aBuffer: SHAPE_POLY_SET,
|
|
aClearance: number,
|
|
aMaxError: number,
|
|
aErrorLoc: ERROR_LOC,
|
|
): void;
|
|
};
|
|
|
|
withPolys.TransformTextToPolySet?.(finalPoly, 0, maxError, ERROR_LOC.ERROR_INSIDE);
|
|
|
|
finalPoly.Fracture();
|
|
|
|
for (let ii = 0; ii < finalPoly.OutlineCount(); ++ii)
|
|
this.m_plotter.PlotPolyLineChain(
|
|
finalPoly.Outline(ii),
|
|
FILL_T.FILLED_SHAPE,
|
|
0,
|
|
this.metadata(gbr_metadata),
|
|
);
|
|
} else if (font.IsOutline() && !this.m_board.GetEmbeddedFiles().GetAreFontsEmbedded()) {
|
|
const callback_gal = new CALLBACK_GAL(
|
|
// Stroke callback
|
|
(aPt1, aPt2) => {
|
|
this.m_plotter.ThickSegment(aPt1, aPt2, attrs.m_StrokeWidth, this.metadata(gbr_metadata));
|
|
},
|
|
// Polygon callback
|
|
(aPoly: SHAPE_LINE_CHAIN) => {
|
|
this.m_plotter.PlotPolyLineChain(
|
|
aPoly,
|
|
FILL_T.FILLED_SHAPE,
|
|
0,
|
|
this.metadata(gbr_metadata),
|
|
);
|
|
},
|
|
);
|
|
|
|
callback_gal.DrawGlyphs(aText.GetRenderCache(font, shownText) ?? []);
|
|
} else if (aText.IsMultilineAllowed()) {
|
|
const positions: VECTOR2I[] = [];
|
|
const strings_list = wxStringSplit(shownText, '\n');
|
|
|
|
aText.GetLinePositions(this.renderSettings(), positions, strings_list.length);
|
|
|
|
for (let ii = 0; ii < strings_list.length; ii++) {
|
|
this.m_plotter.PlotText(
|
|
positions[ii]!,
|
|
color,
|
|
strings_list[ii]!,
|
|
attrs,
|
|
plotterFont(font, aFontMetrics),
|
|
aFontMetrics,
|
|
this.metadata(gbr_metadata),
|
|
);
|
|
}
|
|
|
|
if (aStrikeout && strings_list.length === 1) strikeoutText(aText as unknown as PCB_TEXT);
|
|
} else {
|
|
this.m_plotter.PlotText(
|
|
pos,
|
|
color,
|
|
shownText,
|
|
attrs,
|
|
plotterFont(font, aFontMetrics),
|
|
aFontMetrics,
|
|
this.metadata(gbr_metadata),
|
|
);
|
|
|
|
if (aStrikeout) strikeoutText(aText as unknown as PCB_TEXT);
|
|
}
|
|
}
|
|
|
|
PlotZone(aZone: ZONE, aLayer: PCB_LAYER_ID, aPolysList: SHAPE_POLY_SET): void {
|
|
if (aPolysList.IsEmpty()) return;
|
|
|
|
const gbr_metadata = new GBR_METADATA();
|
|
|
|
if (aZone.IsOnCopperLayer()) {
|
|
gbr_metadata.SetNetName(aZone.GetNetname());
|
|
gbr_metadata.SetCopper(true);
|
|
|
|
// Zones with no net name can exist.
|
|
// they are not used to connect items, so the aperture attribute cannot
|
|
// be set as conductor
|
|
if (aZone.GetNetname() === '') {
|
|
gbr_metadata.SetApertureAttrib(GBR_APERTURE_ATTRIB.GBR_APERTURE_ATTRIB_NONCONDUCTOR);
|
|
} else {
|
|
gbr_metadata.SetApertureAttrib(GBR_APERTURE_ATTRIB.GBR_APERTURE_ATTRIB_CONDUCTOR);
|
|
gbr_metadata.SetNetAttribType(GBR_NETINFO_TYPE.GBR_NETINFO_NET);
|
|
}
|
|
}
|
|
|
|
this.m_plotter.SetColor(this.getColor(aLayer));
|
|
|
|
this.m_plotter.StartBlock(null); // Clean current object attributes
|
|
|
|
/*
|
|
* In non filled mode the outline is plotted, but not the filling items
|
|
*/
|
|
|
|
for (let idx = 0; idx < aPolysList.OutlineCount(); ++idx) {
|
|
const outline = aPolysList.Outline(idx);
|
|
|
|
// Plot the current filled area (as region for Gerber plotter to manage attributes)
|
|
const gerberPlotter = this.gerber();
|
|
|
|
if (gerberPlotter) {
|
|
gerberPlotter.PlotGerberRegionLineChain(outline, gbr_metadata);
|
|
} else if (this.m_plotter.GetPlotterType() === PLOT_FORMAT.DXF) {
|
|
if (this.GetDXFPlotMode() === DXF_OUTLINE_MODE.FILLED)
|
|
this.m_plotter.PlotPolyLineChain(
|
|
outline,
|
|
FILL_T.FILLED_SHAPE,
|
|
0,
|
|
this.metadata(gbr_metadata),
|
|
);
|
|
} else {
|
|
this.m_plotter.PlotPolyLineChain(
|
|
outline,
|
|
FILL_T.FILLED_SHAPE,
|
|
0,
|
|
this.metadata(gbr_metadata),
|
|
);
|
|
}
|
|
}
|
|
|
|
this.m_plotter.EndBlock(null); // Clear object attributes
|
|
}
|
|
|
|
PlotShape(aShape: PCB_SHAPE): void {
|
|
if (!this.m_layerMask.and(aShape.GetLayerSet()).any()) return;
|
|
|
|
let thickness = aShape.GetWidth();
|
|
const margin = { value: thickness }; // unclamped thickness (can be negative)
|
|
const lineStyle = aShape.GetStroke().GetLineStyle();
|
|
const onCopperLayer = LSET.AllCuMask().and(this.m_layerMask).any();
|
|
const onSolderMaskLayer = new LSET([PCB_LAYER_ID.F_Mask, PCB_LAYER_ID.B_Mask])
|
|
.and(this.m_layerMask)
|
|
.any();
|
|
let isSolidFill = aShape.IsSolidFill();
|
|
let isHatchedFill = aShape.IsHatchedFill();
|
|
|
|
if (onSolderMaskLayer && aShape.HasSolderMask() && IsExternalCopperLayer(aShape.GetLayer())) {
|
|
margin.value += 2 * aShape.GetSolderMaskExpansion();
|
|
thickness = Math.max(margin.value, 0);
|
|
|
|
if (isHatchedFill) {
|
|
isSolidFill = true;
|
|
isHatchedFill = false;
|
|
}
|
|
}
|
|
|
|
this.m_plotter.SetColor(this.getColor(aShape.GetLayer()));
|
|
|
|
const parentFP = aShape.GetParentFootprint();
|
|
const gbr_metadata = new GBR_METADATA();
|
|
const variantName = this.m_board ? this.m_board.GetCurrentVariant() : '';
|
|
const parentDnp = parentFP ? parentFP.GetDNPForVariant(variantName) : false;
|
|
|
|
if (parentFP) {
|
|
gbr_metadata.SetCmpReference(parentFP.GetReference());
|
|
gbr_metadata.SetNetAttribType(GBR_NETINFO_TYPE.GBR_NETINFO_CMP);
|
|
}
|
|
|
|
if (parentFP && parentDnp && this.GetSketchDNPFPsOnFabLayers()) {
|
|
if (aShape.GetLayer() === PCB_LAYER_ID.F_Fab || aShape.GetLayer() === PCB_LAYER_ID.B_Fab) {
|
|
thickness = this.GetSketchPadLineWidth();
|
|
isSolidFill = false;
|
|
isHatchedFill = false;
|
|
}
|
|
}
|
|
|
|
if (aShape.GetLayer() === PCB_LAYER_ID.Edge_Cuts) {
|
|
gbr_metadata.SetApertureAttrib(GBR_APERTURE_ATTRIB.GBR_APERTURE_ATTRIB_EDGECUT);
|
|
} else if (onCopperLayer) {
|
|
if (parentFP) {
|
|
gbr_metadata.SetApertureAttrib(GBR_APERTURE_ATTRIB.GBR_APERTURE_ATTRIB_ETCHEDCMP);
|
|
gbr_metadata.SetCopper(true);
|
|
} else if (aShape.GetNetCode() > 0) {
|
|
gbr_metadata.SetCopper(true);
|
|
gbr_metadata.SetApertureAttrib(GBR_APERTURE_ATTRIB.GBR_APERTURE_ATTRIB_CONDUCTOR);
|
|
gbr_metadata.SetNetAttribType(GBR_NETINFO_TYPE.GBR_NETINFO_NET);
|
|
gbr_metadata.SetNetName(aShape.GetNetname());
|
|
} else {
|
|
// Graphic items (PCB_SHAPE, TEXT) having no net have the NonConductor attribute
|
|
// Graphic items having a net have the Conductor attribute, but are not (yet?)
|
|
// supported in Pcbnew
|
|
gbr_metadata.SetApertureAttrib(GBR_APERTURE_ATTRIB.GBR_APERTURE_ATTRIB_NONCONDUCTOR);
|
|
}
|
|
}
|
|
|
|
const md = this.metadata(gbr_metadata);
|
|
const gerberPlotter = this.gerber();
|
|
|
|
if (lineStyle <= LINE_STYLE.SOLID /* FIRST_TYPE */) {
|
|
switch (aShape.GetShape()) {
|
|
case SHAPE_T.SEGMENT:
|
|
this.m_plotter.ThickSegment(aShape.GetStart(), aShape.GetEnd(), thickness, md);
|
|
break;
|
|
|
|
case SHAPE_T.CIRCLE:
|
|
if (isSolidFill) {
|
|
let diameter = aShape.GetRadius() * 2 + thickness;
|
|
|
|
if (margin.value < 0) {
|
|
diameter += margin.value;
|
|
diameter = Math.max(diameter, 0);
|
|
}
|
|
|
|
this.m_plotter.FilledCircle(aShape.GetStart(), diameter, md);
|
|
} else {
|
|
this.m_plotter.ThickCircle(aShape.GetStart(), aShape.GetRadius() * 2, thickness, md);
|
|
}
|
|
|
|
break;
|
|
|
|
case SHAPE_T.ARC:
|
|
// when startAngle == endAngle ThickArc() doesn't know whether it's 0 deg and 360 deg
|
|
// but it is a circle
|
|
if (Math.abs(aShape.GetArcAngle().AsDegrees()) === 360.0) {
|
|
this.m_plotter.ThickCircle(aShape.GetCenter(), aShape.GetRadius() * 2, thickness, md);
|
|
} else {
|
|
this.m_plotter.ThickArcShape(aShape, md, thickness);
|
|
}
|
|
|
|
break;
|
|
|
|
case SHAPE_T.BEZIER:
|
|
this.m_plotter.BezierCurve(
|
|
aShape.GetStart(),
|
|
aShape.GetBezierC1(),
|
|
aShape.GetBezierC2(),
|
|
aShape.GetEnd(),
|
|
0,
|
|
thickness,
|
|
);
|
|
break;
|
|
|
|
case SHAPE_T.POLY:
|
|
if (aShape.IsPolyShapeValid()) {
|
|
if (
|
|
this.m_plotter.GetPlotterType() === PLOT_FORMAT.DXF &&
|
|
this.GetDXFPlotMode() === DXF_OUTLINE_MODE.SKETCH
|
|
) {
|
|
this.m_plotter.ThickPoly(aShape.GetPolyShape(), thickness, md);
|
|
} else {
|
|
this.m_plotter.SetCurrentLineWidth(thickness, gbr_metadata);
|
|
|
|
const origPoly = aShape.GetPolyShape();
|
|
|
|
// Stroke the unfractured outline so degenerate near-zero-width
|
|
// spikes (which Fracture() collapses but the editor still draws as
|
|
// thick lines) are preserved in the plot output (issue #24143).
|
|
if (thickness > 0) {
|
|
for (let jj = 0; jj < origPoly.OutlineCount(); ++jj) {
|
|
this.m_plotter.PlotPolyLineChain(
|
|
origPoly.COutline(jj),
|
|
FILL_T.NO_FILL,
|
|
thickness,
|
|
md,
|
|
);
|
|
}
|
|
}
|
|
|
|
if (!isSolidFill) break;
|
|
|
|
// Fracture before plotting the fill to avoid invalid gerber regions
|
|
// from self-intersecting or overlapping outlines.
|
|
const tmpPoly = origPoly.CloneDropTriangulation();
|
|
tmpPoly.Fracture();
|
|
|
|
if (margin.value < 0)
|
|
tmpPoly.Inflate(
|
|
Math.trunc(margin.value / 2),
|
|
CornerStrategy.ROUND_ALL_CORNERS,
|
|
aShape.GetMaxError(),
|
|
);
|
|
|
|
for (let jj = 0; jj < tmpPoly.OutlineCount(); ++jj) {
|
|
const poly = tmpPoly.Outline(jj);
|
|
poly.SetClosed(true);
|
|
|
|
// Width 0; the stroke was already plotted from the unfractured outline.
|
|
if (gerberPlotter) {
|
|
gerberPlotter.PlotPolyAsRegion(poly, FILL_T.FILLED_SHAPE, 0, gbr_metadata);
|
|
} else {
|
|
this.m_plotter.PlotPolyLineChain(poly, FILL_T.FILLED_SHAPE, 0, md);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case SHAPE_T.RECTANGLE: {
|
|
let radius = aShape.GetCornerRadius();
|
|
|
|
if (
|
|
radius === 0 &&
|
|
this.m_plotter.GetPlotterType() === PLOT_FORMAT.DXF &&
|
|
this.GetDXFPlotMode() === DXF_OUTLINE_MODE.SKETCH
|
|
) {
|
|
const pts = aShape.GetRectCorners();
|
|
this.m_plotter.ThickRect(pts[0]!, pts[2]!, thickness, md);
|
|
} else {
|
|
const box = new BOX2I(aShape.GetStart(), {
|
|
x: aShape.GetEnd().x - aShape.GetStart().x,
|
|
y: aShape.GetEnd().y - aShape.GetStart().y,
|
|
});
|
|
box.Normalize();
|
|
|
|
if (margin.value < 0) {
|
|
box.Inflate(margin.value);
|
|
radius += margin.value;
|
|
}
|
|
|
|
const rect = new SHAPE_RECT(box);
|
|
rect.SetRadius(radius);
|
|
|
|
const outline = rect.Outline();
|
|
const poly = new SHAPE_POLY_SET(outline);
|
|
|
|
const fill_mode = isSolidFill ? FILL_T.FILLED_SHAPE : FILL_T.NO_FILL;
|
|
|
|
if (poly.OutlineCount() > 0) {
|
|
if (gerberPlotter) {
|
|
gerberPlotter.PlotPolyAsRegion(
|
|
poly.COutline(0),
|
|
fill_mode,
|
|
thickness,
|
|
gbr_metadata,
|
|
);
|
|
} else {
|
|
// TODO: PlotPoly needs to handle arcs...
|
|
this.m_plotter.PlotPolyLineChain(poly.COutline(0), fill_mode, thickness, md);
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
// UNIMPLEMENTED_FOR( aShape->SHAPE_T_asString() )
|
|
break;
|
|
}
|
|
} else {
|
|
const shapes = aShape.MakeEffectiveShapesForStroking();
|
|
const renderSettings = this.m_plotter.RenderSettings();
|
|
|
|
for (const shape of shapes) {
|
|
STROKE_PARAMS.Stroke(shape, lineStyle, aShape.GetWidth(), renderSettings!, (a, b) => {
|
|
this.m_plotter.ThickSegment(a, b, thickness, md);
|
|
});
|
|
}
|
|
}
|
|
|
|
if (isHatchedFill) {
|
|
for (let ii = 0; ii < aShape.GetHatching().OutlineCount(); ++ii) {
|
|
if (gerberPlotter) {
|
|
gerberPlotter.PlotPolyAsRegion(
|
|
aShape.GetHatching().Outline(ii),
|
|
FILL_T.FILLED_SHAPE,
|
|
0,
|
|
gbr_metadata,
|
|
);
|
|
} else {
|
|
this.m_plotter.PlotPolyLineChain(
|
|
aShape.GetHatching().Outline(ii),
|
|
FILL_T.FILLED_SHAPE,
|
|
0,
|
|
md,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
PlotBarCode(aBarCode: PCB_BARCODE): void {
|
|
if (!this.m_layerMask.test(aBarCode.GetLayer())) return;
|
|
|
|
// To avoid duplicate code, build a PCB_SHAPE to plot the polygon shape
|
|
const dummy = new PCB_SHAPE(aBarCode.GetParent(), SHAPE_T.POLY);
|
|
dummy.SetLayer(aBarCode.GetLayer());
|
|
dummy.SetFillMode(FILL_T.FILLED_SHAPE);
|
|
dummy.SetWidth(0);
|
|
|
|
const shape = new SHAPE_POLY_SET();
|
|
aBarCode.TransformShapeToPolySet(shape, aBarCode.GetLayer(), 0, 0, ERROR_LOC.ERROR_INSIDE);
|
|
dummy.SetPolyShape(shape);
|
|
|
|
this.PlotShape(dummy);
|
|
}
|
|
|
|
PlotTableBorders(aTable: PCB_TABLE): void {
|
|
if (!this.m_layerMask.test(aTable.GetLayer())) return;
|
|
|
|
const gbr_metadata = new GBR_METADATA();
|
|
const parentFP = aTable.GetParentFootprint();
|
|
|
|
if (parentFP) {
|
|
gbr_metadata.SetCmpReference(parentFP.GetReference());
|
|
gbr_metadata.SetNetAttribType(GBR_NETINFO_TYPE.GBR_NETINFO_CMP);
|
|
}
|
|
|
|
const md = this.metadata(gbr_metadata);
|
|
|
|
aTable.DrawBorders((ptA, ptB, stroke) => {
|
|
const lineWidth = stroke.GetWidth();
|
|
const lineStyle = stroke.GetLineStyle();
|
|
|
|
if (lineStyle <= LINE_STYLE.SOLID /* FIRST_TYPE */) {
|
|
this.m_plotter.ThickSegment(ptA, ptB, lineWidth, md);
|
|
} else {
|
|
const seg = new SHAPE_SEGMENT(ptA, ptB);
|
|
|
|
STROKE_PARAMS.Stroke(
|
|
seg,
|
|
lineStyle,
|
|
lineWidth,
|
|
this.m_plotter.RenderSettings()!,
|
|
(a, b) => {
|
|
this.m_plotter.ThickSegment(a, b, lineWidth, md);
|
|
},
|
|
);
|
|
}
|
|
});
|
|
}
|
|
|
|
private plotOneDrillMark(
|
|
aDrillShape: PAD_DRILL_SHAPE,
|
|
aDrillPos: VECTOR2I,
|
|
aDrillSize: VECTOR2I,
|
|
aPadSize: VECTOR2I,
|
|
aOrientation: EDA_ANGLE,
|
|
aSmallDrill: number,
|
|
): void {
|
|
const drillSize = { x: aDrillSize.x, y: aDrillSize.y };
|
|
|
|
// Small drill marks have no significance when applied to slots
|
|
if (aSmallDrill && aDrillShape === PAD_DRILL_SHAPE.CIRCLE)
|
|
drillSize.x = Math.min(aSmallDrill, drillSize.x);
|
|
|
|
// Round holes only have x diameter, slots have both
|
|
const clamp = (v: number, lo: number, hi: number): number => Math.min(Math.max(v, lo), hi);
|
|
drillSize.x -= this.getFineWidthAdj();
|
|
drillSize.x = clamp(drillSize.x, 1, aPadSize.x - 1);
|
|
|
|
if (aDrillShape === PAD_DRILL_SHAPE.OBLONG) {
|
|
drillSize.y -= this.getFineWidthAdj();
|
|
drillSize.y = clamp(drillSize.y, 1, aPadSize.y - 1);
|
|
|
|
this.m_plotter.FlashPadOval(aDrillPos, drillSize, aOrientation, null);
|
|
} else {
|
|
this.m_plotter.FlashPadCircle(aDrillPos, drillSize.x, null);
|
|
}
|
|
}
|
|
|
|
PlotDrillMarks(): void {
|
|
let smallDrill = 0;
|
|
|
|
if (this.GetDrillMarksType() === DRILL_MARKS.SMALL_DRILL_SHAPE)
|
|
smallDrill = pcbIUScale.mmToIU(ADVANCED_CFG.GetCfg().m_SmallDrillMarkSize);
|
|
|
|
/* Drill marks are drawn white-on-black to knock-out the underlying pad. This works only
|
|
* for drivers supporting color change, obviously... it means that:
|
|
- PS, SVG and PDF output is correct (i.e. you have a 'donut' pad)
|
|
- In gerbers you can't see them. This is arguably the right thing to do since having
|
|
drill marks and high speed drill stations is a sure recipe for broken tools and angry
|
|
manufacturers. If you *really* want them you could start a layer with negative
|
|
polarity to knock-out the film.
|
|
- In DXF they go into the 'WHITE' layer. This could be useful.
|
|
*/
|
|
const notSketchDxf =
|
|
this.m_plotter.GetPlotterType() !== PLOT_FORMAT.DXF ||
|
|
this.GetDXFPlotMode() === DXF_OUTLINE_MODE.FILLED;
|
|
|
|
if (notSketchDxf) this.m_plotter.SetColor(WHITE);
|
|
|
|
for (const track of this.m_board.Tracks()) {
|
|
if (track.Type() === KICAD_T.PCB_VIA_T) {
|
|
const via = track as PCB_VIA;
|
|
|
|
// Via are not always on all layers
|
|
if (via.GetLayerSet().and(this.m_layerMask).none()) continue;
|
|
|
|
this.plotOneDrillMark(
|
|
PAD_DRILL_SHAPE.CIRCLE,
|
|
via.GetStart(),
|
|
{ x: via.GetDrillValue(), y: 0 },
|
|
{ x: via.GetWidth(PADSTACK.ALL_LAYERS), y: 0 },
|
|
ANGLE_0,
|
|
smallDrill,
|
|
);
|
|
}
|
|
}
|
|
|
|
for (const footprint of this.m_board.Footprints()) {
|
|
for (const pad of footprint.Pads()) {
|
|
if (pad.GetDrillSize().x === 0) continue;
|
|
|
|
// Skip marks on layers the pad isn't on for Gerber only (24416). Other
|
|
// formats keep them as a drill map, e.g. Edge.Cuts (24867).
|
|
if (
|
|
this.m_plotter.GetPlotterType() === PLOT_FORMAT.GERBER &&
|
|
pad.GetLayerSet().and(this.m_layerMask).none()
|
|
)
|
|
continue;
|
|
|
|
if (notSketchDxf) {
|
|
// Drill mark is in black unless we can find something to knock it out of
|
|
this.m_plotter.SetColor(COLOR4D_BLACK);
|
|
|
|
for (const layer of this.m_layerMask.Seq()) {
|
|
if (!pad.IsOnLayer(layer)) continue;
|
|
|
|
const padSize = pad.GetSize(layer);
|
|
|
|
if (padSize.x > pad.GetDrillSizeX() || padSize.y > pad.GetDrillSizeY()) {
|
|
this.m_plotter.SetColor(WHITE);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
this.plotOneDrillMark(
|
|
pad.GetDrillShape(),
|
|
pad.GetPosition(),
|
|
pad.GetDrillSize(),
|
|
pad.GetSize(PADSTACK.ALL_LAYERS),
|
|
pad.GetOrientation(),
|
|
smallDrill,
|
|
);
|
|
}
|
|
}
|
|
|
|
if (notSketchDxf) this.m_plotter.SetColor(COLOR4D_BLACK);
|
|
}
|
|
}
|