@openbraininstitute/morphoviewer 0.0.1 → 0.24.18

package/lib/dist/components/morpho-viewer-simul/painter/painters/overlay/overlay.js

@@ -0,0 +1,114 @@
+import { TgdColor, TgdPainterGroup, TgdPainterOverlay, TgdTexture2D, tgdCalcClamp, tgdCanvasCreate, tgdCanvasCreateWithContext2D, } from "@tolokoban/tgd";
+import { TIMELINE_HEIGHT, TIMELINE_MARGIN } from "./../../../contants.js";
+import { PainterCursor } from "./cursor/index.js";
+import { FramebufferTicks } from "./ticks.js";
+export class PainterSpikingOverlay extends TgdPainterGroup {
+    constructor(context, spikingManager) {
+        super({ name: "PainterSpikingOverlay" });
+        this.context = context;
+        this.spikingManager = spikingManager;
+        this.actualWidth = 0;
+        this.actualHeight = 0;
+        this.handleTap = (evt) => {
+            this.setCursor(evt.x);
+        };
+        this.handleMove = (evt) => {
+            this.setCursor(evt.current.x);
+            return true;
+        };
+        this.handleStopPropagation = () => true;
+        this.refresh = () => {
+            const spike = this.spikingManager.spike;
+            if (spike) {
+                this.active = true;
+                this.context.paintOneTime({
+                    paint: (time, delta) => {
+                        var _a;
+                        (_a = this.painterOverlay.texture) === null || _a === void 0 ? void 0 : _a.loadBitmap(this.makeCapsule());
+                        this.painterTicks.spike = spike;
+                        this.painterTicks.paint(time, delta);
+                    },
+                });
+            }
+            else {
+                this.active = false;
+                this.context.pause();
+            }
+            this.context.paint();
+        };
+        this.painterCursor = new PainterCursor(context, spikingManager);
+        const texture = new TgdTexture2D(context).loadBitmap(tgdCanvasCreate(1, 1));
+        const overlay = new TgdPainterOverlay(context, {
+            alignX: +1,
+            alignY: -1,
+            margin: TIMELINE_MARGIN,
+            width: undefined,
+            height: TIMELINE_HEIGHT,
+            texture,
+        });
+        this.painterOverlay = overlay;
+        this.painterTicks = new FramebufferTicks(context, { texture });
+        overlay.eventResize.addListener(({ width, height }) => {
+            this.actualWidth = width;
+            this.actualHeight = height;
+            this.refresh();
+        });
+        overlay.eventMoveStart.addListener(this.handleStopPropagation);
+        overlay.eventMoveEnd.addListener(this.handleStopPropagation);
+        overlay.eventTap.addListener(this.handleTap);
+        overlay.eventMove.addListener(this.handleMove);
+        spikingManager.eventSpikeChange.addListener(this.refresh);
+        this.add(overlay, this.painterCursor);
+    }
+    setCursor(cursorX) {
+        const [_top, right, _bottom, left] = TIMELINE_MARGIN;
+        const width = this.context.width - left - right;
+        const height = TIMELINE_HEIGHT;
+        const x = ((width + height) * cursorX) / width;
+        const normalizedX = tgdCalcClamp(0.5 * (1 + x), 0, 1);
+        this.spikingManager.progress = normalizedX;
+        this.refresh();
+    }
+    delete() {
+        var _a;
+        this.painterTicks.delete();
+        (_a = this.painterOverlay.texture) === null || _a === void 0 ? void 0 : _a.delete();
+        this.painterOverlay.eventTap.addListener(this.handleTap);
+        this.painterOverlay.eventMove.addListener(this.handleMove);
+        this.painterOverlay.eventMoveStart.removeListener(this.handleStopPropagation);
+        this.painterOverlay.eventMoveEnd.removeListener(this.handleStopPropagation);
+        this.painterOverlay.delete();
+        this.spikingManager.eventSpikeChange.removeListener(this.refresh);
+        super.delete();
+    }
+    makeCapsule() {
+        const { actualWidth: width, actualHeight: height, spikingManager } = this;
+        const color = spikingManager.color.toString();
+        const { canvas, ctx } = tgdCanvasCreateWithContext2D(width, height);
+        ctx.clearRect(0, 0, width, height);
+        ctx.lineWidth = 1;
+        const gradFill = ctx.createLinearGradient(0, 0, 0, height);
+        gradFill.addColorStop(0, setAlpha(color, 0.0));
+        gradFill.addColorStop(0.5, setAlpha(color, 0.05));
+        gradFill.addColorStop(1, setAlpha(color, 0.2));
+        const gradStroke = ctx.createLinearGradient(0, 0, 0, height);
+        gradStroke.addColorStop(0, setAlpha(color, 0.2));
+        gradStroke.addColorStop(1, setAlpha(color, 0));
+        ctx.fillStyle = gradFill;
+        ctx.strokeStyle = gradStroke;
+        ctx.beginPath();
+        ctx.roundRect(1.5, 1.5, width - 4, height - 4, (height - 4) / 2);
+        ctx.fill();
+        ctx.stroke();
+        return canvas;
+    }
+}
+function setAlpha(cssColor, alpha) {
+    const color = new TgdColor(cssColor);
+    color.rgb2hsl();
+    color.L = alpha / 2;
+    color.hsl2rgb();
+    color.A = 1;
+    return color.toString();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/dist/components/morpho-viewer-simul/painter/painters/overlay/ticks.d.ts

@@ -0,0 +1,24 @@
+import { TgdContext, TgdEvent, TgdPainterFramebuffer, TgdPainterProgram, TgdTexture2D } from "@tolokoban/tgd";
+import { MorphoViewerSpikeRecord } from "../../../types/public";
+export interface FramebufferTicksOptions {
+    texture: TgdTexture2D;
+}
+export declare class FramebufferTicks extends TgdPainterFramebuffer {
+    readonly context: TgdContext;
+    readonly eventNeedsRefresh: TgdEvent<void>;
+    private readonly ticks;
+    constructor(context: TgdContext, { texture }: FramebufferTicksOptions);
+    get spike(): MorphoViewerSpikeRecord | undefined;
+    set spike(spike: MorphoViewerSpikeRecord | undefined);
+}
+export declare class PainterTicks extends TgdPainterProgram {
+    readonly context: TgdContext;
+    private _spike;
+    private readonly uniformBlock;
+    private readonly dataset;
+    constructor(context: TgdContext);
+    get spike(): MorphoViewerSpikeRecord | undefined;
+    set spike(spike: MorphoViewerSpikeRecord | undefined);
+    paint(time: number, delta: number): void;
+}
+//# sourceMappingURL=ticks.d.ts.map

package/lib/dist/components/morpho-viewer-simul/painter/painters/overlay/ticks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ticks.d.ts","sourceRoot":"","sources":["../../../../../../src/components/morpho-viewer-simul/painter/painters/overlay/ticks.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,UAAU,EAEV,QAAQ,EACR,qBAAqB,EACrB,iBAAiB,EACjB,YAAY,EAEb,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,uBAAuB,EAAE,MAAM,+CAA+C,CAAC;AAExF,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,YAAY,CAAC;CACvB;AAED,qBAAa,gBAAiB,SAAQ,qBAAqB;aAMvC,OAAO,EAAE,UAAU;IALrC,SAAgB,iBAAiB,iBAAkB;IAEnD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;gBAGnB,OAAO,EAAE,UAAU,EACnC,EAAE,OAAO,EAAE,EAAE,uBAAuB;IAWtC,IAAI,KAAK,IAAI,uBAAuB,GAAG,SAAS,CAE/C;IACD,IAAI,KAAK,CAAC,KAAK,EAAE,uBAAuB,GAAG,SAAS,EAInD;CACF;AAKD,qBAAa,YAAa,SAAQ,iBAAiB;aAOrB,OAAO,EAAE,UAAU;IAN/C,OAAO,CAAC,MAAM,CAAkD;IAChE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAE3B;IACF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAa;gBAET,OAAO,EAAE,UAAU;IAgF/C,IAAI,KAAK,IAAI,uBAAuB,GAAG,SAAS,CAE/C;IACD,IAAI,KAAK,CAAC,KAAK,EAAE,uBAAuB,GAAG,SAAS,EAmBnD;IAED,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;CAGzC"}

package/lib/dist/components/morpho-viewer-simul/painter/painters/overlay/ticks.js

@@ -0,0 +1,127 @@
+import { TgdColor, TgdDataset, TgdEvent, TgdPainterFramebuffer, TgdPainterProgram, TgdUniformBufferObject, } from "@tolokoban/tgd";
+export class FramebufferTicks extends TgdPainterFramebuffer {
+    constructor(context, { texture }) {
+        const ticks = new PainterTicks(context);
+        super(context, {
+            textureColor0: texture,
+            fixedSize: true,
+            children: [ticks],
+        });
+        this.context = context;
+        this.eventNeedsRefresh = new TgdEvent();
+        this.ticks = ticks;
+    }
+    get spike() {
+        return this.ticks.spike;
+    }
+    set spike(spike) {
+        if (this.ticks.spike === spike)
+            return;
+        this.ticks.spike = spike;
+    }
+}
+export class PainterTicks extends TgdPainterProgram {
+    constructor(context) {
+        const datasetTicks = new TgdDataset({
+            attShift: "float",
+        }, {
+            divisor: 1,
+            usage: "DYNAMIC_DRAW",
+        });
+        const uniformBlock = new TgdUniformBufferObject(context, {
+            uniforms: {
+                uniSize: "float",
+                uniScale: "vec2",
+                uniPower: "float",
+                uniColor: "vec4",
+            },
+        });
+        super(context, {
+            drawMode: "TRIANGLE_STRIP",
+            uniforms: {
+                uniformBlock,
+            },
+            state: {
+                depth: "off",
+                cull: "off",
+                blend: "add",
+            },
+            varying: {
+                varCorner: "vec2",
+            },
+            dataset: [
+                datasetTicks,
+                {
+                    attribs: {
+                        attCorner: {
+                            type: "vec2",
+                            data: new Float32Array([+1, -1, +1, +1, -1, -1, -1, +1]),
+                        },
+                    },
+                },
+            ],
+            vert: {
+                mainCode: [
+                    "varCorner = attCorner;",
+                    "gl_Position = vec4(",
+                    [
+                        "attShift * uniScale.x + uniSize * attCorner.x,",
+                        "uniScale.y * attCorner.y,",
+                        "0,",
+                        "1",
+                    ],
+                    ");",
+                ],
+            },
+            frag: {
+                mainCode: [
+                    "float x = abs(varCorner.x);",
+                    "float y = abs(varCorner.y);",
+                    "float dx = max(1.0 - pow(x, 0.125), 0.0);",
+                    "float dy = max(1.0 - pow(y, 1.0), 0.0);",
+                    "float strength = 2.0 * dx * dy;",
+                    "FragColor = vec4(uniColor.rgb * strength, 1.0);",
+                ],
+            },
+            onEnter: () => {
+                const radius = 32;
+                const { width, height } = context;
+                uniformBlock.values.uniSize = radius / width;
+                uniformBlock.values.uniScale = new Float32Array([
+                    (width - height) / width,
+                    (height - 4) / height,
+                ]);
+                uniformBlock.values.uniPower = 1000 / (width - height);
+            },
+        });
+        this.context = context;
+        this._spike = undefined;
+        this.uniformBlock = uniformBlock;
+        this.dataset = datasetTicks;
+    }
+    get spike() {
+        return this._spike;
+    }
+    set spike(spike) {
+        if (this._spike === spike)
+            return;
+        this._spike = spike;
+        if (!spike)
+            return;
+        const squash = (v) => 0.2 + v * 0.8;
+        const color = TgdColor.fromString(spike.color);
+        color.R = squash(color.R);
+        color.G = squash(color.G);
+        color.B = squash(color.B);
+        this.uniformBlock.values.uniColor = color.toVec4();
+        const { dataset } = this;
+        const inverseSize = 1 / (spike.timeMaxInSeconds - spike.timeMinInSeconds);
+        const data = spike.spikesInSeconds.map((t) => 2 * (t - spike.timeMinInSeconds) * inverseSize - 1);
+        this.setAttributeValues(dataset, "attShift", new Float32Array(data));
+        this.context.paint();
+    }
+    paint(time, delta) {
+        super.paint(time, delta);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/dist/components/morpho-viewer-simul/painter/painters/painter.d.ts

@@ -0,0 +1,28 @@
+import { type TgdContext, TgdPainterGroup, type TgdPainterSegmentsData } from "@tolokoban/tgd";
+import type { MorphoViewerSynapsesGroup } from "../../types/public";
+import type { MorphologyData } from "../morphology-data";
+import { SpikingManager } from "../spiking-manager";
+export declare class Painter extends TgdPainterGroup {
+    private readonly context;
+    private readonly data;
+    private _minRadius;
+    private readonly groupSegments;
+    private readonly groupSynapses;
+    private readonly groupHover;
+    private readonly painterSpiking;
+    private readonly palette;
+    private _painterSegments;
+    private _mix;
+    private _synapses;
+    private _spike;
+    constructor(context: TgdContext, data: MorphologyData, spikingManager: SpikingManager);
+    get minRadius(): number;
+    set minRadius(minRadius: number);
+    get mix(): number;
+    set mix(value: number);
+    get synapses(): MorphoViewerSynapsesGroup[];
+    set synapses(synapses: MorphoViewerSynapsesGroup[]);
+    highlight(segments: TgdPainterSegmentsData | null | undefined): void;
+    delete(): void;
+}
+//# sourceMappingURL=painter.d.ts.map

package/lib/dist/components/morpho-viewer-simul/painter/painters/painter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"painter.d.ts","sourceRoot":"","sources":["../../../../../src/components/morpho-viewer-simul/painter/painters/painter.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,UAAU,EAKf,eAAe,EAEf,KAAK,sBAAsB,EAQ5B,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAA2B,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAC7F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAOpD,qBAAa,OAAQ,SAAQ,eAAe;IAqBxC,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,IAAI;IArBvB,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAE3B;IACH,OAAO,CAAC,QAAQ,CAAC,aAAa,CAE3B;IACH,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAyB;IACpD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiB;IAChD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IACvC,OAAO,CAAC,gBAAgB,CAA2C;IAKnE,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,SAAS,CAAmC;IACpD,OAAO,CAAC,MAAM,CAAkD;gBAG7C,OAAO,EAAE,UAAU,EACnB,IAAI,EAAE,cAAc,EACrC,cAAc,EAAE,cAAc;IAmDhC,IAAI,SAAS,IAAI,MAAM,CAEtB;IACD,IAAI,SAAS,CAAC,SAAS,EAAE,MAAM,EAK9B;IAED,IAAI,GAAG,IAIQ,MAAM,CAFpB;IAED,IAAI,GAAG,CAAC,KAAK,EAAE,MAAM,EAWpB;IAED,IAAI,QAAQ,IAIW,yBAAyB,EAAE,CAFjD;IAED,IAAI,QAAQ,CAAC,QAAQ,EAAE,yBAAyB,EAAE,EAYjD;IAED,SAAS,CAAC,QAAQ,EAAE,sBAAsB,GAAG,IAAI,GAAG,SAAS;IAS7D,MAAM;CAMP"}

package/lib/dist/components/morpho-viewer-simul/painter/painters/painter.js

@@ -0,0 +1,136 @@
+import { TgdGeometrySphereIco, TgdLight, TgdMaterialDiffuse, TgdMaterialGhost, TgdPainterGroup, TgdPainterMesh, TgdPainterSegmentsMorphing, TgdPainterState, TgdTexture2D, TgdVec3, tgdCanvasCreatePalette, webglPresetBlend, webglPresetDepth, } from "@tolokoban/tgd";
+import { PALETTE } from "./contants.js";
+import { PainterHover as PainterHighlight } from "./highlight.js";
+import { PainterSpikingOverlay } from "./overlay/index.js";
+import { PainterSpiking } from "./spiking/index.js";
+import { PainterSynapses } from "./synapses.js";
+export class Painter extends TgdPainterGroup {
+    constructor(context, data, spikingManager) {
+        super();
+        this.context = context;
+        this.data = data;
+        this._minRadius = 2;
+        this.groupSegments = new TgdPainterGroup({
+            name: "GroupSegments",
+        });
+        this.groupSynapses = new TgdPainterGroup({
+            name: "GroupSynapses",
+        });
+        this.groupHover = new TgdPainterGroup();
+        this._painterSegments = null;
+        this._mix = 0;
+        this._synapses = [];
+        this._spike = undefined;
+        this.palette = new TgdTexture2D(context).loadBitmap(tgdCanvasCreatePalette(PALETTE)).setParams({
+            magFilter: "NEAREST",
+            minFilter: "NEAREST",
+        });
+        this.add(new TgdPainterState(context, {
+            depth: webglPresetDepth.less,
+            blend: "off",
+            cull: "back",
+            children: [this.groupSegments, this.groupHover],
+        }));
+        const { dataset3D, datasetDendrogram } = data;
+        const material = new TgdMaterialDiffuse({
+            color: this.palette,
+            specularExponent: 1,
+            specularIntensity: 0.25,
+            lockLightsToCamera: true,
+            light: new TgdLight({
+                direction: new TgdVec3(0, 0, -1),
+            }),
+        });
+        const painterSegments = new TgdPainterSegmentsMorphing(context, {
+            roundness: 18,
+            datasetsPairs: [[dataset3D, datasetDendrogram]],
+            material,
+        });
+        painterSegments.mix = this.mix;
+        this._painterSegments = painterSegments;
+        const painterSpiking = new PainterSpiking(context, data, spikingManager);
+        this.painterSpiking = painterSpiking;
+        const painterSpikingOverlay = new PainterSpikingOverlay(context, spikingManager);
+        this.groupSegments.add(painterSegments, this.groupSynapses, painterSpiking, new TgdPainterState(context, {
+            depth: "off",
+            blend: "alpha",
+            cull: "off",
+            children: [painterSpikingOverlay],
+        }));
+        context.paint();
+    }
+    get minRadius() {
+        return this._minRadius;
+    }
+    set minRadius(minRadius) {
+        this._minRadius = minRadius;
+        if (this._painterSegments) {
+            this._painterSegments.minRadius = minRadius;
+        }
+    }
+    get mix() {
+        return this._mix;
+    }
+    set mix(value) {
+        this._mix = value;
+        if (this._painterSegments) {
+            this._painterSegments.mix = value;
+            this.painterSpiking.mix = value;
+        }
+        this.groupSynapses.forEachChild((painter) => {
+            if (painter instanceof PainterSynapses) {
+                painter.mix = value;
+            }
+        });
+    }
+    get synapses() {
+        return this._synapses;
+    }
+    set synapses(synapses) {
+        this._synapses = synapses;
+        const { context, groupSynapses } = this;
+        groupSynapses.delete();
+        if (synapses && synapses.length > 0) {
+            for (const group of synapses) {
+                const painter = new PainterSynapses(context, group, this.data);
+                painter.mix = this.mix;
+                groupSynapses.add(painter);
+            }
+        }
+        this.context.paint();
+    }
+    highlight(segments) {
+        const { groupHover, context } = this;
+        groupHover.delete();
+        if (segments) {
+            groupHover.add(new PainterHighlight(context, segments));
+        }
+        context.paint();
+    }
+    delete() {
+        this.palette.delete();
+        this.groupHover.delete();
+        this.groupSegments.delete();
+        this.groupSynapses.delete();
+    }
+}
+function makeDebugPainter(context) {
+    const geometry = new TgdGeometrySphereIco({
+        center: [6.627639388754254, 14.459156076113382, 1.7206141365071137],
+        radius: 10.124441881874594,
+    });
+    const material = new TgdMaterialGhost({
+        color: [0.5, 1, 0.5, 1],
+    });
+    return new TgdPainterState(context, {
+        depth: webglPresetDepth.less,
+        blend: webglPresetBlend.alpha,
+        children: [
+            new TgdPainterMesh(context, {
+                geometry,
+                material,
+            }),
+        ],
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/dist/components/morpho-viewer-simul/painter/painters/spiking/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./spiking";
+//# sourceMappingURL=index.d.ts.map

package/lib/dist/components/morpho-viewer-simul/painter/painters/spiking/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/components/morpho-viewer-simul/painter/painters/spiking/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC"}

package/lib/dist/components/morpho-viewer-simul/painter/painters/spiking/index.js

@@ -0,0 +1,2 @@
+export * from "./spiking.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY29tcG9uZW50cy9tb3JwaG8tdmlld2VyLXNpbXVsL3BhaW50ZXIvcGFpbnRlcnMvc3Bpa2luZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFdBQVcsQ0FBQyJ9

package/lib/dist/components/morpho-viewer-simul/painter/painters/spiking/spiking.d.ts

@@ -0,0 +1,26 @@
+import { type TgdContext, TgdPainterGroup } from "@tolokoban/tgd";
+import type { MorphoViewerSpikeRecord } from "../../../types/public";
+import type { MorphologyData } from "../../morphology-data";
+import { SpikingManager } from "../../spiking-manager";
+export declare class PainterSpiking extends TgdPainterGroup {
+    private readonly context;
+    private readonly spikingManager;
+    private textureInternal;
+    private framebufferInternal;
+    private blurEffect;
+    private painterSegments;
+    private _mix;
+    private _spike;
+    private readonly material;
+    constructor(context: TgdContext, data: MorphologyData, spikingManager: SpikingManager);
+    private createBlurEffect;
+    private createFramebufferInternal;
+    private createPainterSegments;
+    get spike(): MorphoViewerSpikeRecord | undefined;
+    set spike(value: MorphoViewerSpikeRecord | undefined);
+    get mix(): number;
+    set mix(mix: number);
+    delete(): void;
+    paint(time: number, delta: number): void;
+}
+//# sourceMappingURL=spiking.d.ts.map

package/lib/dist/components/morpho-viewer-simul/painter/painters/spiking/spiking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spiking.d.ts","sourceRoot":"","sources":["../../../../../../src/components/morpho-viewer-simul/painter/painters/spiking/spiking.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,UAAU,EAQf,eAAe,EAIhB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAQvD,qBAAa,cAAe,SAAQ,eAAe;IAgB/C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAExB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAjBjC,OAAO,CAAC,eAAe,CAA6B;IACpD,OAAO,CAAC,mBAAmB,CAAsD;IACjF,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,eAAe,CAA2C;IAKlE,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,MAAM,CAAkD;IAChE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAEtB;gBAGgB,OAAO,EAAE,UAAU,EACpC,IAAI,EAAE,cAAc,EACH,cAAc,EAAE,cAAc;IASjD,OAAO,CAAC,gBAAgB;IAoBxB,OAAO,CAAC,yBAAyB;IA2BjC,OAAO,CAAC,qBAAqB;IAa7B,IAAI,KAAK,IAGQ,uBAAuB,GAAG,SAAS,CADnD;IACD,IAAI,KAAK,CAAC,KAAK,EAAE,uBAAuB,GAAG,SAAS,EAGnD;IAED,IAAI,GAAG,IAIM,MAAM,CAFlB;IAED,IAAI,GAAG,CAAC,GAAG,EAAE,MAAM,EAKlB;IAED,MAAM;IAON,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;CAYlC"}

package/lib/dist/components/morpho-viewer-simul/painter/painters/spiking/spiking.js

@@ -0,0 +1,116 @@
+import { tgdCalcMix, TgdFilterBlur, TgdMaterialSolid, TgdPainterClear, TgdPainterFilter, TgdPainterFramebuffer, TgdPainterGroup, TgdPainterSegmentsMorphing, TgdPainterState, TgdTexture2D, } from "@tolokoban/tgd";
+import { SPIKING_BLUR_SIZE, SPIKING_COLOR, SPIKING_COLOR_MIX, SPIKING_RADIUS_MULTIPLIER, } from "./../../../contants.js";
+export class PainterSpiking extends TgdPainterGroup {
+    constructor(context, data, spikingManager) {
+        super({ name: "PainterSpiking" });
+        this.context = context;
+        this.spikingManager = spikingManager;
+        this.textureInternal = null;
+        this.framebufferInternal = null;
+        this.blurEffect = null;
+        this.painterSegments = null;
+        this._mix = 0;
+        this._spike = undefined;
+        this.material = new TgdMaterialSolid({
+            color: [0, 0, 0, 1],
+        });
+        this.painterSegments = this.createPainterSegments(context, data);
+        const framebufferInternal = this.createFramebufferInternal();
+        const blurEffect = this.createBlurEffect();
+        this.add(framebufferInternal, blurEffect);
+    }
+    createBlurEffect() {
+        const { context, framebufferInternal, painterSegments } = this;
+        if (!framebufferInternal)
+            throw new Error("framebufferInternal is not defined!");
+        if (!painterSegments)
+            throw new Error("painterSegments is not defined!");
+        const size = SPIKING_BLUR_SIZE;
+        const filters = new TgdPainterFilter(context, {
+            filters: [...TgdFilterBlur.createPair({ size })],
+            texture: framebufferInternal.textureColor0,
+            flipY: true,
+        });
+        return new TgdPainterState(context, {
+            name: "State for blur effect",
+            depth: "off",
+            cull: "off",
+            blend: "add",
+            children: [filters],
+        });
+    }
+    createFramebufferInternal() {
+        const { context, painterSegments } = this;
+        if (!painterSegments)
+            throw new Error("painterSegments is not defined!");
+        const textureInternal = (this.textureInternal = new TgdTexture2D(context).setParams({
+            magFilter: "LINEAR",
+            minFilter: "LINEAR",
+        }));
+        const clear = new TgdPainterClear(context, { depth: 1 });
+        this.framebufferInternal = new TgdPainterFramebuffer(context, {
+            name: "framebufferInternal",
+            children: [
+                new TgdPainterClear(context, { color: [0, 0, 0, 1], depth: 1 }),
+                new TgdPainterState(context, {
+                    depth: "less",
+                    blend: "off",
+                    cull: "back",
+                    children: [clear, painterSegments],
+                }),
+            ],
+            depthBuffer: true,
+            viewportMatchingScale: 0.25,
+            textureColor0: textureInternal,
+        });
+        return this.framebufferInternal;
+    }
+    createPainterSegments(context, data) {
+        const { dataset3D, datasetDendrogram } = data;
+        const painterSegments = (this.painterSegments = new TgdPainterSegmentsMorphing(context, {
+            roundness: 4,
+            minRadius: 8,
+            radiusMultiplier: SPIKING_RADIUS_MULTIPLIER,
+            datasetsPairs: [[dataset3D, datasetDendrogram]],
+            material: this.material,
+        }));
+        painterSegments.mix = this.mix;
+        return painterSegments;
+    }
+    get spike() {
+        return this._spike;
+    }
+    set spike(value) {
+        this._spike = value;
+        this.context.paint();
+    }
+    get mix() {
+        return this._mix;
+    }
+    set mix(mix) {
+        this._mix = mix;
+        if (this.painterSegments) {
+            this.painterSegments.mix = mix;
+        }
+    }
+    delete() {
+        var _a, _b, _c, _d;
+        (_a = this.blurEffect) === null || _a === void 0 ? void 0 : _a.delete();
+        (_b = this.painterSegments) === null || _b === void 0 ? void 0 : _b.delete();
+        (_c = this.textureInternal) === null || _c === void 0 ? void 0 : _c.delete();
+        (_d = this.framebufferInternal) === null || _d === void 0 ? void 0 : _d.delete();
+    }
+    paint(time, delta) {
+        const { spikingManager } = this;
+        const { R: R1, G: G1, B: B1, A } = spikingManager.color;
+        const [R2, G2, B2] = SPIKING_COLOR;
+        const R = tgdCalcMix(R1, R2, SPIKING_COLOR_MIX);
+        const G = tgdCalcMix(G1, G2, SPIKING_COLOR_MIX);
+        const B = tgdCalcMix(B1, B2, SPIKING_COLOR_MIX);
+        const { color } = this.material;
+        const { intensity } = spikingManager;
+        color.reset(R * intensity, G * intensity, B * intensity, A);
+        super.paint(time, delta);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/dist/components/morpho-viewer-simul/painter/painters/synapses.d.ts

@@ -0,0 +1,12 @@
+import { type TgdContext, TgdPainterGroup } from "@tolokoban/tgd";
+import type { MorphoViewerSynapsesGroup } from "../../types/public";
+import type { MorphologyData } from "../morphology-data";
+export declare class PainterSynapses extends TgdPainterGroup {
+    private readonly textures;
+    private readonly cloud;
+    constructor(context: TgdContext, synapses: MorphoViewerSynapsesGroup, data: MorphologyData);
+    get mix(): number;
+    set mix(mix: number);
+    delete(): void;
+}
+//# sourceMappingURL=synapses.d.ts.map