@datagrok-libraries/utils 4.1.15 → 4.1.16

package/package.json

@@ -8,7 +8,7 @@
     "email": "amuzychyna@datagrok.ai"
   },
   "fullName": "Utils",
-  "version": "4.1.15",
+  "version": "4.1.16",
   "description": "Common utilities",
   "dependencies": {
     "cash-dom": "^8.1.1",

package/src/render-lines-on-sp.d.ts

@@ -0,0 +1,44 @@
+import * as DG from 'datagrok-api/dg';
+import { Subject } from 'rxjs';
+export declare enum LineDirection {
+    lower = "lower",
+    higher = "higher"
+}
+export type ILineOpts = {
+    id: number;
+    color?: string;
+    directionCol?: string;
+    direction?: LineDirection;
+    opacity?: number;
+    width?: number;
+};
+export type IConnectedPoints = {
+    [key: number]: ILineOpts[];
+};
+export type ILines = {
+    [key: number]: IConnectedPoints;
+};
+export declare class ScatterPlotLinesRenderer {
+    sp: DG.ScatterPlotViewer;
+    xAxis: string;
+    yAxis: string;
+    currentLineIdx: number;
+    lines: ILines;
+    lineClicked: Subject<number>;
+    lineHover: Subject<number>;
+    canvas: any;
+    paths: {
+        [key: number]: Path2D;
+    };
+    mouseOverLineId: number | null;
+    get currentLineId(): number;
+    set currentLineId(id: number);
+    constructor(sp: DG.ScatterPlotViewer, xAxis: string, yAxis: string, lines: ILines);
+    renderLines(): void;
+    checkCursorOnLine(x: number, y: number): number | null;
+    midPointBtw(p1: DG.Point, p2: DG.Point): DG.Point;
+    findPerpendicularPointOnCurve(idx: number, x1: number, y1: number, x2: number, y2: number): DG.Point;
+    canvasArrow(path: Path2D, arrowEndX: number, arrowEndY: number, quadX: number, quadY: number): void;
+    getArrowPoint(lineOpts: ILineOpts, p1: number, p2: number, pointFrom: DG.Point, pointTo: DG.Point): DG.Point | null;
+}
+//# sourceMappingURL=render-lines-on-sp.d.ts.map

package/src/render-lines-on-sp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-lines-on-sp.d.ts","sourceRoot":"","sources":["render-lines-on-sp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAE/B,oBAAY,aAAa;IACrB,KAAK,UAAU;IACf,MAAM,WAAW;CACpB;AAED,MAAM,MAAM,SAAS,GAAG;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,CAAA;CAAE,CAAA;AAE7D,MAAM,MAAM,MAAM,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAAA;CAAE,CAAA;AAExD,qBAAa,wBAAwB;IACjC,EAAE,EAAE,EAAE,CAAC,iBAAiB,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,SAAM;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,kBAAyB;IACpC,SAAS,kBAAyB;IAClC,MAAM,EAAE,GAAG,CAAC;IACZ,KAAK,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAM;IACtC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAQ;IAEtC,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,IAAI,aAAa,CAAC,EAAE,EAAE,MAAM,EAG3B;gBAEW,EAAE,EAAE,EAAE,CAAC,iBAAiB,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAyBjF,WAAW,IAAI,IAAI;IAgDnB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAWtD,WAAW,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC,KAAK,GAAG,EAAE,CAAC,KAAK;IAIjD,6BAA6B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAYzF,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAU5F,aAAa,CAAC,QAAQ,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC,KAAK,GAAG,EAAE,CAAC,KAAK,GAAG,IAAI;CAgBtH"}

package/src/render-lines-on-sp.js

@@ -0,0 +1,135 @@
+import * as DG from 'datagrok-api/dg';
+import { Subject } from 'rxjs';
+export var LineDirection;
+(function (LineDirection) {
+    LineDirection["lower"] = "lower";
+    LineDirection["higher"] = "higher";
+})(LineDirection || (LineDirection = {}));
+export class ScatterPlotLinesRenderer {
+    get currentLineId() {
+        return this.currentLineIdx;
+    }
+    set currentLineId(id) {
+        this.currentLineIdx = id;
+        this.sp.render(this.canvas.getContext('2d'));
+    }
+    constructor(sp, xAxis, yAxis, lines) {
+        this.currentLineIdx = -1;
+        this.lineClicked = new Subject();
+        this.lineHover = new Subject();
+        this.paths = {};
+        this.mouseOverLineId = null;
+        this.sp = sp;
+        this.xAxis = xAxis;
+        this.yAxis = yAxis;
+        this.lines = lines;
+        this.canvas = this.sp.getInfo()['canvas'];
+        this.canvas.addEventListener('mousedown', (event) => {
+            if (this.mouseOverLineId !== null)
+                this.lineClicked.next(this.mouseOverLineId);
+        });
+        this.canvas.addEventListener('mousemove', (event) => {
+            this.mouseOverLineId = this.checkCursorOnLine(event.offsetX, event.offsetY);
+            if (this.mouseOverLineId !== null)
+                this.lineHover.next(this.mouseOverLineId);
+        });
+        sp.onEvent('d4-before-draw-scene')
+            .subscribe((_) => {
+            this.renderLines();
+        });
+    }
+    renderLines() {
+        var _a, _b;
+        const ctx = this.canvas.getContext('2d');
+        const x = this.sp.dataFrame.columns.byName(this.xAxis);
+        const y = this.sp.dataFrame.columns.byName(this.yAxis);
+        for (let p1 of Object.keys(this.lines).map(Number)) {
+            if (this.sp.dataFrame.filter.get(p1)) {
+                const pointFrom = this.sp.worldToScreen(x.get(p1), y.get(p1));
+                const aX = pointFrom === null || pointFrom === void 0 ? void 0 : pointFrom.x;
+                const aY = pointFrom === null || pointFrom === void 0 ? void 0 : pointFrom.y;
+                for (let p2 of Object.keys(this.lines[p1]).map(Number)) {
+                    if (this.sp.dataFrame.filter.get(p2)) {
+                        const pointTo = this.sp.worldToScreen(x.get(p2), y.get(p2));
+                        const bX = pointTo === null || pointTo === void 0 ? void 0 : pointTo.x;
+                        const bY = pointTo === null || pointTo === void 0 ? void 0 : pointTo.y;
+                        if (aX && aY && bX && bY) {
+                            for (let lineIdx = 0; lineIdx < this.lines[p1][p2].length; lineIdx++) {
+                                const lineOpts = this.lines[p1][p2][lineIdx];
+                                const line = new Path2D();
+                                this.paths[lineOpts.id] = line;
+                                line.moveTo(aX, aY);
+                                const color = (_a = lineOpts.color) !== null && _a !== void 0 ? _a : '0,128,0';
+                                const opacity = (_b = lineOpts.opacity) !== null && _b !== void 0 ? _b : 1;
+                                ctx.strokeStyle = `rgba(${color},${opacity})`;
+                                ctx.lineWidth = lineOpts.width ? lineOpts.id === this.currentLineIdx ? lineOpts.width + 2 : lineOpts.width :
+                                    lineOpts.id === this.currentLineIdx ? 3 : 1;
+                                let midPoint = this.midPointBtw(pointFrom, pointTo);
+                                if (lineIdx > 0 || this.lines[p1][p2].length > 1) {
+                                    midPoint = this.findPerpendicularPointOnCurve(lineIdx, pointFrom.x, pointFrom.y, midPoint.x, midPoint.y);
+                                }
+                                line.quadraticCurveTo(midPoint.x, midPoint.y, bX, bY);
+                                if (lineOpts.directionCol) {
+                                    const arrowPoint = this.getArrowPoint(lineOpts, p1, p2, pointFrom, pointTo);
+                                    if (arrowPoint)
+                                        this.canvasArrow(line, arrowPoint.x, arrowPoint.y, midPoint.x, midPoint.y);
+                                }
+                                ctx.beginPath();
+                                ctx.stroke(line);
+                                ctx.closePath();
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    checkCursorOnLine(x, y) {
+        const ctx = this.canvas.getContext('2d');
+        for (let id of Object.keys(this.paths).map(Number)) {
+            ctx.lineWidth = 5;
+            const inStroke = ctx.isPointInStroke(this.paths[id], x * window.devicePixelRatio, y * window.devicePixelRatio);
+            if (inStroke)
+                return id;
+        }
+        return null;
+    }
+    midPointBtw(p1, p2) {
+        return new DG.Point(p1.x + (p2.x - p1.x) / 2, p1.y + (p2.y - p1.y) / 2);
+    }
+    findPerpendicularPointOnCurve(idx, x1, y1, x2, y2) {
+        let dx = x2 - x1;
+        let dy = y2 - y1;
+        const dist = Math.sqrt(dx * dx + dy * dy);
+        dx /= dist;
+        dy /= dist;
+        const perpendicularLen = 50 * Math.floor(idx / 2) + 50;
+        return idx % 2 === 0 ?
+            new DG.Point(x2 + (perpendicularLen / 2) * dy, y2 - (perpendicularLen / 2) * dx) :
+            new DG.Point(x2 - (perpendicularLen / 2) * dy, y2 + (perpendicularLen / 2) * dx);
+    }
+    canvasArrow(path, arrowEndX, arrowEndY, quadX, quadY) {
+        const arrowAngle = Math.atan2(quadX - arrowEndX, quadY - arrowEndY) + Math.PI;
+        const arrowWidth = 15;
+        path.moveTo(arrowEndX - (arrowWidth * Math.sin(arrowAngle - Math.PI / 10)), arrowEndY - (arrowWidth * Math.cos(arrowAngle - Math.PI / 10)));
+        path.lineTo(arrowEndX, arrowEndY);
+        path.lineTo(arrowEndX - (arrowWidth * Math.sin(arrowAngle + Math.PI / 10)), arrowEndY - (arrowWidth * Math.cos(arrowAngle + Math.PI / 10)));
+    }
+    getArrowPoint(lineOpts, p1, p2, pointFrom, pointTo) {
+        var _a;
+        const compareCol = this.sp.dataFrame.col(lineOpts.directionCol);
+        if (compareCol) {
+            const direction = (_a = lineOpts.direction) !== null && _a !== void 0 ? _a : LineDirection.higher;
+            switch (direction) {
+                case LineDirection.higher:
+                    return compareCol.get(p1) > compareCol.get(p2) ? pointFrom : pointTo;
+                case LineDirection.lower:
+                    return compareCol.get(p1) > compareCol.get(p2) ? pointTo : pointFrom;
+                default:
+                    return null;
+            }
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"render-lines-on-sp.js","sourceRoot":"","sources":["render-lines-on-sp.ts"],"names":[],"mappings":"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","sourcesContent":["import * as DG from 'datagrok-api/dg';\nimport { Subject } from 'rxjs';\n\nexport enum LineDirection {\n    lower = 'lower',\n    higher = 'higher',\n}\n\nexport type ILineOpts = {\n    id: number;\n    color?: string;\n    directionCol?: string\n    direction?: LineDirection;\n    opacity?: number;\n    width?: number;\n}\n\nexport type IConnectedPoints = { [key: number]: ILineOpts[] }\n\nexport type ILines = { [key: number]: IConnectedPoints }\n\nexport class ScatterPlotLinesRenderer {\n    sp: DG.ScatterPlotViewer;\n    xAxis: string;\n    yAxis: string;\n    currentLineIdx = -1;\n    lines: ILines;\n    lineClicked = new Subject<number>();\n    lineHover = new Subject<number>();\n    canvas: any;\n    paths: { [key: number]: Path2D } = {};\n    mouseOverLineId: number | null = null;\n\n    get currentLineId(): number {\n        return this.currentLineIdx;\n    }\n\n    set currentLineId(id: number) {\n        this.currentLineIdx = id;\n        this.sp.render(this.canvas.getContext('2d') as CanvasRenderingContext2D);\n    }\n\n    constructor(sp: DG.ScatterPlotViewer, xAxis: string, yAxis: string, lines: ILines) {\n        this.sp = sp;\n        this.xAxis = xAxis;\n        this.yAxis = yAxis;\n        this.lines = lines;\n        this.canvas = (this.sp.getInfo() as { [index: string]: any })['canvas'];\n\n        this.canvas.addEventListener('mousedown', (event: MouseEvent) => {\n            if (this.mouseOverLineId !== null)\n                this.lineClicked.next(this.mouseOverLineId);\n        });\n\n        this.canvas.addEventListener('mousemove', (event: MouseEvent) => {\n            this.mouseOverLineId = this.checkCursorOnLine(event.offsetX, event.offsetY);\n            if (this.mouseOverLineId !== null)\n                this.lineHover.next(this.mouseOverLineId);\n        });\n\n        sp.onEvent('d4-before-draw-scene')\n            .subscribe((_: any) => {\n                this.renderLines();\n            });\n\n    }\n\n    renderLines(): void {\n        const ctx = this.canvas.getContext('2d') as CanvasRenderingContext2D;\n        const x = this.sp.dataFrame!.columns.byName(this.xAxis);\n        const y = this.sp.dataFrame!.columns.byName(this.yAxis);\n        for (let p1 of Object.keys(this.lines).map(Number)) {\n\n            if (this.sp.dataFrame.filter.get(p1)) {\n                const pointFrom = this.sp.worldToScreen(x.get(p1), y.get(p1));\n                const aX = pointFrom?.x;\n                const aY = pointFrom?.y;\n                for (let p2 of Object.keys(this.lines[p1]).map(Number)) {\n                    if (this.sp.dataFrame.filter.get(p2)) {\n                        const pointTo = this.sp.worldToScreen(x.get(p2), y.get(p2));\n                        const bX = pointTo?.x;\n                        const bY = pointTo?.y;\n                        if (aX && aY && bX && bY) {\n                            for (let lineIdx = 0; lineIdx < this.lines[p1][p2].length; lineIdx++) {\n                                const lineOpts = this.lines[p1][p2][lineIdx];\n                                const line = new Path2D();\n                                this.paths[lineOpts.id] = line;\n                                line.moveTo(aX!, aY!);\n                                const color = lineOpts.color ?? '0,128,0';\n                                const opacity = lineOpts.opacity ?? 1;\n                                ctx.strokeStyle = `rgba(${color},${opacity})`;\n                                ctx.lineWidth = lineOpts.width ? lineOpts.id === this.currentLineIdx ? lineOpts.width + 2 : lineOpts.width :\n                                    lineOpts.id === this.currentLineIdx ? 3 : 1;\n                                let midPoint: DG.Point = this.midPointBtw(pointFrom, pointTo);\n                                if (lineIdx > 0 || this.lines[p1][p2].length > 1) {\n                                    midPoint = this.findPerpendicularPointOnCurve(lineIdx,\n                                        pointFrom.x, pointFrom.y, midPoint.x, midPoint.y)\n                                }\n                                line.quadraticCurveTo(midPoint.x, midPoint.y, bX, bY);\n                                if (lineOpts.directionCol) {\n                                    const arrowPoint = this.getArrowPoint(lineOpts, p1, p2, pointFrom, pointTo);\n                                    if (arrowPoint)\n                                        this.canvasArrow(line, arrowPoint.x, arrowPoint.y, midPoint.x, midPoint.y);\n                                }\n                                ctx.beginPath();\n                                ctx.stroke(line);\n                                ctx.closePath();\n                            }\n                        }\n                    }\n                }\n            }\n        }\n    }\n\n    checkCursorOnLine(x: number, y: number): number | null {\n        const ctx = this.canvas.getContext('2d') as CanvasRenderingContext2D;\n        for (let id of Object.keys(this.paths).map(Number)) {\n            ctx.lineWidth = 5;\n            const inStroke = ctx.isPointInStroke(this.paths[id], x * window.devicePixelRatio, y * window.devicePixelRatio);\n            if (inStroke)\n                return id;\n        }\n        return null;\n    }\n\n    midPointBtw(p1: DG.Point, p2: DG.Point): DG.Point {\n        return new DG.Point(p1.x + (p2.x - p1.x) / 2, p1.y + (p2.y - p1.y) / 2);\n    }\n\n    findPerpendicularPointOnCurve(idx: number, x1: number, y1: number, x2: number, y2: number) {\n        let dx = x2 - x1\n        let dy = y2 - y1\n        const dist = Math.sqrt(dx * dx + dy * dy)\n        dx /= dist\n        dy /= dist\n        const perpendicularLen = 50 * Math.floor(idx / 2) + 50;\n        return idx % 2 === 0 ?\n            new DG.Point(x2 + (perpendicularLen / 2) * dy, y2 - (perpendicularLen / 2) * dx) :\n            new DG.Point(x2 - (perpendicularLen / 2) * dy, y2 + (perpendicularLen / 2) * dx);\n    }\n\n    canvasArrow(path: Path2D, arrowEndX: number, arrowEndY: number, quadX: number, quadY: number) {\n        const arrowAngle = Math.atan2(quadX - arrowEndX, quadY - arrowEndY) + Math.PI;\n        const arrowWidth = 15;\n        path.moveTo(arrowEndX - (arrowWidth * Math.sin(arrowAngle - Math.PI / 10)),\n            arrowEndY - (arrowWidth * Math.cos(arrowAngle - Math.PI / 10)));\n        path.lineTo(arrowEndX, arrowEndY);\n        path.lineTo(arrowEndX - (arrowWidth * Math.sin(arrowAngle + Math.PI / 10)),\n            arrowEndY - (arrowWidth * Math.cos(arrowAngle + Math.PI / 10)));\n    }\n\n    getArrowPoint(lineOpts: ILineOpts, p1: number, p2: number, pointFrom: DG.Point, pointTo: DG.Point): DG.Point | null {\n        const compareCol = this.sp.dataFrame!.col(lineOpts.directionCol!);\n        if (compareCol) {\n            const direction = lineOpts.direction ?? LineDirection.higher;\n            switch (direction) {\n                case LineDirection.higher:\n                    return compareCol.get(p1) > compareCol.get(p2) ? pointFrom : pointTo;\n                case LineDirection.lower:\n                    return compareCol.get(p1) > compareCol.get(p2) ? pointTo : pointFrom;\n                default:\n                    return null;\n            }\n        }\n        return null;\n    }\n\n}"]}