@slithy/prim-lib 0.3.0 → 0.3.2

package/dist/index.d.ts

@@ -38,6 +38,7 @@ interface Cfg {
     alpha: number;
     mutateAlpha: boolean;
     shapeTypes: Array<new (w: number, h: number) => ShapeInterface>;
+    shapeWeights?: number[];
     shapes: number;
     mutations: number;
     steps: number;
@@ -166,6 +167,7 @@ declare class Step {
     mutate(): Step;
 }
 
+type ShapeCtor = new (w: number, h: number) => ShapeInterface;
 declare class Optimizer {
     cfg: Cfg;
     state: State;
@@ -173,6 +175,7 @@ declare class Optimizer {
     _steps: number;
     _stopped: boolean;
     _paused: boolean;
+    _stepPlan: ShapeCtor[];
     constructor(original: Canvas, cfg: Cfg);
     start(): void;
     stop(): void;

package/dist/index.js

@@ -349,6 +349,16 @@ var Shape = class {
   }
   static create(cfg) {
     const ctors = cfg.shapeTypes;
+    const weights = cfg.shapeWeights;
+    if (weights && weights.length === ctors.length) {
+      const total = weights.reduce((sum, w) => sum + w, 0);
+      let r = Math.random() * total;
+      for (let i = 0; i < weights.length; i++) {
+        r -= weights[i];
+        if (r <= 0) return new ctors[i](cfg.width, cfg.height);
+      }
+      return new ctors[ctors.length - 1](cfg.width, cfg.height);
+    }
     const index = Math.floor(Math.random() * ctors.length);
     const ctor = ctors[index];
     return new ctor(cfg.width, cfg.height);
@@ -844,6 +854,22 @@ var Debug = class extends Shape {
 };
 
 // src/optimizer.ts
+function buildStepPlan(cfg) {
+  const { shapeTypes, shapeWeights, steps } = cfg;
+  if (!shapeWeights || shapeWeights.length !== shapeTypes.length) return [];
+  const total = shapeWeights.reduce((sum, w) => sum + w, 0);
+  const floats = shapeWeights.map((w) => w / total * steps);
+  const floors = floats.map(Math.floor);
+  const remainder = steps - floors.reduce((s, n) => s + n, 0);
+  const indices = floats.map((f, i) => ({ i, frac: f - floors[i] })).sort((a, b) => b.frac - a.frac).slice(0, remainder).map((x) => x.i);
+  const counts = floors.map((n, i) => indices.includes(i) ? n + 1 : n);
+  const plan = shapeTypes.flatMap((ctor, i) => Array(counts[i]).fill(ctor));
+  for (let i = plan.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [plan[i], plan[j]] = [plan[j], plan[i]];
+  }
+  return plan;
+}
 var Optimizer = class {
   cfg;
   state;
@@ -851,6 +877,7 @@ var Optimizer = class {
   _steps;
   _stopped;
   _paused;
+  _stepPlan;
   constructor(original, cfg) {
     this.cfg = cfg;
     this.state = new State(original, Canvas.empty(cfg));
@@ -859,6 +886,7 @@ var Optimizer = class {
     this._paused = false;
     this.onStep = () => {
     };
+    this._stepPlan = buildStepPlan(cfg);
   }
   start() {
     this._stopped = false;
@@ -899,10 +927,11 @@ var Optimizer = class {
   }
   _findBestStep() {
     const LIMIT = this.cfg.shapes;
+    const ctor = this._stepPlan[this._steps];
     let bestStep = null;
     const promises = [];
     for (let i = 0; i < LIMIT; i++) {
-      const shape = Shape.create(this.cfg);
+      const shape = ctor ? new ctor(this.cfg.width, this.cfg.height) : Shape.create(this.cfg);
       const promise = new Step(shape, this.cfg).compute(this.state).then((step) => {
         if (!bestStep || step.distance < bestStep.distance) {
           bestStep = step;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slithy/prim-lib",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Core engine for primitive-based image reconstruction.",
   "type": "module",
   "exports": {