kisch 1.0.2 → 1.0.4

package/src/{Schematic.js → schematic/Schematic.js}

@@ -1,11 +1,11 @@
 import SymbolLibrary from "./SymbolLibrary.js";
 import fs, {promises as fsp} from "fs";
 import Entity from "./Entity.js";
-import {Point, pointKey, Rect} from "./cartesian-math.js";
-import {findGridPath} from "../src/manhattan-router.js";
-import {isSym, sym, sexpParse, sexpStringify, symName, sexpCallName} from "./sexp.js";
-import {placeRect} from "./place-rect.js";
-import {arrayUnique} from "./js-util.js";
+import {Point, pointKey, Rect} from "../utils/cartesian-math.js";
+import RoutingGrid from "../utils/RoutingGrid.js";
+import {isSym, sym, sexpParse, sexpStringify, symName, sexpCallName} from "../utils/sexp.js";
+import {placeRect} from "../utils/place-rect.js";
+import {arrayUnique} from "../utils/js-util.js";
 
 export default class Schematic {
 	constructor(options) {
@@ -63,59 +63,43 @@ export default class Schematic {
 		await fsp.writeFile(fn,content);
 	}
 
-	getEntities() {
-		return this.entities;
-	}
-
-	sym(ref) {
-		for (let e of this.entities)
-			if (e.getType()=="symbol" && e.getReference()==ref)
-				return e;
+	// filter: type connectionPoint label
+	getEntities(filter={}) {
+		if (filter.label)
+			filter.type="label";
 
-		throw new Error("Undefined symbol reference: "+ref);
-	}
-
-	getSymbolEntities() {
-		let entities=[];
-
-		for (let e of this.entities)
-			if (e.getType()=="symbol")
-				entities.push(e);
+		return this.entities.filter(e=>{
+			if (filter.type && e.getType()!=filter.type)
+				return false;
 
-		return entities;
-	}
+			if (filter.label && e.getLabel()!=filter.label)
+				return false;
 
-	getLabelEntities(label) {
-		let entities=[];
+			if (filter.connectionPoint) {
+				let cp=Point.from(filter.connectionPoint);
+				let found=false;
+				for (let p of e.getConnectionPoints())
+					if (cp.equals(p))
+						found=true;
 
-		for (let e of this.entities)
-			if (e.getType()=="label" && e.getLabel()==label)
-				entities.push(e);
+				if (!found)
+					return false;
+			}
 
-		return entities;
+			return true;
+		});
 	}
 
 	getNets() {
-		let nets=this.getEntities()
-			.filter(e=>e.getType()=="label")
-			.map(e=>e.getLabel());
-
-		nets=arrayUnique(nets);
-
-		return nets;
+		return arrayUnique(this.getEntities({type: "label"}).map(e=>e.getLabel()));
 	}
 
-	getEntitiesByConnectionPoint(connectonPoint) {
-		connectonPoint=Point.from(connectonPoint);
-		let entities=[];
-
-		for (let e of this.entities) {
-			for (let p of e.getConnectionPoints())
-				if (connectonPoint.equals(p))
-					entities.push(e)
-		}
+	sym(ref) {
+		for (let e of this.entities)
+			if (e.getType()=="symbol" && e.getReference()==ref)
+				return e;
 
-		return entities;
+		throw new Error("Undefined symbol reference: "+ref);
 	}
 
 	getConnectionPoints() {
@@ -154,8 +138,8 @@ export default class Schematic {
 			if (visitedPoints.has(key)) continue;
 			visitedPoints.add(key);
 
-			// find all entities touching this point
-			const entities = this.getEntitiesByConnectionPoint(point).filter(e=>e.getType()=="wire");
+			// find all wires touching this point
+			const entities=this.getEntities({type: "wire", connectionPoint: point});
 
 			for (const entity of entities) {
 				const connectionPoints = entity.getConnectionPoints();
@@ -185,29 +169,45 @@ export default class Schematic {
 	}
 
 	addConnectionWire(fromPoint, toPoint) {
-		let connectionPoints=this.getConnectionPoints();
-		connectionPoints=connectionPoints.filter(p=>!p.equals(fromPoint) && !p.equals(toPoint));
-		let avoidRects=connectionPoints.map(p=>new Rect(p.sub([0.635,0.635]),[1.27,1.27]));
-
-		let avoidLines=this.entities.filter(e=>e.getType()=="wire").map(e=>{
-			return ({
-				a: e.getConnectionPoints()[0],
-				b: e.getConnectionPoints()[1],
-			})
-		});
+		//console.log("add connection...");
+
+		let grid=new RoutingGrid({spacing: 1.27});
+		for (let sym of this.getEntities({type: "symbol"})) {
+			let r=sym.getBoundingRect();
+			grid.drawRect(r.getLeft(),r.getTop(),r.getRight(),r.getBottom());
+
+			for (let pin of sym.getPins()) {
+				let point=pin.getPoint();
+				let legPoint=pin.getLegPoint();
+				grid.drawLine(point[0],point[1],legPoint[0],legPoint[1]);
+			}
+		}
+
+		for (let wire of this.getEntities({type: "wire"})) {
+			let [p1,p2]=wire.getConnectionPoints();
+			grid.drawLine(p1[0],p1[1],p2[0],p2[1]);
+		}
+
+		let startPoints=[fromPoint,...this.getConnectedWirePoints(fromPoint)];
+		let goalPoints=[toPoint,...this.getConnectedWirePoints(toPoint)];
 
-		//console.log(avoidLines);
+		for (let p of [...startPoints,...goalPoints])
+			grid.clearPoint(p[0],p[1]);
 
-		let points=findGridPath({
-			from: fromPoint,
-			to: toPoint,
-			gridSize: 1.27,
-			avoidRects: avoidRects,
-			avoidLines: avoidLines
+		let stats={};
+		let points=grid.findPath({
+			start: startPoints.map(p=>({x: p[0], y: p[1]})),
+			goal: goalPoints.map(p=>({x: p[0], y: p[1]})),
+			stats
 		});
 
+		//console.log("steps: "+stats.steps);
+
+		this.addJunctionIfNeeded(new Point(points[0]));
+		this.addJunctionIfNeeded(new Point(points[points.length-1]));
+
 		for (let i=0; i<points.length-1; i++) {
-			let p1=points[i], p2=points[i+1];
+			let p1=new Point(points[i]), p2=new Point(points[i+1]);
 			let expr=[sym("wire"),
 				[sym("pts"), [sym("xy"),p1[0],p1[1]], [sym("xy"),p2[0],p2[1]]],
 				[sym("stroke"), [sym("width"),0], [sym("type"), sym("default")]],
@@ -219,6 +219,98 @@ export default class Schematic {
 		}
 	}
 
+	addJunctionIfNeeded(p) {
+		p=new Point(p);
+		if (this.getEntities({connectionPoint: p, type: "symbol"}).length)
+			return;
+
+		this.splitWire(p);
+		this.addJunction(p);
+	}
+
+	splitWire(p) {
+		for (let e of this.getEntities({type: "wire"})) {
+			if (e.containsPoint(p)) {
+				let cp=e.getConnectionPoints();
+				let seg1=this.drawWireLine(cp[0],p);
+				let seg2=this.drawWireLine(p,cp[1]);
+				seg1.declared=e.declared;
+				seg2.declared=e.declared;
+				this.removeEntity(e);
+				//console.log("found it!!");
+				return;
+			}
+		}
+
+		throw new Error("No wire to split");
+	}
+
+	addJunction(p) {
+		let expr=[sym("junction"),
+			[sym("at"),p[0],p[1]],
+			[sym("diameter"),0],
+			[sym("color"),0,0,0,0],
+			[sym("uuid"),crypto.randomUUID()]
+		];
+
+		let e=new Entity(expr,this);
+		this.entities.push(e);
+	}
+
+	getConnectedWires(connectionPoint) {
+		let points=[Point.from(connectionPoint)];
+		let entities=[];
+
+		while (points.length) {
+			let p=Point.from(points.pop());
+			//console.log(p);
+			for (let e of this.getEntities({type: "wire", connectionPoint: p})) {
+				if (!entities.includes(e)) {
+					entities.push(e);
+					points.push(...e.getConnectionPoints());
+				}
+			}
+		}
+
+		return entities;
+	}
+
+	getConnectedWirePoints(connectionPoint) {
+		let wires=this.getConnectedWires(connectionPoint);
+		let grid=new RoutingGrid({spacing: 1.27});
+		for (let w of wires) {
+			let p=w.getConnectionPoints();
+			grid.drawLine(p[0][0],p[0][1],p[1][0],p[1][1]);
+		}
+
+		return grid.getPoints().map(p=>[p.x,p.y]);
+	}
+
+	drawWireLine(p1, p2) {
+		let expr=[sym("wire"),
+			[sym("pts"), [sym("xy"),p1[0],p1[1]], [sym("xy"),p2[0],p2[1]]],
+			[sym("stroke"), [sym("width"),0], [sym("type"), sym("default")]],
+			[sym("uuid"),crypto.randomUUID()]
+		];
+
+		let e=new Entity(expr,this);
+		this.entities.push(e);
+
+		return e;
+	}
+
+	drawWireRect(r) {
+		this.drawWireLine([r.getLeft(),r.getTop()], [r.getRight(),r.getTop()]);
+		this.drawWireLine([r.getRight(),r.getTop()], [r.getRight(),r.getBottom()]);
+		this.drawWireLine([r.getRight(),r.getBottom()], [r.getLeft(),r.getBottom()]);
+		this.drawWireLine([r.getLeft(),r.getBottom()], [r.getLeft(),r.getTop()]);
+	}
+
+	drawWirePoint(p) {
+		p=new Point(p);
+		this.drawWireRect(new Rect(p.sub([0.25,0.25]),[0.5,0.5]));
+	}
+
 	addLabel(point, label) {
 		let expr=[sym("label"),label,
 			[sym("at"),point[0],point[1],180],
@@ -235,8 +327,6 @@ export default class Schematic {
 	}
 
 	getLibSymbolsExp() {
-		//return sexpFirst(this.sexpr,x=>sexpCallName(x)=="lib_symbols")
-
 		for (let exp of this.sexp)
 			if (sexpCallName(exp)=="lib_symbols")
 				return exp;
@@ -264,12 +354,6 @@ export default class Schematic {
 		libSymbolsExpr.push(librarySymbol.getQualifiedSexpr());
 	}
 
-	async use(...symbols) {
-		symbols=symbols.flat(Infinity);
-		for (let symbol of symbols)
-			await this.ensureLibSymbol(symbol);
-	}
-
 	declare(ref, options) {
 		let entity=this.entities.find(e=>e.getType()=="symbol" && e.getReference()==ref);
 		if (!entity)
@@ -281,6 +365,22 @@ export default class Schematic {
 		this.ensureLibSymbolSync(options.symbol);
 
 		entity.setFootprint(options.footprint);
+
+		if (options.name)
+			entity.setName(options.name);
+
+		if (options.lcsc)
+			entity.setProp("lcsc",options.lcsc);
+
+		else
+			entity.removeProp("lcsc");
+
+		if (options.lcscRot)
+			entity.setProp("lcscRot",String(options.lcscRot));
+
+		else
+			entity.removeProp("lcscRot");
+
 		entity.declared=true;
 
 		return entity;
@@ -295,19 +395,22 @@ export default class Schematic {
 		let librarySymbol=this.symbolLibrary.loadLibrarySymbolSync(symbol);
 
 		//let librarySymbol=await this.symbolLibrary.loadLibrarySymbol(symbol);
-		let rects=this.getSymbolEntities().map(e=>e.getBoundingRect().pad(2.54*4));
+		let rects=this.getEntities({type: "symbol"}).map(e=>e.getBoundingRect().pad(2.54*4));
 
 		let center=new Point(101.6,101.6);
 		if (rects.length)
 			center=rects.reduce((r,q)=>r.union(q)).getCenter().snap(2.54);
 
 		if (!at) {
+			//console.log("place: ",librarySymbol.getBoundingRect());
+			//console.log(rects);
 			at=placeRect({
 				start: center,
 				rect: librarySymbol.getBoundingRect(),
 				avoid: rects,
 				step: 2.54,
 			});
+			//console.log("placed!");
 		}
 
 		let expr=[sym("symbol"),
@@ -351,6 +454,12 @@ export default class Schematic {
 
 	markConnectionDeclared(from, to) {
 		let wires=this.getConnectionPath(from,to);
+		if (!wires) {
+			console.log("wires?");
+			console.log(wires);
+			return;
+		}
+
 		for (let wire of wires) {
 			if (wire.getType()!="wire")
 				throw new Error("Sanity check... Wire is not a wire...");
@@ -361,6 +470,9 @@ export default class Schematic {
 
 	removeUndeclared() {
 		this.entities=this.entities.filter(entity=>{
+			if (entity.type=="junction")
+				return true;
+
 			return entity.declared;
 		});
 	}
@@ -368,7 +480,7 @@ export default class Schematic {
 	getSource() {
 		let src="";
 		src+=`export default async function(sch) {\n`;
-		for (let e of this.getSymbolEntities()) {
+		for (let e of this.getEntities({type: "symbol"})) {
 			src+=`    let ${e.getReference()}=sch.declare("${e.getReference()}",{\n`;
 			src+=`        "symbol": "${e.getLibId()}",\n`
 			src+=`        "footprint": "${e.getFootprint()}",\n`
@@ -376,7 +488,7 @@ export default class Schematic {
 		}
 
 		let allConnectionPoints=this.getConnectionPoints();
-		for (let e of this.getSymbolEntities()) {
+		for (let e of this.getEntities({type: "symbol"})) {
 			for (let pin of e.pins) {
 				for (let c of pin.getConnections()) {
 					if (typeof c=="string") {
@@ -398,6 +510,10 @@ export default class Schematic {
 
 		return src;
 	}
+
+	removeEntity(removable) {
+		this.entities=this.entities.filter(e=>e!=removable);
+	}
 }
 
 export async function loadSchematic(fn, options) {

package/src/{SymbolLibrary.js → schematic/SymbolLibrary.js}

@@ -1,7 +1,7 @@
 import fs, {promises as fsp} from "fs";
 import path from "path";
 import LibrarySymbol from "./LibrarySymbol.js";
-import {sexpParse, sym, isSym, symEq} from "../src/sexp.js";
+import {sexpParse, sym, isSym, symEq} from "../utils/sexp.js";
 
 /**
  * SymbolLibrary represents a directory of .kicad_sym files.

package/src/utils/RoutingGrid.js

@@ -0,0 +1,260 @@
+import {arrayGetMinIndex, arrayGetMaxIndex} from "./js-util.js";
+import {collapsePath, manhattanDist} from "./grid-util.js";
+import {astar} from "./astar.js";
+
+export default class RoutingGrid {
+	constructor({spacing}={spacing: 1}) {
+		this.grid=[];
+		this.spacing=spacing;
+	}
+
+	snap(v) {
+		return Math.round(v/this.spacing);
+	}
+
+	unsnap(v) {
+		return v*this.spacing;
+	}
+
+	getGrid(x, y) {
+		if (!this.grid[y] || !this.grid[y][x])
+			return {};
+
+		return this.grid[y][x];
+	}
+
+	updateGrid(x, y, update) {
+		//console.log(x+","+y);
+		if (!this.grid[y])
+			this.grid[y]=[];
+
+		if (!this.grid[y][x])
+			this.grid[y][x]={};
+
+		this.grid[y][x]={...this.grid[y][x], ...update};
+	}
+
+	drawPoint(x, y) {
+		x=this.snap(x);
+		y=this.snap(y);
+		this.updateGrid(x,y,{b: true});
+	}
+
+	clearPoint(x, y) {
+		x=this.snap(x);
+		y=this.snap(y);
+		this.updateGrid(x,y,{b: false});
+	}
+
+	drawHorizontalLine(x, y, x2) {
+		x=this.snap(x);
+		y=this.snap(y);
+		x2=this.snap(x2);
+
+		if (x2<x) { let v=x; x=x2; x2=v; }
+		for (let i=x; i<x2; i++)
+			this.updateGrid(i,y,{h: true});
+	}
+
+	drawVerticalLine(x, y, y2) {
+		x=this.snap(x);
+		y=this.snap(y);
+		y2=this.snap(y2);
+
+		if (y2<y) { let v=y; y=y2; y2=v; }
+		for (let i=y; i<y2; i++)
+			this.updateGrid(x,i,{v: true});
+	}
+
+	drawLine(x1, y1, x2, y2) {
+		if (y1==y2)
+			this.drawHorizontalLine(x1,y2,x2);
+
+		else if (x1==x2)
+			this.drawVerticalLine(x1,y1,y2);
+
+		else
+			throw new Error("can only draw h/v");
+
+		this.drawPoint(x1,y1);
+		this.drawPoint(x2,y2);
+	}
+
+	drawLines(points) {
+		for (let i=0; i<points.length-1; i++) {
+			this.drawLine(
+				points[i].x,
+				points[i].y,
+				points[i+1].x,
+				points[i+1].y,
+			)
+		}
+	}
+
+	drawRect(x1, y1, x2, y2) {
+		x1=this.snap(x1);
+		y1=this.snap(y1);
+		x2=this.snap(x2);
+		y2=this.snap(y2);
+
+		if (x2<x1) { let v=x1; x1=x2; x2=v; }
+		if (y2<y1) { let v=y1; y1=y2; y2=v; }
+		for (let y=y1; y<=y2; y++) {
+			for (let x=x1; x<=x2; x++) {
+				this.updateGrid(x,y,{b: true});
+
+				if (x!=x2)
+					this.updateGrid(x,y,{h: true});
+
+				if (y!=y2)
+					this.updateGrid(x,y,{v: true});
+			}
+		}
+	}
+
+	getTop() {
+		return arrayGetMinIndex(this.grid);
+	}
+
+	getBottom() {
+		return arrayGetMaxIndex(this.grid);
+	}
+
+	getLeft() {
+		let min;
+		for (let y=arrayGetMinIndex(this.grid); y<=arrayGetMaxIndex(this.grid); y++) {
+			if (this.grid[y]) {
+				if (min===undefined || arrayGetMinIndex(this.grid[y])<min)
+					min=arrayGetMinIndex(this.grid[y]);
+			}
+		}
+
+		return min;
+	}
+
+	getRight() {
+		let max;
+		for (let y=arrayGetMinIndex(this.grid); y<=arrayGetMaxIndex(this.grid); y++) {
+			if (this.grid[y]) {
+				//console.log(y+" "+arrayGetMaxIndex(this.grid[y]),this.grid[y],Object.keys(this.grid[y]));
+				if (max===undefined || arrayGetMaxIndex(this.grid[y])>max)
+					max=arrayGetMaxIndex(this.grid[y]);
+			}
+		}
+
+		return max;
+	}
+
+	toGridString() {
+		let s="";
+
+		for (let y=this.getTop(); y<=this.getBottom(); y++) {
+			for (let x=this.getLeft(); x<=this.getRight(); x++)
+				s+=((this.getGrid(x,y).b?"*":"+")+(this.getGrid(x,y).h?"-":" "));
+
+			s+="\n";
+
+			for (let x=this.getLeft(); x<=this.getRight(); x++)
+				s+=(this.getGrid(x,y).v?"|":" ")+" ";
+
+			s+="\n";
+		}
+
+		return s;
+	}
+
+	findPath({start, goal, stats}) {
+		start=start.map(p=>({x: this.snap(p.x), y: this.snap(p.y)}));
+		goal=goal.map(p=>({x: this.snap(p.x), y: this.snap(p.y)}));
+
+		let neighbours=(g)=>{
+			let n=[];
+
+			if (g=="start")
+				return start;
+
+			if (!this.getGrid(g.x,g.y).h &&
+					!this.getGrid(g.x+1,g.y).b)
+				n.push({x: g.x+1, y: g.y, from: "w"});
+
+			if (!this.getGrid(g.x-1,g.y).h &&
+					!this.getGrid(g.x-1,g.y).b)
+				n.push({x: g.x-1, y: g.y, from: "e"});
+
+			if (!this.getGrid(g.x,g.y).v &&
+					!this.getGrid(g.x,g.y+1).b)
+				n.push({x: g.x, y: g.y+1, from: "n"});
+
+			if (!this.getGrid(g.x,g.y-1).v &&
+					!this.getGrid(g.x,g.y-1).b)
+				n.push({x: g.x, y: g.y-1, from: "s"});
+
+			return n;
+		}
+
+		let cost=(g1, g2)=>{
+			if (g1.from==g2.from)
+				return 1;
+
+			return 20;
+		}
+
+		let heuristic=(node)=>{
+			if (node=="start")
+				return 0;
+
+			let closest;
+			for (let g of goal) {
+				let d=manhattanDist(node.x,node.y,g.x,g.y);
+				if (closest===undefined || d<closest)
+					closest=d;
+			}
+
+			return closest;
+		}
+
+		let key=(g)=>{
+			if (g=="start")
+				return "start";
+
+			return `${g.x}|${g.y}|${g.from??""}`;
+		}
+
+		let isGoal=g=>{
+			for (let p of goal)
+				if (p.x==g.x && p.y==g.y)
+					return true;
+		}
+
+		let steps=astar({
+			start: "start",
+			neighbours,
+			isGoal, //: g=>(g.x==goal.x && g.y==goal.y),
+			cost,
+			heuristic,
+			key,
+			stats
+		});
+
+		steps=steps.filter(i=>i!="start");
+
+		return collapsePath(steps).map(p=>({x: this.unsnap(p.x), y: this.unsnap(p.y)}));
+	}
+
+	getPoints() {
+		let points=[];
+
+		for (let y=arrayGetMinIndex(this.grid); y<=arrayGetMaxIndex(this.grid); y++) {
+			let row=this.grid[y];
+			if (row) {
+				for (let x=arrayGetMinIndex(row); x<=arrayGetMaxIndex(row); x++) {
+					let g=this.getGrid(x,y)
+					if (g.b || g.h || g.v)
+						points.push({x,y});
+				}
+			}
+		}
+
+		return points.map(p=>({x: this.unsnap(p.x), y: this.unsnap(p.y)}));
+	}
+}