circuitscript 0.0.14 → 0.0.15

package/src/draw_symbols.ts

@@ -154,6 +154,7 @@ export abstract class SymbolGraphic {
                 anchor = HorizontalAlign.Left, 
                 vanchor = VerticalAlign.Bottom,
                 fontWeight = 'regular',
+                angle: labelAngle = 0,
             } = tmpLabel.style ?? {};
 
             let anchorStyle = 'start';
@@ -198,7 +199,8 @@ export abstract class SymbolGraphic {
             const position = tmpLabel.getLabelPosition();
             const useFont = defaultFont;
 
-            const text = group.text(tmpLabel.text)
+            const textContainer = group.group();
+            const text = textContainer.text(tmpLabel.text)
                 .fill('#333')
                 .font({
                     family: useFont,
@@ -208,12 +210,25 @@ export abstract class SymbolGraphic {
                     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');
         });
     }
 
@@ -289,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[] = [];
@@ -403,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);
 
@@ -451,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;
@@ -512,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;
@@ -570,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([
@@ -820,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,6 +65,18 @@ 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,
@@ -71,7 +86,7 @@ export class Label extends Flatten.Polygon {
         // 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 =
@@ -88,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 {
@@ -117,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);
     }
@@ -188,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!";
             }
 
@@ -219,6 +248,8 @@ export class Geometry {
         console.log('unknown type', feature);
     }
 
+    static FullCircleRadians = 2 * Math.PI;
+
     static featuresToPath(items: Feature[]): 
         { path: string, isClosedPolygon: boolean } {
 
@@ -238,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/helpers.ts

@@ -41,7 +41,11 @@ export function renderScript(scriptData: string, outputPath: string, options): s
         return null;
     }
 
-    visitor.annotateComponents();
+    try {
+        visitor.annotateComponents();
+    } catch (err) {
+        console.log('Error during annotation: ', err);
+    }
 
     if (kicadNetlistPath) {
         const kicadNetList = generateKiCADNetList(visitor.getNetList());
@@ -99,12 +103,11 @@ export function renderScript(scriptData: string, outputPath: string, options): s
         svgOutput = generateSVG2(graph);
         showStats && console.log('Render took:', generateSvgTimer.lap());
 
-        if (outputPath){
+        if (outputPath) {
             writeFileSync(outputPath, svgOutput);
-        } 
+        }
     } catch (err) {
-        console.log('Failed to render:');
-        console.log(err)
+        console.log('Error during render: ', err);
     }
 
     return svgOutput;

package/src/layout.ts

@@ -604,10 +604,6 @@ export class LayoutEngine {
                     if (tmpSymbol instanceof SymbolCustom && widthProp){
                         tmpSymbol.bodyWidth = widthProp;
                     }
-
-                    if (component.assignedRefDes !== null){
-                        tmpSymbol.setLabelValue("refdes", component.assignedRefDes);
-                    }
     
                     if (!didSetAngle && component.parameters.has('_addDirection')){
                         // If there is an _addDirection specified, then the angle
@@ -683,8 +679,31 @@ export class LayoutEngine {
     
                 previousNode = wireName;
                 previousPin = 1;
-   
-                this.print(SequenceAction.Wire, wireId, JSON.stringify(wireSegments));
+                
+                const wireSegmentsInfo = wireSegments.map(item => {
+                    const tmp: {
+                        direction: string,
+                        value: number,
+                        valueXY?: [x: number, y: number],
+                        until?: [instanceName: string, pin: number]
+                    } = {
+                        direction: item.direction,
+                        value: item.value,
+                    };
+
+                    if (item.valueXY) {
+                        tmp.valueXY = item.valueXY;
+                    }
+
+                    if (item.until) {
+                        tmp.until = [item.until[0].toString(), item.until[1]];
+                    }
+
+                    return tmp;
+                });
+
+                this.print(SequenceAction.Wire, wireId, 
+                    JSON.stringify(wireSegmentsInfo));
                 
             } else if (action === SequenceAction.WireJump) {
                 this.print(...sequence[i]);
@@ -1338,26 +1357,28 @@ function applyComponentParamsToSymbol(typeProp: string,
     component: ClassComponent, symbol: SymbolGraphic): void {
     
     if (typeProp === 'net') {
-        symbol.setLabelValue("net_name", component.parameters.get(ParamKeys.net_name) as string);
+        symbol.setLabelValue("net_name", 
+            component.parameters.get(ParamKeys.net_name) as string);
     }
 
-    if (component.parameters.has('value')) {
-
-        let displayString = "";
-        const tmpValue = component.parameters.get('value');
-        if (typeof tmpValue == 'object' && (tmpValue instanceof NumericValue)) {
-            displayString = (tmpValue as NumericValue).toDisplayString();
-        } else {
-            displayString = tmpValue;
-        }
-
-        symbol.setLabelValue('value', displayString);
+    if (component.assignedRefDes !== null){
+        symbol.setLabelValue("refdes", component.assignedRefDes);
     }
 
-    symbol.setLabelValue('refdes', component.instanceName);
+    for (const [key, value] of component.parameters) {
+        if (key !== 'refdes' && key !== 'net_name') {
+            let useValue: string;
+
+            if (typeof value == 'object' && (value instanceof NumericValue)) {
+                useValue = (value as NumericValue).toDisplayString();
+            } else if (typeof value === 'number') {
+                useValue = value.toString();
+            } else if (typeof value === 'string'){
+                useValue = value;
+            }
 
-    if (component.parameters.has('MPN')) {
-        symbol.setLabelValue('MPN', component.parameters.get('MPN') as string);
+            symbol.setLabelValue(key, useValue);
+        }
     }
 }
 

package/src/regenerate-tests.ts

@@ -21,5 +21,5 @@ cstFiles.forEach(file => {
     const outputPath = inputPath + '.svg';
     renderScript(scriptData, outputPath, { currentDirectory: useCurrentDir });
 
-    console.log('generated ', inputPath);
+    console.log('generated ', outputPath);
 });