circuitscript 0.0.13 → 0.0.15

package/src/draw_symbols.ts

@@ -1,6 +1,6 @@
 import { G } from "@svgdotjs/svg.js";
 
-import { SymbolPinSide, bodyColor, defaultFont } from "./globals.js";
+import { SymbolPinSide, bodyColor, defaultFontBold, defaultFont } from "./globals.js";
 import { Feature, Geometry, GeometryProp, HorizontalAlign, Label, LabelStyle, VerticalAlign } from "./geometry.js";
 import { Logger } from "./logger.js";
 
@@ -154,6 +154,7 @@ export abstract class SymbolGraphic {
                 anchor = HorizontalAlign.Left, 
                 vanchor = VerticalAlign.Bottom,
                 fontWeight = 'regular',
+                angle: labelAngle = 0,
             } = tmpLabel.style ?? {};
 
             let anchorStyle = 'start';
@@ -196,28 +197,38 @@ export abstract class SymbolGraphic {
             }
 
             const position = tmpLabel.getLabelPosition();
+            const useFont = defaultFont;
 
-            let useFont = defaultFont;
-            if (fontWeight === 'bold'){
-                useFont = 'Inter-Bold';
-            }
-
-            const text = group.text(tmpLabel.text)
+            const textContainer = group.group();
+            const text = textContainer.text(tmpLabel.text)
                 .fill('#333')
                 .font({
                     family: useFont,
                     size: fontSize,
                     anchor: anchorStyle,
                     'dominant-baseline': dominantBaseline,
-                    // weight: fontWeight,
+                    weight: fontWeight,
                 });
 
+            let translateX: number, translateY: number;
+            let useRotateAngle = 0;
+
             if (isRotation180){
-                text.translate(-position[0], position[1]);
+                translateX = -position[0];
+                translateY = position[1];
+                useRotateAngle = 0;
             } else {
-                text.translate(position[0], position[1])
-                    .rotate(this.angle, -position[0], -position[1]);
+                translateX = position[0];
+                translateY = position[1];
+                useRotateAngle = this.angle;
             }
+
+            text.rotate(labelAngle);
+            textContainer.translate(translateX, translateY)
+                        .rotate(useRotateAngle, -translateX, -translateY);
+            
+            // For debug, show the origin of the text container
+            // textContainer.circle(2).fill('red');
         });
     }
 
@@ -293,73 +304,233 @@ export class SymbolPlaceholder extends SymbolGraphic {
         drawing.angle = this._angle;
         const commands = drawing.getCommands();
 
-        drawing.log(drawing.id, 'angle: ', this._angle, "commands:", commands.length);
+        drawing.log('id: ', drawing.id, 'angle: ', this._angle, "commands:", commands.length);
 
         commands.forEach(([commandName, positionParams, keywordParams]) => {
-            if (commandName === 'rect') {
-                drawing.log('add rect', ...positionParams);
-                drawing.addRect(...positionParams);
-
-            } else if (commandName === 'pin') {
-                drawing.log('add pin', ...positionParams);
-                drawing.addPin(...positionParams);
-
-            } else if (commandName === 'hline') {
-                drawing.log('add hline', ...positionParams);
-                drawing.addHLine(...positionParams);
-
-            } else if (commandName === 'vline') {
-                drawing.log('add vline', ...positionParams);
-                drawing.addVLine(...positionParams);
-
-            } else if (commandName === 'line') {
-                drawing.log('add line', ...positionParams);
-                drawing.addLine(...positionParams);
-
-            } else if (commandName === 'label') {
-                const keywords = ['fontSize', 'anchor', 'vanchor'];
-
-                // Create the style object
-                const style = {};
-                keywords.forEach(item => {
-                    if (keywordParams.has(item)){
-                        style[item] = keywordParams.get(item);
-                    }
-                });
+            switch (commandName) {
+                case PlaceHolderCommands.rect:
+                    drawing.log('add rect', ...positionParams);
+                    drawing.addRect(...positionParams);
+                    break;
 
-                positionParams = [...positionParams];
-                positionParams.push(style);
+                case PlaceHolderCommands.hline:
+                    drawing.log('add hline', ...positionParams);
+                    drawing.addHLine(...positionParams);
+                    break;
 
-                const labelId = positionParams[0];
+                case PlaceHolderCommands.vline:
+                    drawing.log('add vline', ...positionParams);
+                    drawing.addVLine(...positionParams);
+                    break;
 
-                const tmpPositionParams = [...positionParams];
-                tmpPositionParams[3] = this.getLabelValue(labelId);
+                case PlaceHolderCommands.line:
+                    drawing.log('add line', ...positionParams);
+                    drawing.addLine(...positionParams);
+                    break;
 
-                drawing.log('add label', JSON.stringify(tmpPositionParams));
-                drawing.addLabelId(...tmpPositionParams);
-            
-            } else if (commandName === 'path') {
-                drawing.addPath(...positionParams);
-            } else if (commandName === 'lineWidth') {
-                drawing.addSetLineWidth(...positionParams);
-            } else if (commandName === 'fill') {
-                drawing.addSetFillColor(...positionParams);
-            } else if (commandName === 'lineColor') {
-                drawing.addSetLineColor(...positionParams);
-            } else if (commandName === 'arc'){
-                drawing.addArc(...positionParams);
+                case PlaceHolderCommands.path:
+                    drawing.addPath(...positionParams);
+                    break;
+
+                case PlaceHolderCommands.lineWidth:
+                    drawing.addSetLineWidth(...positionParams);
+                    break;
+
+                case PlaceHolderCommands.fill:
+                    drawing.addSetFillColor(...positionParams);
+                    break;
+
+                case PlaceHolderCommands.lineColor:
+                    drawing.addSetLineColor(...positionParams);
+                    break;
+
+                case PlaceHolderCommands.arc:
+                    drawing.addArc(...positionParams);
+                    break;
+
+                case PlaceHolderCommands.circle:
+                    // circle params: center x, center y, radius
+                    drawing.addArc(...positionParams, 0, 360);
+                    break;
+
+                case PlaceHolderCommands.triangle:
+                    drawing.addTriangle(...positionParams);
+                    break;
+
+                case PlaceHolderCommands.pin: 
+                case PlaceHolderCommands.hpin:
+                case PlaceHolderCommands.vpin:
+                {
+                    this.drawPinParams(drawing, commandName, 
+                        keywordParams, positionParams);
+                    break;
+                }
+
+                case PlaceHolderCommands.label: {
+                    const keywords = ['fontSize', 'anchor', 'vanchor', 'angle'];
+
+                    // Create the style object
+                    const style = {};
+                    keywords.forEach(item => {
+                        if (keywordParams.has(item)) {
+                            style[item] = keywordParams.get(item);
+                        }
+                    });
+
+                    positionParams = [...positionParams];
+                    positionParams.push(style);
+
+                    const labelId = positionParams[0];
+
+                    const tmpPositionParams = [...positionParams];
+
+                    const tmpLabelValue = this.getLabelValue(labelId);
+                    if (tmpLabelValue !== undefined) {
+                        tmpPositionParams[3] = tmpLabelValue;
+                    }
+
+                    drawing.log('add label', JSON.stringify(tmpPositionParams));
+                    drawing.addLabelId(...tmpPositionParams);
+                    break;
+                }
             }
         });
 
         drawing.log("=== end generate drawing ===");
     }
 
+    drawPinParams(drawing: SymbolDrawingCommands,
+        commandName: string, keywordParams: Map<string, any>,
+        positionParams: any[]): void {
+
+        drawing.log('add pin', ...positionParams);
+
+        const keywordDisplayPinId = 'display_pin_id';
+        let displayPinId = true;
+
+        if (keywordParams.has(keywordDisplayPinId)) {
+            if (keywordParams.get(keywordDisplayPinId) === 0) {
+                displayPinId = false;
+            }
+        }
+
+        let pinNameParam: string | null = null;
+        if (typeof positionParams[1] === 'string') {
+            // If the type of the second position is a string, then
+            // use the string value as the pin name
+            pinNameParam = positionParams[1];
+            positionParams = [positionParams[0], ...positionParams.slice(2)];
+        }
+
+        // create the next point
+        const startX = positionParams[1];
+        const startY = positionParams[2];
+
+        if (commandName === PlaceHolderCommands.vpin) {
+            const magnitude = positionParams[3];
+            positionParams = [
+                positionParams[0],
+                startX,
+                startY,
+                startX,
+                startY + magnitude
+            ];
+        } else if (commandName === PlaceHolderCommands.hpin) {
+            const magnitude = positionParams[3];
+            positionParams = [
+                positionParams[0],
+                startX,
+                startY,
+                startX + magnitude,
+                startY
+            ];
+        }
+
+        drawing.addPin(...positionParams);
+
+        // Add a label for the pinId and pinName
+        const latestPin = this.drawing.pins[this.drawing.pins.length - 1];
+        const [pinId, , angle] = latestPin;
+        const [, , , endX, endY] = positionParams;
+
+        let pinNameAlignment = HorizontalAlign.Left;
+        let pinNameOffsetX = 4;
+
+        let pinIdOffsetX = 0;
+        let pinIdAlignment = HorizontalAlign.Left;
+
+        let pinIdVAlignment = VerticalAlign.Bottom;
+        let pinIdOffsetY = -2;
+
+        switch (angle) {
+            case 0:
+                pinNameAlignment = HorizontalAlign.Left;
+                pinNameOffsetX = 4;
+                pinIdAlignment = HorizontalAlign.Right;
+                pinIdOffsetX = -2;
+                break;
+            case 90:
+            case 180:
+                pinNameAlignment = HorizontalAlign.Right;
+                pinNameOffsetX = -4;
+                pinIdAlignment = HorizontalAlign.Left;
+                pinIdOffsetX = 2;
+                break;
+            case 270:
+                pinNameAlignment = HorizontalAlign.Left;
+                pinNameOffsetX = 4;
+                pinIdAlignment = HorizontalAlign.Left;
+                pinIdOffsetX = 2;
+                pinIdOffsetY = 2;
+                pinIdVAlignment = VerticalAlign.Top;
+                break;
+        }
+
+        if (angle === 0 || angle === 90 || angle === 180 || angle === 270) {
+            const usePinName = pinNameParam ?? "";
+
+            // Draw the pinName
+            usePinName !== "" && drawing.addLabel(
+                endX + pinNameOffsetX, endY, usePinName, {
+                fontSize: 10,
+                anchor: pinNameAlignment,
+                vanchor: VerticalAlign.Middle,
+            });
+
+            // Draw pin Id
+            displayPinId && drawing.addLabel(
+                endX + pinIdOffsetX, endY + pinIdOffsetY, pinId.toString(), {
+                fontSize: 8,
+                anchor: pinIdAlignment,
+                vanchor: pinIdVAlignment,
+            });
+        }
+    }
+
     constructor(drawing: SymbolDrawing) {
         super();
         this.drawing = drawing;
     }
 }
 
+export enum PlaceHolderCommands { 
+    arc = 'arc',
+    circle = 'circle',
+    rect = 'rect',
+    triangle = 'triangle',
+    pin = 'pin',
+    hpin = 'hpin',
+    vpin = 'vpin',
+    hline = 'hline',
+    vline = 'vline',
+    line = 'line',
+    label = 'label',
+    path = 'path',
+    lineWidth = 'lineWidth',
+    fill = 'fill',
+    lineColor = 'lineColor'
+}
+
 export class SymbolCustom extends SymbolGraphic {
 
     pinDefinition: SymbolPinDefintion[] = [];
@@ -407,7 +578,7 @@ export class SymbolCustom extends SymbolGraphic {
         const bodyWidth = this.bodyWidth;
         const bodyHeight = (1 + Math.max(maxLeftPins, maxRightPins)) * this.pinSpacing;
 
-        drawing.addSetFillColor(bodyColor);
+        // drawing.addSetFillColor(bodyColor);
 
         drawing.addRect(0, 0, bodyWidth, bodyHeight);
 
@@ -455,18 +626,23 @@ export class SymbolCustom extends SymbolGraphic {
         });
 
         const instanceName = this.getLabelValue("refdes");
-        const MPN = this.getLabelValue("MPN");
-
         instanceName && drawing.addLabel(-bodyWidth/2, -bodyHeight/2 - 4, instanceName, {
             fontSize: 10,
             anchor: HorizontalAlign.Left,
         });
 
-        MPN && drawing.addLabel(-bodyWidth/2, bodyHeight/2 + 4, MPN, {
-                fontSize: 10,
-                anchor: HorizontalAlign.Left,
-                vanchor: VerticalAlign.Top,
-            });
+        const acceptedMPNKeys = ['MPN', 'mpn', 'manufacturer_pn'];
+
+        acceptedMPNKeys.some(key => {
+            const labelValue = this.getLabelValue(key);
+            if (labelValue !== undefined){
+                drawing.addLabel(-bodyWidth/2, bodyHeight/2 + 4, labelValue, {
+                    fontSize: 10,
+                    anchor: HorizontalAlign.Left,
+                    vanchor: VerticalAlign.Top,
+                });
+            }
+        });
 
         this.drawing = drawing;
         this._cacheLeftPins = leftPins;
@@ -516,10 +692,13 @@ export class SymbolDrawing {
     addPin(pinId: number, startX: number, startY: number, 
         endX: number, endY: number): SymbolDrawing {
 
-        // Determine the pin angle based on the start and end values.
+        // Determine the pin angle based on vector with start point 
+        // going to end point. The angle is relative to the x-axis. 
+        //             270 
+        //     180 -- start --> 0
+        //             90
 
         let angle = 0;
-
         if (startX === endX) {
             if (startY > endY) {
                 angle = 270;
@@ -574,6 +753,29 @@ export class SymbolDrawing {
         return this;
     }
 
+    addTriangle(startX: number, startY: number, endX: number, endY: number, width: number): SymbolDrawing {
+        const line = Geometry.line(
+            startX, startY,
+            endX, endY);
+
+        const normLine = line.norm;
+        const dx1 = normLine.x * width / 2;
+        const dy1 = normLine.y * width / 2;
+        const dx2 = normLine.x * -width / 2;
+        const dy2 = normLine.y * -width / 2;
+
+        this.items.push(
+            Geometry.polygon([
+                [dx1 + startX, dy1 + startY],
+                [dx2 + startX, dy2 + startY],
+                [endX, endY],
+                [dx1 + startX, dy1 + startY],
+            ])
+        );
+
+        return this;
+    }
+
     addRect2(x: number, y: number, x2: number, y2: number): SymbolDrawing {
         this.items.push(
             Geometry.polygon([
@@ -824,7 +1026,7 @@ export class SymbolDrawingCommands extends SymbolDrawing {
     clone(): SymbolDrawingCommands {
         // Force a deep clone
         const tmpCommands: SubExpressionCommand[] = this.commands.map(item => {
-            if (item[0] === "label") {
+            if (item[0] === PlaceHolderCommands.label) {
                 const commandName = item[0];
                 const positionParams = item[1];
                 const keywordParams = item[2];

package/src/geometry.ts

@@ -2,10 +2,12 @@ import Flatten from '@flatten-js/core'
 import { measureTextSize2 } from './sizing.js';
 import { defaultFont } from './globals.js';
 import { Box } from '@svgdotjs/svg.js';
+import { NumericValue } from './objects/ParamDefinition.js';
 
 export type Segment = Flatten.Segment;
 export type Polygon = Flatten.Polygon;
 export type Multiline = Flatten.Multiline;
+export type Line = Flatten.Line;
 
 export type Arc = Flatten.Arc;
 
@@ -15,6 +17,7 @@ export type LabelStyle = {
     font?: string,
     fontSize?: number,
     fontWeight?: string,
+    angle?: number,
     
     anchor?: HorizontalAlign.Left | HorizontalAlign.Middle | HorizontalAlign.Right, // Horizontal anchor
     vanchor?: VerticalAlign.Top | VerticalAlign.Middle | VerticalAlign.Bottom, // Vertical anchor
@@ -62,15 +65,28 @@ export class Label extends Flatten.Polygon {
     static fromPoint(id: string, x: number, y: number, 
         text: string, style: LabelStyle): Label {
 
+        let useText: string;
+        if (typeof text === 'number'){
+            useText = (text as number).toString();
+        } else if (typeof text === 'object' 
+            && text instanceof NumericValue) {
+            useText = (text as NumericValue).toDisplayString();
+        } else if (typeof text === 'string'){
+            useText = text;
+        } else {
+            throw 'Invalid string passed into label';
+        }
+
         const { fontSize = 10,
             anchor = HorizontalAlign.Left,
             vanchor = VerticalAlign.Bottom,
             fontWeight = 'regular',
          } = style ?? {};
 
-        // Determine the size of the text
+        // Determine the size of the text, this is needed to determine the 
+        // bounding box of the text for layout purposes.
         const { width, height, box } =
-            measureTextSize2(text, defaultFont, fontSize, fontWeight, 
+            measureTextSize2(useText, defaultFont, fontSize, fontWeight, 
                 anchor, vanchor);
 
         // const polygonCoords =
@@ -87,7 +103,7 @@ export class Label extends Flatten.Polygon {
         const polygon = new Flatten.Polygon(polygonCoords);
 
         // Create the bounds of the label
-        return new Label(id, text, [x, y], polygon, style, box);
+        return new Label(id, useText, [x, y], polygon, style, box);
     }
 
     rotate(angle: number, origin: Flatten.Point): Label {
@@ -116,6 +132,13 @@ export class Geometry {
         return new Flatten.Point(x, y);
     }
 
+    static line(x1: number, y1: number, x2: number, y2: number): Flatten.Line {
+        return new Flatten.Line(
+            Geometry.point(x1, y1),
+            Geometry.point(x2, y2)
+        )
+    }
+
     static label(id: string, x: number, y: number, text: string, style: LabelStyle): Label {
         return Label.fromPoint(id, x, y, text, style);
     }
@@ -187,7 +210,14 @@ export class Geometry {
 
         features.forEach(feature => {
             const box = feature.box;
-            if (box.xmin === undefined){
+
+            if (feature instanceof Label
+                && typeof feature.text === 'string'
+                && feature.text.trim().length === 0) {
+                return;
+            }
+
+            if (box.xmin === undefined) {
                 throw "Invalid box!";
             }
 
@@ -218,6 +248,8 @@ export class Geometry {
         console.log('unknown type', feature);
     }
 
+    static FullCircleRadians = 2 * Math.PI;
+
     static featuresToPath(items: Feature[]): 
         { path: string, isClosedPolygon: boolean } {
 
@@ -237,16 +269,26 @@ export class Geometry {
                 const y = item.center.y;
                 const radius = item.r as number;
 
+                let useEndAngle = item.endAngle;
+                let extraEnd = '';
+                if (item.startAngle === 0 && item.endAngle === Geometry.FullCircleRadians){
+                    // detect as a circle and close the polygon
+                    useEndAngle = 359.9999 * Math.PI/ 180;
+                    isClosedPolygon = true;
+                    extraEnd = ' Z'; // close the circle
+                }
+
                 // Assume angle is clockwise for now
                 const startPoint = getArcPointRadians(x, y, radius, 
                     item.startAngle);
                 
                 const endPoint = getArcPointRadians(x, y, radius, 
-                    item.endAngle);
+                    useEndAngle);
                 
                 paths.push('M ' + startPoint[0] + ' ' + startPoint[1]
                     + 'A ' + radius + ' ' + radius + ' 0 1 1 ' 
-                    + endPoint[0] + ' ' + endPoint[1]);
+                    + endPoint[0] + ' ' + endPoint[1] + extraEnd);
+
 
             } else {
                 const coords = Geometry.getCoords(item);

package/src/globals.ts

@@ -33,7 +33,9 @@ export enum SymbolPinSide {
 export const portWidth = 20;
 export const portHeight = 2;
 
-export const defaultFont = 'Inter';
+export const defaultFont = 'Open Sans-Regular, Arial';
+export const defaultFontBold = 'Open Sans-Bold, Arial-Bold, Arial';
+
 export const defaultFontSize = 10;
 
 export const bodyColor = '#FFFEAF';

package/src/helpers.ts

@@ -0,0 +1,114 @@
+import { writeFileSync } from "fs";
+import { generateKiCADNetList } from "./export.js";
+import { LayoutEngine } from "./layout.js";
+import { SequenceAction } from "./objects/ExecutionScope.js";
+import { parseFileWithVisitor } from "./parser.js";
+import { generateSVG2 } from "./render.js";
+import { SimpleStopwatch } from "./utils.js";
+import { MainVisitor } from "./visitor.js";
+
+export function renderScript(scriptData: string, outputPath: string, options): string {
+
+    const {
+        currentDirectory = null, 
+        defaultLibsPath,
+        dumpNets = false,
+        dumpData = false,
+        kicadNetlistPath = null,
+        showStats = false} = options;
+
+    const visitor = new MainVisitor(true);
+
+    visitor.onImportFile = visitor.createImportFileHandler(currentDirectory, defaultLibsPath);
+
+    visitor.print('reading file');
+    visitor.print('done reading file');
+
+    const { tree, parser,
+        hasParseError, hasError, 
+        parserTimeTaken, 
+        lexerTimeTaken } = parseFileWithVisitor(visitor, scriptData);
+
+    showStats && console.log('Lexing took:', lexerTimeTaken);
+    showStats && console.log('Parsing took:', parserTimeTaken);
+    dumpNets && console.log(visitor.dumpNets());
+
+    dumpData && writeFileSync('dump/tree.lisp', tree.toStringTree(null, parser));
+    dumpData && writeFileSync('dump/raw-parser.txt', visitor.logger.dump());
+    
+    if (hasError || hasParseError) {
+        console.log('Error while parsing');
+        return null;
+    }
+
+    try {
+        visitor.annotateComponents();
+    } catch (err) {
+        console.log('Error during annotation: ', err);
+    }
+
+    if (kicadNetlistPath) {
+        const kicadNetList = generateKiCADNetList(visitor.getNetList());
+        writeFileSync(kicadNetlistPath, kicadNetList);
+        console.log('Generated KiCad netlist file');
+    }
+    
+
+    // await writeFile('dump/raw-netlist.json', JSON.stringify(visitor.dump2(), null, 2));
+
+    const { sequence, nets } = visitor.getGraph();
+
+    // const tmpInstances = visitor.getExecutor().scope.instances;
+    // for (const [instanceName, instance] of tmpInstances){
+    //     console.log(instanceName);
+    //     console.log(instance.pinNets);
+    // }
+
+
+    const tmpSequence = sequence.map(item => {
+        const tmp = [...item];
+
+        const action = tmp[0];
+
+        if (action === SequenceAction.Wire) {
+            tmp[2] = tmp[2].map(item2 => {
+                return [item2.direction, item2.value].join(",");
+            }).join(" ");
+        } else if (action === SequenceAction.Frame) {
+            tmp[1] = item[1].frameId;
+            
+        } else if (action !== SequenceAction.WireJump) {
+            tmp[1] = item[1].instanceName;
+        }
+
+        return tmp.join(" | ");
+    });
+
+    dumpData && writeFileSync('dump/raw-sequence.txt', tmpSequence.join('\n'));
+    let svgOutput: string = null;
+
+    try {
+        const layoutEngine = new LayoutEngine();
+        const layoutTimer = new SimpleStopwatch();
+
+        const graph = layoutEngine.runLayout(sequence, nets);
+
+        layoutEngine.printWarnings();
+
+        showStats && console.log('Layout took:', layoutTimer.lap());
+
+        dumpData && writeFileSync('dump/raw-layout.txt', layoutEngine.logger.dump());
+
+        const generateSvgTimer = new SimpleStopwatch();
+        svgOutput = generateSVG2(graph);
+        showStats && console.log('Render took:', generateSvgTimer.lap());
+
+        if (outputPath) {
+            writeFileSync(outputPath, svgOutput);
+        }
+    } catch (err) {
+        console.log('Error during render: ', err);
+    }
+
+    return svgOutput;
+}