circuitscript 0.0.13 → 0.0.15

package/build/src/draw_symbols.js

@@ -1,4 +1,4 @@
-import { SymbolPinSide, bodyColor, defaultFont } from "./globals.js";
+import { SymbolPinSide, defaultFont } from "./globals.js";
 import { Geometry, GeometryProp, HorizontalAlign, Label, VerticalAlign } from "./geometry.js";
 const defaultSymbolLineColor = '#333';
 const defaultSymbolLineWidth = 2;
@@ -98,7 +98,7 @@ export class SymbolGraphic {
         const labels = this.drawing.getLabels();
         labels.forEach(label => {
             const tmpLabel = label;
-            const { fontSize = 10, anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom, fontWeight = 'regular', } = tmpLabel.style ?? {};
+            const { fontSize = 10, anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom, fontWeight = 'regular', angle: labelAngle = 0, } = tmpLabel.style ?? {};
             let anchorStyle = 'start';
             let dominantBaseline = 'auto';
             let useAnchor = anchor;
@@ -129,25 +129,32 @@ export class SymbolGraphic {
                     break;
             }
             const position = tmpLabel.getLabelPosition();
-            let useFont = defaultFont;
-            if (fontWeight === 'bold') {
-                useFont = 'Inter-Bold';
-            }
-            const text = group.text(tmpLabel.text)
+            const useFont = defaultFont;
+            const textContainer = group.group();
+            const text = textContainer.text(tmpLabel.text)
                 .fill('#333')
                 .font({
                 family: useFont,
                 size: fontSize,
                 anchor: anchorStyle,
                 'dominant-baseline': dominantBaseline,
+                weight: fontWeight,
             });
+            let translateX, translateY;
+            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);
         });
     }
     flipTextAnchor(value) {
@@ -208,67 +215,183 @@ export class SymbolPlaceholder extends SymbolGraphic {
         drawing.clear();
         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'];
-                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;
+                case PlaceHolderCommands.hline:
+                    drawing.log('add hline', ...positionParams);
+                    drawing.addHLine(...positionParams);
+                    break;
+                case PlaceHolderCommands.vline:
+                    drawing.log('add vline', ...positionParams);
+                    drawing.addVLine(...positionParams);
+                    break;
+                case PlaceHolderCommands.line:
+                    drawing.log('add line', ...positionParams);
+                    drawing.addLine(...positionParams);
+                    break;
+                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:
+                    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;
                     }
-                });
-                positionParams = [...positionParams];
-                positionParams.push(style);
-                const labelId = positionParams[0];
-                const tmpPositionParams = [...positionParams];
-                tmpPositionParams[3] = this.getLabelValue(labelId);
-                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.label: {
+                    const keywords = ['fontSize', 'anchor', 'vanchor', 'angle'];
+                    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, commandName, keywordParams, positionParams) {
+        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 = null;
+        if (typeof positionParams[1] === 'string') {
+            pinNameParam = positionParams[1];
+            positionParams = [positionParams[0], ...positionParams.slice(2)];
+        }
+        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);
+        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 ?? "";
+            usePinName !== "" && drawing.addLabel(endX + pinNameOffsetX, endY, usePinName, {
+                fontSize: 10,
+                anchor: pinNameAlignment,
+                vanchor: VerticalAlign.Middle,
+            });
+            displayPinId && drawing.addLabel(endX + pinIdOffsetX, endY + pinIdOffsetY, pinId.toString(), {
+                fontSize: 8,
+                anchor: pinIdAlignment,
+                vanchor: pinIdVAlignment,
+            });
+        }
+    }
     constructor(drawing) {
         super();
         this.drawing = drawing;
     }
 }
+export var PlaceHolderCommands;
+(function (PlaceHolderCommands) {
+    PlaceHolderCommands["arc"] = "arc";
+    PlaceHolderCommands["circle"] = "circle";
+    PlaceHolderCommands["rect"] = "rect";
+    PlaceHolderCommands["triangle"] = "triangle";
+    PlaceHolderCommands["pin"] = "pin";
+    PlaceHolderCommands["hpin"] = "hpin";
+    PlaceHolderCommands["vpin"] = "vpin";
+    PlaceHolderCommands["hline"] = "hline";
+    PlaceHolderCommands["vline"] = "vline";
+    PlaceHolderCommands["line"] = "line";
+    PlaceHolderCommands["label"] = "label";
+    PlaceHolderCommands["path"] = "path";
+    PlaceHolderCommands["lineWidth"] = "lineWidth";
+    PlaceHolderCommands["fill"] = "fill";
+    PlaceHolderCommands["lineColor"] = "lineColor";
+})(PlaceHolderCommands || (PlaceHolderCommands = {}));
 export class SymbolCustom extends SymbolGraphic {
     pinDefinition = [];
     bodyWidth = 100;
@@ -297,7 +420,6 @@ export class SymbolCustom extends SymbolGraphic {
         drawing.angle = this._angle;
         const bodyWidth = this.bodyWidth;
         const bodyHeight = (1 + Math.max(maxLeftPins, maxRightPins)) * this.pinSpacing;
-        drawing.addSetFillColor(bodyColor);
         drawing.addRect(0, 0, bodyWidth, bodyHeight);
         const leftPinStart = -bodyWidth / 2;
         const rightPinStart = bodyWidth / 2;
@@ -333,15 +455,20 @@ 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;
@@ -414,6 +541,21 @@ export class SymbolDrawing {
         ]));
         return this;
     }
+    addTriangle(startX, startY, endX, endY, width) {
+        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, y, x2, y2) {
         this.items.push(Geometry.polygon([
             [x, y],
@@ -589,7 +731,7 @@ export class SymbolDrawingCommands extends SymbolDrawing {
     }
     clone() {
         const tmpCommands = 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/build/src/geometry.js

@@ -1,6 +1,7 @@
 import Flatten from '@flatten-js/core';
 import { measureTextSize2 } from './sizing.js';
 import { defaultFont } from './globals.js';
+import { NumericValue } from './objects/ParamDefinition.js';
 export class Label extends Flatten.Polygon {
     id;
     text;
@@ -24,8 +25,22 @@ export class Label extends Flatten.Polygon {
         this.textMeasurementBounds = bounds;
     }
     static fromPoint(id, x, y, text, style) {
+        let useText;
+        if (typeof text === 'number') {
+            useText = text.toString();
+        }
+        else if (typeof text === 'object'
+            && text instanceof NumericValue) {
+            useText = text.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 ?? {};
-        const { width, height, box } = measureTextSize2(text, defaultFont, fontSize, fontWeight, anchor, vanchor);
+        const { width, height, box } = measureTextSize2(useText, defaultFont, fontSize, fontWeight, anchor, vanchor);
         const polygonCoords = [
             [box.x, box.y],
             [box.x2, box.y],
@@ -34,7 +49,7 @@ export class Label extends Flatten.Polygon {
             [box.x, box.y],
         ];
         const polygon = new Flatten.Polygon(polygonCoords);
-        return new Label(id, text, [x, y], polygon, style, box);
+        return new Label(id, useText, [x, y], polygon, style, box);
     }
     rotate(angle, origin) {
         const polygonRotate = super.rotate(angle, origin);
@@ -56,6 +71,9 @@ export class Geometry {
     static point(x, y) {
         return new Flatten.Point(x, y);
     }
+    static line(x1, y1, x2, y2) {
+        return new Flatten.Line(Geometry.point(x1, y1), Geometry.point(x2, y2));
+    }
     static label(id, x, y, text, style) {
         return Label.fromPoint(id, x, y, text, style);
     }
@@ -99,6 +117,11 @@ export class Geometry {
         let maxY = Number.NEGATIVE_INFINITY;
         features.forEach(feature => {
             const box = feature.box;
+            if (feature instanceof Label
+                && typeof feature.text === 'string'
+                && feature.text.trim().length === 0) {
+                return;
+            }
             if (box.xmin === undefined) {
                 throw "Invalid box!";
             }
@@ -126,6 +149,7 @@ export class Geometry {
         }
         console.log('unknown type', feature);
     }
+    static FullCircleRadians = 2 * Math.PI;
     static featuresToPath(items) {
         const paths = [];
         let isClosedPolygon = false;
@@ -138,11 +162,18 @@ export class Geometry {
                 const x = item.center.x;
                 const y = item.center.y;
                 const radius = item.r;
+                let useEndAngle = item.endAngle;
+                let extraEnd = '';
+                if (item.startAngle === 0 && item.endAngle === Geometry.FullCircleRadians) {
+                    useEndAngle = 359.9999 * Math.PI / 180;
+                    isClosedPolygon = true;
+                    extraEnd = ' Z';
+                }
                 const startPoint = getArcPointRadians(x, y, radius, item.startAngle);
-                const endPoint = getArcPointRadians(x, y, radius, item.endAngle);
+                const endPoint = getArcPointRadians(x, y, radius, 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/build/src/globals.js

@@ -26,7 +26,8 @@ export var SymbolPinSide;
 })(SymbolPinSide || (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';
 export const junctionSize = 5;

package/build/src/helpers.js

@@ -0,0 +1,73 @@
+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, outputPath, options) {
+    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');
+    }
+    const { sequence, nets } = visitor.getGraph();
+    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 = 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;
+}

package/build/src/layout.js

@@ -389,9 +389,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')) {
                         tmpSymbol.refreshDrawing(false);
                         tmpSymbol.angle = calculateSymbolAngle(tmpSymbol, component.parameters.get('_addPin'), component.parameters.get('_addDirection'));
@@ -433,7 +430,20 @@ export class LayoutEngine {
                 graph.setEdge(previousNode, wireName, makeEdgeValue(previousNode, previousPin, wireName, 0, i));
                 previousNode = wireName;
                 previousPin = 1;
-                this.print(SequenceAction.Wire, wireId, JSON.stringify(wireSegments));
+                const wireSegmentsInfo = wireSegments.map(item => {
+                    const tmp = {
+                        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]);
@@ -881,20 +891,23 @@ function applyComponentParamsToSymbol(typeProp, component, symbol) {
     if (typeProp === 'net') {
         symbol.setLabelValue("net_name", component.parameters.get(ParamKeys.net_name));
     }
-    if (component.parameters.has('value')) {
-        let displayString = "";
-        const tmpValue = component.parameters.get('value');
-        if (typeof tmpValue == 'object' && (tmpValue instanceof NumericValue)) {
-            displayString = tmpValue.toDisplayString();
-        }
-        else {
-            displayString = tmpValue;
-        }
-        symbol.setLabelValue('value', displayString);
+    if (component.assignedRefDes !== null) {
+        symbol.setLabelValue("refdes", component.assignedRefDes);
     }
-    symbol.setLabelValue('refdes', component.instanceName);
-    if (component.parameters.has('MPN')) {
-        symbol.setLabelValue('MPN', component.parameters.get('MPN'));
+    for (const [key, value] of component.parameters) {
+        if (key !== 'refdes' && key !== 'net_name') {
+            let useValue;
+            if (typeof value == 'object' && (value instanceof NumericValue)) {
+                useValue = value.toDisplayString();
+            }
+            else if (typeof value === 'number') {
+                useValue = value.toString();
+            }
+            else if (typeof value === 'string') {
+                useValue = value;
+            }
+            symbol.setLabelValue(key, useValue);
+        }
     }
 }
 function calculateSymbolAngle(symbol, pin, direction) {