@jbrowse/plugin-linear-comparative-view 4.0.2 → 4.0.4

package/esm/LinearSyntenyDisplay/{drawMouseoverClickMap.js → drawMouseover.js}

@@ -1,12 +1,6 @@
 import { getContainingView } from '@jbrowse/core/util';
 import { drawMatchSimple } from "./components/util.js";
-const oobLimit = 1600;
-const fillCallback = (ctx) => {
-    ctx.fill();
-};
-const strokeCallback = (ctx) => {
-    ctx.stroke();
-};
+import { oobLimit } from "./drawSyntenyUtils.js";
 export function drawMouseoverClickMap(model) {
     const { level, clickId, mouseoverId } = model;
     const view = getContainingView(model);
@@ -25,12 +19,14 @@ export function drawMouseoverClickMap(model) {
     const feature1 = model.featMap[mouseoverId || ''];
     if (feature1) {
         drawMatchSimple({
-            cb: fillCallback,
+            cb: ctx => {
+                ctx.fill();
+            },
             feature: feature1,
             level,
             ctx,
             oobLimit,
-            viewWidth: width,
+            viewWidth: view.width,
             drawCurves,
             offsets,
             height,
@@ -39,12 +35,14 @@ export function drawMouseoverClickMap(model) {
     const feature2 = model.featMap[clickId || ''];
     if (feature2) {
         drawMatchSimple({
-            cb: strokeCallback,
+            cb: ctx => {
+                ctx.stroke();
+            },
             feature: feature2,
             ctx,
             level,
             oobLimit,
-            viewWidth: width,
+            viewWidth: view.width,
             drawCurves,
             offsets,
             height,

package/esm/LinearSyntenyDisplay/drawRef.d.ts

@@ -0,0 +1,2 @@
+import type { LinearSyntenyDisplayModel } from './model.ts';
+export declare function drawRef(model: LinearSyntenyDisplayModel, mainCanvas: CanvasRenderingContext2D): void;

package/esm/LinearSyntenyDisplay/drawRef.js

@@ -0,0 +1,190 @@
+import { doesIntersect2, getContainingView } from '@jbrowse/core/util';
+import { draw, drawLocationMarkers, drawMatchSimple, } from "./components/util.js";
+import { MAX_COLOR_RANGE, lineLimit, makeColor, oobLimit, } from "./drawSyntenyUtils.js";
+const fillCb = (ctx) => {
+    ctx.fill();
+};
+export function drawRef(model, mainCanvas) {
+    const view = getContainingView(model);
+    const drawCurves = view.drawCurves;
+    const drawCIGAR = view.drawCIGAR;
+    const drawCIGARMatchesOnly = view.drawCIGARMatchesOnly;
+    const drawLocationMarkersEnabled = view.drawLocationMarkers;
+    const { level, height, featPositions, minAlignmentLength, colorBy } = model;
+    const width = view.width;
+    const bpPerPxs = view.views.map(v => v.bpPerPx);
+    const colorMapWithAlpha = model.colorMapWithAlpha;
+    const posColorWithAlpha = model.posColorWithAlpha;
+    const negColorWithAlpha = model.negColorWithAlpha;
+    const getQueryColorWithAlpha = model.queryColorWithAlphaMap;
+    const queryTotalLengths = model.queryTotalLengths;
+    const offsets = view.views.map(v => v.offsetPx);
+    const offsetsL0 = offsets[level];
+    const offsetsL1 = offsets[level + 1];
+    const unitMultiplier = Math.floor(MAX_COLOR_RANGE / featPositions.length);
+    const y1 = 0;
+    const y2 = height;
+    const mid = (y2 - y1) / 2;
+    const useStrandColor = colorBy === 'strand';
+    const useQueryColor = colorBy === 'query';
+    const bpPerPx0 = bpPerPxs[level];
+    const bpPerPx1 = bpPerPxs[level + 1];
+    const bpPerPxInv0 = 1 / bpPerPx0;
+    const bpPerPxInv1 = 1 / bpPerPx1;
+    const clickMapCtx = model.clickMapCanvas?.getContext('2d');
+    if (clickMapCtx) {
+        clickMapCtx.imageSmoothingEnabled = false;
+        clickMapCtx.clearRect(0, 0, width, height);
+    }
+    mainCanvas.fillStyle = colorMapWithAlpha.M;
+    mainCanvas.strokeStyle = colorMapWithAlpha.M;
+    for (const [i, featPosition] of featPositions.entries()) {
+        const feature = featPosition;
+        const { p11, p12, p21, p22, f, cigar } = feature;
+        const strand = f.get('strand');
+        const refName = f.get('refName');
+        if (queryTotalLengths) {
+            const queryName = f.get('name') || f.get('id') || f.id();
+            const totalLength = queryTotalLengths.get(queryName) || 0;
+            if (totalLength < minAlignmentLength) {
+                continue;
+            }
+        }
+        const x11 = p11.offsetPx - offsetsL0;
+        const x12 = p12.offsetPx - offsetsL0;
+        const x21 = p21.offsetPx - offsetsL1;
+        const x22 = p22.offsetPx - offsetsL1;
+        const l1 = Math.abs(x12 - x11);
+        const l2 = Math.abs(x22 - x21);
+        const minX = Math.min(x21, x22);
+        const maxX = Math.max(x21, x22);
+        if (l1 <= lineLimit &&
+            l2 <= lineLimit &&
+            x21 < width + oobLimit &&
+            x21 > -oobLimit) {
+            if (useStrandColor) {
+                mainCanvas.strokeStyle =
+                    strand === -1 ? negColorWithAlpha : posColorWithAlpha;
+            }
+            else if (useQueryColor) {
+                mainCanvas.strokeStyle = getQueryColorWithAlpha(refName);
+            }
+            else {
+                mainCanvas.strokeStyle = colorMapWithAlpha.M;
+            }
+            mainCanvas.beginPath();
+            mainCanvas.moveTo(x11, y1);
+            if (drawCurves) {
+                mainCanvas.bezierCurveTo(x11, mid, x21, mid, x21, y2);
+            }
+            else {
+                mainCanvas.lineTo(x21, y2);
+            }
+            mainCanvas.stroke();
+        }
+        else if (doesIntersect2(minX, maxX, -oobLimit, view.width + oobLimit)) {
+            const s1 = strand;
+            const k1 = s1 === -1 ? x12 : x11;
+            const k2 = s1 === -1 ? x11 : x12;
+            const rev1 = k1 < k2 ? 1 : -1;
+            const rev2 = (x21 < x22 ? 1 : -1) * s1;
+            let cx1 = k1;
+            let cx2 = s1 === -1 ? x22 : x21;
+            if (cigar.length && drawCIGAR) {
+                let continuingFlag = false;
+                let px1 = 0;
+                let px2 = 0;
+                for (let j = 0; j < cigar.length; j += 2) {
+                    const len = +cigar[j];
+                    const op = cigar[j + 1];
+                    if (!continuingFlag) {
+                        px1 = cx1;
+                        px2 = cx2;
+                    }
+                    const d1 = len * bpPerPxInv0;
+                    const d2 = len * bpPerPxInv1;
+                    if (op === 'M' || op === '=' || op === 'X') {
+                        cx1 += d1 * rev1;
+                        cx2 += d2 * rev2;
+                    }
+                    else if (op === 'D' || op === 'N') {
+                        cx1 += d1 * rev1;
+                    }
+                    else if (op === 'I') {
+                        cx2 += d2 * rev2;
+                    }
+                    if (!(Math.max(px1, px2, cx1, cx2) < 0 ||
+                        Math.min(px1, px2, cx1, cx2) > width)) {
+                        const isNotLast = j < cigar.length - 2;
+                        if (Math.abs(cx1 - px1) <= 1 &&
+                            Math.abs(cx2 - px2) <= 1 &&
+                            isNotLast) {
+                            continuingFlag = true;
+                        }
+                        else {
+                            const letter = (continuingFlag && d1 > 1) || d2 > 1 ? op : 'M';
+                            const isInsertionOrDeletion = letter === 'I' || letter === 'D' || letter === 'N';
+                            if (useStrandColor && !isInsertionOrDeletion) {
+                                mainCanvas.fillStyle =
+                                    strand === -1 ? negColorWithAlpha : posColorWithAlpha;
+                            }
+                            else if (useQueryColor && !isInsertionOrDeletion) {
+                                mainCanvas.fillStyle = getQueryColorWithAlpha(refName);
+                            }
+                            else {
+                                mainCanvas.fillStyle = colorMapWithAlpha[letter];
+                            }
+                            continuingFlag = false;
+                            if (drawCIGARMatchesOnly) {
+                                if (letter === 'M') {
+                                    draw(mainCanvas, px1, cx1, y1, cx2, px2, y2, mid, drawCurves);
+                                    mainCanvas.fill();
+                                    if (drawLocationMarkersEnabled) {
+                                        drawLocationMarkers(mainCanvas, px1, cx1, y1, cx2, px2, y2, mid, bpPerPx0, bpPerPx1, drawCurves);
+                                    }
+                                }
+                            }
+                            else {
+                                draw(mainCanvas, px1, cx1, y1, cx2, px2, y2, mid, drawCurves);
+                                mainCanvas.fill();
+                                if (drawLocationMarkersEnabled) {
+                                    drawLocationMarkers(mainCanvas, px1, cx1, y1, cx2, px2, y2, mid, bpPerPx0, bpPerPx1, drawCurves);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                if (useStrandColor) {
+                    mainCanvas.fillStyle =
+                        strand === -1 ? negColorWithAlpha : posColorWithAlpha;
+                }
+                else if (useQueryColor) {
+                    mainCanvas.fillStyle = getQueryColorWithAlpha(refName);
+                }
+                draw(mainCanvas, x11, x12, y1, x22, x21, y2, mid, drawCurves);
+                mainCanvas.fill();
+                if (useStrandColor || useQueryColor) {
+                    mainCanvas.fillStyle = colorMapWithAlpha.M;
+                }
+            }
+        }
+        if (clickMapCtx) {
+            const idx = i * unitMultiplier + 1;
+            clickMapCtx.fillStyle = makeColor(idx);
+            drawMatchSimple({
+                cb: fillCb,
+                feature,
+                ctx: clickMapCtx,
+                drawCurves,
+                level,
+                offsets,
+                oobLimit,
+                viewWidth: view.width,
+                hideTiny: true,
+                height,
+            });
+        }
+    }
+}

package/esm/LinearSyntenyDisplay/drawSynteny.d.ts

@@ -1,6 +1,4 @@
-import type { LinearSyntenyDisplayModel } from './model.ts';
-export declare const MAX_COLOR_RANGE: number;
-export declare function getId(r: number, g: number, b: number, unitMultiplier: number): number;
-export declare function drawCigarClickMap(model: LinearSyntenyDisplayModel, cigarClickMapCanvas: CanvasRenderingContext2D): void;
-export declare function drawRef(model: LinearSyntenyDisplayModel, mainCanvas: CanvasRenderingContext2D): void;
-export declare function drawMouseoverClickMap(model: LinearSyntenyDisplayModel): void;
+export { drawCigarClickMap } from './drawCigarClickMap.ts';
+export { drawMouseoverClickMap } from './drawMouseover.ts';
+export { drawRef } from './drawRef.ts';
+export { MAX_COLOR_RANGE, getId } from './drawSyntenyUtils.ts';