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

403 lines
14 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.
/**
* `PCB_PLOTTER` — `pcbnew/pcb_plotter.cpp` / `.h`: plot a list of board
* layers, one file per layer or (PDF single document, DXF multi-layer) one
* file for them all; the loop DIALOG_PLOT and `kicad-cli pcb export
* gerbers|pdf|svg|dxf|ps` both run.
*
* Divergences:
* - **No filesystem.** Each finished file, the Gerber job file included, is
* handed to `aWriteFile` with the path upstream would have written it to.
* - "Now" (Gerber / SVG / PS / job-file dates) comes in as `aDate`, and the PDF
* stream compressor through `SetPdfDeflate` (none: uncompressed streams).
* - `Plot` also returns the layer / file name pairs it fed `AddGbrFile`.
*/
import { ExpandTextVars } from '@ziroeda/common/common.js';
import type { OutStr } from '@ziroeda/common/font/font.js';
import type { PCB_LAYER_ID } from '@ziroeda/common/layer_id.js';
import type { LSEQ } from '@ziroeda/common/lseq.js';
import { LSET } from '@ziroeda/common/lset.js';
import { GetDefaultPlotExtension } from '@ziroeda/common/plotters/common_plot_functions.js';
import type { PdfDeflate, PDF_PLOTTER } from '@ziroeda/common/plotters/PDF_plotter.js';
import { PLOT_FORMAT, type PLOTTER } from '@ziroeda/common/plotters/plotter.js';
import {
type Reporter,
RPT_SEVERITY_ACTION,
RPT_SEVERITY_ERROR,
RPT_SEVERITY_INFO,
} from '@ziroeda/common/reporter.js';
import { PAGE_INFO } from '@ziroeda/common/page_info.js';
import { pcbIUScale } from '@ziroeda/common/eda_units.js';
import { SHAPE_POLY_SET } from '@ziroeda/kimath/src/geometry/shape_poly_set.js';
import type { BOARD } from './board.js';
import { GERBER_JOBFILE_WRITER } from './exporters/gerber_jobfile_writer.js';
import type { PCB_PLOT_PARAMS } from './pcb_plot_params.js';
import { GetGerberProtelExtension } from './pcbplot.js';
import {
PlotBoardLayers,
PlotInteractiveLayer,
StartPlotBoard,
setupPlotterNewPDFPage,
} from './plot_board_layers.js';
/** A plotted file: the layer and the file's full name (`jobfile_writer->AddGbrFile`). */
export interface PCB_PLOTTED_FILE {
layer: PCB_LAYER_ID;
fullName: string;
}
/** Upstream's optional overrides of `Plot`. */
export interface PCB_PLOT_NAMES {
aOutputPathIsSingle?: boolean;
aLayerName?: string;
aSheetName?: string;
aSheetPath?: string;
}
/** A plotter's finished document (every PLOTTER here keeps its file in memory). */
function plotterBytes(aPlotter: PLOTTER): Uint8Array {
return (aPlotter as unknown as { bytes(): Uint8Array }).bytes();
}
export class PCB_PLOTTER {
protected m_board: BOARD;
protected m_plotOpts: PCB_PLOT_PARAMS;
protected m_reporter: Reporter | null;
protected m_pdfDeflate: PdfDeflate | null = null;
constructor(aBoard: BOARD, aReporter: Reporter | null, aParams: PCB_PLOT_PARAMS) {
this.m_board = aBoard;
this.m_plotOpts = aParams;
this.m_reporter = aReporter;
}
/** The PDF page-stream compressor (upstream links zlib). */
SetPdfDeflate(aDeflate: PdfDeflate | null): void {
this.m_pdfDeflate = aDeflate;
}
/**
* Plot each of `aLayersToPlot` (with `aCommonLayers` drawn on every one).
*
* @param aWriteFile receives each finished file (upstream's fopen / fclose).
* @param aDate is "now" for the file dates; upstream reads the clock.
*/
Plot(
aOutputPath: string,
aLayersToPlot: LSEQ,
aCommonLayers: LSEQ,
aUseGerberFileExtensions: boolean,
aWriteFile: (aFullPath: string, aBytes: Uint8Array) => void,
aDate: Date = new Date(),
aNames: PCB_PLOT_NAMES = {},
): { success: boolean; files: PCB_PLOTTED_FILE[] } {
const files: PCB_PLOTTED_FILE[] = [];
const board = this.m_board;
const textResolver = (token: OutStr): boolean =>
// Handles board->GetTitleBlock() *and* board->GetProject()
board.ResolveTextVar(token, 0);
const aOutputPathIsSingle = aNames.aOutputPathIsSingle ?? false;
// sanity, ensure one layer to print
if (aLayersToPlot.length < 1) {
this.m_reporter?.report('No layers selected for plotting.', RPT_SEVERITY_ERROR);
return { success: false, files };
}
const existingPageInfo = new PAGE_INFO();
existingPageInfo.assign(board.GetPageSettings());
const existingAuxOrigin = { ...board.GetDesignSettings().GetAuxOrigin() };
// Page is board boundary size
if (this.m_plotOpts.GetFormat() === PLOT_FORMAT.SVG && this.m_plotOpts.GetSvgFitPagetoBoard()) {
let bbox = board.ComputeBoundingBox(false, false);
const boardOutlines = new SHAPE_POLY_SET();
// Board outline geometry is better if it exists so that origin is not influenced by
// Edge.Cuts line width
if (board.GetBoardPolygonOutlines(boardOutlines, false) && boardOutlines.OutlineCount() > 0)
bbox = boardOutlines.BBox();
const currPageInfo = new PAGE_INFO();
currPageInfo.assign(board.GetPageSettings());
currPageInfo.SetWidthMils(bbox.GetWidth() / pcbIUScale.IU_PER_MILS);
currPageInfo.SetHeightMils(bbox.GetHeight() / pcbIUScale.IU_PER_MILS);
board.SetPageSettings(currPageInfo);
this.m_plotOpts.SetUseAuxOrigin(true);
board.GetDesignSettings().SetAuxOrigin(bbox.GetOrigin());
}
// To reuse logic, in single plot mode, we want to kick any extra layers from the main list
// to commonLayers
let layersToPlot: PCB_LAYER_ID[];
let commonLayers: PCB_LAYER_ID[];
const isPdfMultiPage =
this.m_plotOpts.GetFormat() === PLOT_FORMAT.PDF && this.m_plotOpts.m_PDFSingle;
if (
aOutputPathIsSingle &&
!this.m_plotOpts.GetDXFMultiLayeredExportOption() &&
!isPdfMultiPage
) {
layersToPlot = [aLayersToPlot[0]!];
commonLayers = [...aLayersToPlot.slice(1)];
} else {
layersToPlot = [...aLayersToPlot];
commonLayers = [...aCommonLayers];
}
let finalPageCount = 0;
const layersToExport: [PCB_LAYER_ID, string][] = [];
// Skip the disabled copper layers and build the layer ID -> layer name mapping for plotter
// DXF plotter will use this information to name its layers
for (const layer of layersToPlot) {
if (this.copperLayerShouldBeSkipped(layer)) continue;
finalPageCount++;
layersToExport.push([layer, board.GetLayerName(layer)]);
}
let jobfile_writer: GERBER_JOBFILE_WRITER | null = null;
if (this.m_plotOpts.GetFormat() === PLOT_FORMAT.GERBER && !aOutputPathIsSingle)
jobfile_writer = new GERBER_JOBFILE_WRITER(board, this.m_reporter);
const plot_format = this.m_plotOpts.GetFormat();
let fileExt = GetDefaultPlotExtension(plot_format);
let sheetPath = '';
let success = true;
let plotter: PLOTTER | null = null;
let pageNum = 1;
const pdfSingle = plot_format === PLOT_FORMAT.PDF && this.m_plotOpts.m_PDFSingle;
const dxfMulti =
plot_format === PLOT_FORMAT.DXF && this.m_plotOpts.GetDXFMultiLayeredExportOption();
const brdName = fileNameOf(board.GetFileName()).name;
for (let i = 0; i < layersToPlot.length; i++) {
const layer = layersToPlot[i]!;
if (this.copperLayerShouldBeSkipped(layer)) continue;
const plotSequence = PCB_PLOTTER.getPlotSequence(layer, commonLayers);
let layerName = board.GetLayerName(layer);
let fullName: string;
let fullPath: string;
if (aOutputPathIsSingle) {
fullPath = aOutputPath;
fullName = aOutputPath.split(/[\/]/).pop() ?? aOutputPath;
} else {
// Use Gerber Extensions based on layer number
// (See http://en.wikipedia.org/wiki/Gerber_File)
if (plot_format === PLOT_FORMAT.GERBER && aUseGerberFileExtensions)
fileExt = GetGerberProtelExtension(layer);
if (pdfSingle) fullName = `${brdName}.${GetDefaultPlotExtension(PLOT_FORMAT.PDF)}`;
else if (dxfMulti) fullName = `${brdName}.${GetDefaultPlotExtension(PLOT_FORMAT.DXF)}`;
else fullName = PCB_PLOTTER.BuildPlotFileName(brdName, layerName, fileExt);
fullPath = joinPath(aOutputPath, fullName);
}
files.push({ layer, fullName });
jobfile_writer?.AddGbrFile(layer, fullName);
if ((!pdfSingle && !dxfMulti) || pageNum === 1) {
// this will only be used by pdf
const pageNumber = String(pageNum);
let pageName = layerName;
let sheetName = layerName;
if (aNames.aLayerName !== undefined) {
layerName = aNames.aLayerName;
pageName = aNames.aLayerName;
}
if (aNames.aSheetName !== undefined) sheetName = aNames.aSheetName;
if (aNames.aSheetPath !== undefined) sheetPath = aNames.aSheetPath;
this.m_plotOpts.SetLayersToExport(layersToExport);
plotter = StartPlotBoard(
board,
this.m_plotOpts,
layer,
layerName,
fullPath,
sheetName,
sheetPath,
pageName,
pageNumber,
finalPageCount,
aDate,
this.m_pdfDeflate,
);
}
if (plotter) {
plotter.SetLayer(layer);
plotter.SetTitle(ExpandTextVars(board.GetTitleBlock().GetTitle(), textResolver));
if (this.m_plotOpts.m_PDFMetadata) {
const author: OutStr = { value: 'AUTHOR' };
if (board.ResolveTextVar(author, 0)) plotter.SetAuthor(author.value);
const subject: OutStr = { value: 'SUBJECT' };
if (board.ResolveTextVar(subject, 0)) plotter.SetSubject(subject.value);
}
try {
PlotBoardLayers(board, plotter, plotSequence, this.m_plotOpts);
PlotInteractiveLayer(board, plotter, this.m_plotOpts);
} catch (e) {
console.error(e);
success = false;
break;
}
if (pdfSingle && pageNum !== finalPageCount) {
const pageNumber = String(pageNum + 1);
let nextI = i + 1;
let nextLayer = layersToPlot[nextI]!;
while (this.copperLayerShouldBeSkipped(nextLayer) && nextI < layersToPlot.length - 1) {
++nextI;
nextLayer = layersToPlot[nextI]!;
}
layerName = board.GetLayerName(nextLayer);
const pageName = layerName;
const sheetName = layerName;
(plotter as PDF_PLOTTER).ClosePage();
(plotter as PDF_PLOTTER).StartPage(pageNumber, pageName);
setupPlotterNewPDFPage(
plotter,
board,
this.m_plotOpts,
layerName,
sheetName,
sheetPath,
pageNumber,
finalPageCount,
);
}
// last page
if (
(!pdfSingle && !dxfMulti) ||
i === aLayersToPlot.length - 1 ||
pageNum === finalPageCount
) {
try {
plotter.EndPlot();
aWriteFile(fullPath, plotterBytes(plotter));
} catch (e) {
console.error(e);
success = false;
}
plotter = null;
this.m_reporter?.report(`Plotted to '${fullPath}'.`, RPT_SEVERITY_ACTION);
}
} else {
this.m_reporter?.report(`Failed to create file '${fullPath}'.`, RPT_SEVERITY_ERROR);
success = false;
}
pageNum++;
}
if (jobfile_writer && this.m_plotOpts.GetCreateGerberJobFile()) {
// Build gerber job file from basename
const jobPath = joinPath(
aOutputPath,
PCB_PLOTTER.BuildPlotFileName(brdName, 'job', 'gbrjob'),
);
jobfile_writer.SetDate(aDate);
jobfile_writer.SetFileSink(aWriteFile);
jobfile_writer.CreateJobFile(jobPath);
}
this.m_reporter?.report('Done.', RPT_SEVERITY_INFO);
if (this.m_plotOpts.GetFormat() === PLOT_FORMAT.SVG && this.m_plotOpts.GetSvgFitPagetoBoard()) {
// restore the original page and aux origin
board.SetPageSettings(existingPageInfo);
board.GetDesignSettings().SetAuxOrigin(existingAuxOrigin);
}
return { success, files };
}
/**
* `BuildPlotFileName`: the board's base name, a `-suffix` made safe for a file
* name, and the extension.
*/
static BuildPlotFileName(aBaseName: string, aSuffix: string, aExtension: string): string {
// remove leading and trailing spaces if any from the suffix, if
// something survives add it to the name;
// also the suffix can contain some not allowed chars in filename (/ \ . : and some others),
// so change them to underscore
let suffix = aSuffix.trim();
// wxFileName::GetForbiddenChars( wxPATH_DOS ), plus "%."
const badchars = '/\\:*?"<>|%.';
for (const c of badchars) suffix = suffix.replaceAll(c, '_');
const name = suffix !== '' ? `${aBaseName}-${suffix}` : aBaseName;
return aExtension !== '' ? `${name}.${aExtension}` : name;
}
/** The layer to plot first, then every common layer not already in the sequence. */
static getPlotSequence(aLayerToPlot: PCB_LAYER_ID, aPlotWithAllLayersSeq: LSEQ): LSEQ {
const plotSequence: PCB_LAYER_ID[] = [];
// Base layer always gets plotted first.
plotSequence.push(aLayerToPlot);
for (const layer of aPlotWithAllLayersSeq) {
// Don't plot the same layer more than once;
if (plotSequence.includes(layer)) continue;
plotSequence.push(layer);
}
return plotSequence;
}
protected copperLayerShouldBeSkipped(aLayerToPlot: PCB_LAYER_ID): boolean {
return LSET.AllCuMask()
.and(new LSET(this.m_board.GetEnabledLayers()).flip())
.test(aLayerToPlot);
}
}
/** `wxFileName::Assign( aPath, aName )`: the directory joined to the file name. */
function joinPath(aPath: string, aName: string): string {
return aPath ? `${aPath.replace(/\/+$/, '')}/${aName}` : aName;
}
/** `wxFileName( path ).GetName()`: the last component without its extension. */
function fileNameOf(aPath: string): { name: string } {
const full = aPath.split(/[\\/]/).pop() ?? '';
const dot = full.lastIndexOf('.');
return { name: dot > 0 ? full.slice(0, dot) : full };
}