@teselagen/sequence-utils 0.1.22 → 0.1.23

package/src/mapAnnotationsToRows.js

@@ -0,0 +1,174 @@
+import {each, forEach, startsWith, filter} from "lodash";
+
+import {
+  getYOffsetForPotentiallyCircularRange,
+  splitRangeIntoTwoPartsIfItIsCircular,
+} from "@teselagen/range-utils";
+
+export default function mapAnnotationsToRows(
+  annotations,
+  sequenceLength,
+  bpsPerRow,
+  { splitForwardReverse } = {}
+) {
+  const annotationsToRowsMap = {};
+  const yOffsetLevelMap = {};
+  const wrappedAnnotations = {};
+  each(annotations, annotation => {
+    const containsLocations = !!(
+      annotation.locations && annotation.locations.length
+    );
+    if (annotation.overlapsSelf) {
+      //if the annotation overlaps itself, first send a fake full spanning annotation thru the mapping function
+      if (!wrappedAnnotations[annotation.id]) {
+        mapAnnotationToRows({
+          wrappedAnnotations,
+          annotation: {
+            start: 0,
+            end: sequenceLength - 1,
+            id: `__tempAnnRemoveMe__${annotation.id}`
+          },
+          sequenceLength,
+          bpsPerRow,
+          annotationsToRowsMap,
+          yOffsetLevelMap,
+          containsLocations,
+          splitForwardReverse
+        });
+        wrappedAnnotations[annotation.id] = true;
+        // annotation.yOffset = wrappedAnnotations[annotation.id];
+      }
+    }
+
+    mapAnnotationToRows({
+      wrappedAnnotations,
+      annotation,
+      sequenceLength,
+      bpsPerRow,
+      annotationsToRowsMap,
+      yOffsetLevelMap,
+      containsLocations,
+      splitForwardReverse
+    });
+    if (containsLocations) {
+      annotation.locations.forEach(location => {
+        mapAnnotationToRows({
+          wrappedAnnotations,
+          annotation,
+          sequenceLength,
+          bpsPerRow,
+          annotationsToRowsMap,
+          yOffsetLevelMap,
+          location,
+          splitForwardReverse
+        });
+      });
+    }
+  });
+  forEach(annotationsToRowsMap, (annotationsForRow, i) => {
+    annotationsToRowsMap[i] = filter(
+      annotationsForRow,
+      ann => !startsWith(ann.id, "__tempAnnRemoveMe__")
+    );
+  });
+  return annotationsToRowsMap;
+};
+
+function mapAnnotationToRows({
+  annotation,
+  sequenceLength,
+  bpsPerRow,
+  annotationsToRowsMap,
+  yOffsetLevelMap,
+  location,
+  containsLocations,
+  splitForwardReverse
+}) {
+  const ranges = splitRangeIntoTwoPartsIfItIsCircular(
+    location || annotation,
+    sequenceLength
+  );
+  ranges.forEach((range, index) => {
+    // if (!isPositiveInteger(range.start)) {}
+    const startingRow = Math.floor(range.start / bpsPerRow);
+    const endingRow = Math.floor(range.end / bpsPerRow);
+    // const numberOfRows = endingRow - startingRow + 1;
+    for (let rowNumber = startingRow; rowNumber <= endingRow; rowNumber++) {
+      if (!annotationsToRowsMap[rowNumber]) {
+        annotationsToRowsMap[rowNumber] = [];
+      }
+      const key = splitForwardReverse
+        ? annotation.forward
+          ? rowNumber + "_forward"
+          : rowNumber + "_reverse"
+        : rowNumber;
+
+      const annotationsForRow = annotationsToRowsMap[rowNumber];
+      if (!yOffsetLevelMap[key]) {
+        yOffsetLevelMap[key] = [];
+      }
+
+      let yOffset;
+      const yOffsetsForRow = yOffsetLevelMap[key];
+      const start =
+        rowNumber === startingRow ? range.start : rowNumber * bpsPerRow;
+      const end =
+        rowNumber === endingRow
+          ? range.end
+          : rowNumber * bpsPerRow + bpsPerRow - 1;
+      if (annotation.overlapsSelf) {
+        annotationsForRow.forEach(ann => {
+          if (ann.id === `__tempAnnRemoveMe__${annotation.id}`) {
+            yOffset = ann.yOffset;
+          }
+        });
+      } else {
+        if (location) {
+          //if there's a location then we will just use the previous yOffset for its parent annotation
+          annotationsForRow.forEach(ann => {
+            if (ann.id === annotation.id) {
+              yOffset = ann.yOffset;
+            }
+          });
+        } else {
+          //we need to pass both ranges into this function so that we can correctly
+          //get the y-offset for circular features that start and end on the same row
+          //we pass the entire annotation range here and compare it only with ranges that have already been added to the row
+          if (
+            index > 0 && //second half of an annotation range
+            annotationsForRow.length && //there are already annotations within the row
+            annotationsForRow[annotationsForRow.length - 1].annotation ===
+              annotation
+          ) {
+            //the first chunk of the annotation has already been pushed into the row,
+            //so set the yOffset for the range chunk to the already calculated yOffset
+            yOffset = annotationsForRow[annotationsForRow.length - 1].yOffset;
+          } else {
+            yOffset = getYOffsetForPotentiallyCircularRange(
+              annotation,
+              yOffsetsForRow
+            );
+          }
+          //add the new yOffset to the yOffset array
+          if (!yOffsetsForRow[yOffset]) yOffsetsForRow[yOffset] = [];
+          yOffsetsForRow[yOffset].push({
+            start: start,
+            end: end
+          });
+        }
+      }
+
+      annotationsForRow.push({
+        id: annotation.id,
+        annotation: annotation,
+        start: start,
+        end: end,
+        ...(containsLocations && { containsLocations }),
+        ...(location && { isJoinedLocation: !!location }),
+        yOffset: yOffset,
+        enclosingRangeType: range.type //either "beginning", "end" or "beginningAndEnd"
+      });
+    }
+  });
+  // return annotationsToRowsMap;
+}

package/src/mapAnnotationsToRows.test.js

@@ -0,0 +1,425 @@
+
+
+import chai from "chai";
+
+import {expect} from "chai";
+import chaiSubset from "chai-subset";
+import mapAnnotationsToRows from "./mapAnnotationsToRows.js";
+chai.use(chaiSubset);
+describe("mapAnnotationsToRows", () => {
+  it("maps overlapsSelf=true annotations to the same y-offset correctly", () => {
+    const annotation1 = {
+      start: 1,
+      end: 3,
+      id: "a"
+    };
+
+    const annotationWraps = {
+      start: 1,
+      end: 3,
+      overlapsSelf: true,
+      id: "overlaps self"
+    };
+    const annotationWrapsAddon = {
+      start: 4,
+      end: 0,
+      overlapsSelf: true,
+      isWrappedAddon: true,
+      id: "overlaps self"
+    };
+    const annotation3 = {
+      start: 0,
+      end: 0,
+      id: "b"
+    };
+
+    const annotation4 = {
+      start: 0,
+      end: 0,
+      id: "c"
+    };
+
+    const annotations = [
+      annotation1,
+      annotationWraps,
+      annotationWrapsAddon,
+      annotation3,
+      annotation4
+    ];
+    const sequenceLength = 10;
+    const bpsPerRow = 5;
+    const annotationsToRowsMap = mapAnnotationsToRows(
+      annotations,
+      sequenceLength,
+      bpsPerRow
+    );
+    expect(annotationsToRowsMap[0]).to.containSubset([
+      {
+        annotation: annotationWraps,
+        start: 1,
+        end: 3,
+        id: annotationWraps.id,
+        yOffset: 1,
+        enclosingRangeType: "beginningAndEnd"
+      },
+      {
+        annotation: annotationWrapsAddon,
+        start: 0,
+        end: 0,
+        id: annotationWrapsAddon.id,
+        yOffset: 1,
+        enclosingRangeType: "end"
+      },
+      {
+        annotation: annotationWrapsAddon,
+        start: 4,
+        end: 4,
+        id: annotationWrapsAddon.id,
+        yOffset: 1,
+        enclosingRangeType: "beginning"
+      }
+    ]);
+  });
+  it("maps overlapping annotations with joined locations to rows correctly", () => {
+    const annotation1 = {
+      start: 0,
+      end: 9,
+      locations: [
+        { start: 0, end: 1 },
+        { start: 7, end: 9 }
+      ],
+      id: "a"
+    };
+    const annotation2 = {
+      start: 0,
+      end: 9,
+      locations: [
+        { start: 0, end: 1 },
+        { start: 2, end: 4 },
+        { start: 9, end: 9 }
+      ],
+      id: "b"
+    };
+    const annotations = [annotation1, annotation2];
+    const sequenceLength = 10;
+    const bpsPerRow = 5;
+    const annotationsToRowsMap = mapAnnotationsToRows(
+      annotations,
+      sequenceLength,
+      bpsPerRow
+    );
+    expect(annotationsToRowsMap[0]).to.containSubset([
+      {
+        annotation: annotation1,
+        start: 0,
+        end: 4,
+        id: annotation1.id,
+        yOffset: 0,
+        containsLocations: true,
+        enclosingRangeType: "beginningAndEnd"
+      },
+      {
+        annotation: annotation1,
+        start: 0,
+        end: 1,
+        id: annotation1.id,
+        yOffset: 0,
+        isJoinedLocation: true,
+        enclosingRangeType: "beginningAndEnd"
+      },
+      {
+        start: 0,
+        end: 4,
+        id: annotation2.id,
+        yOffset: 1,
+        annotation: annotation2,
+        enclosingRangeType: "beginningAndEnd"
+      },
+      {
+        annotation: annotation2,
+        start: 0,
+        end: 1,
+        id: annotation2.id,
+        yOffset: 1,
+        isJoinedLocation: true,
+        enclosingRangeType: "beginningAndEnd"
+      },
+      {
+        annotation: annotation2,
+        start: 2,
+        end: 4,
+        id: annotation2.id,
+        yOffset: 1,
+        isJoinedLocation: true,
+        enclosingRangeType: "beginningAndEnd"
+      }
+    ]);
+
+    expect(annotationsToRowsMap[1]).to.containSubset([
+      {
+        annotation: annotation1,
+        start: 5,
+        end: 9,
+        id: annotation1.id,
+        yOffset: 0,
+        containsLocations: true,
+        enclosingRangeType: "beginningAndEnd"
+      },
+      {
+        annotation: annotation1,
+        start: 7,
+        end: 9,
+        id: annotation1.id,
+        yOffset: 0,
+        isJoinedLocation: true,
+        enclosingRangeType: "beginningAndEnd"
+      },
+      {
+        start: 5,
+        end: 9,
+        id: annotation2.id,
+        yOffset: 1,
+        annotation: annotation2,
+        enclosingRangeType: "beginningAndEnd"
+      },
+      {
+        annotation: annotation2,
+        start: 9,
+        end: 9,
+        id: annotation2.id,
+        yOffset: 1,
+        isJoinedLocation: true,
+        enclosingRangeType: "beginningAndEnd"
+      }
+    ]);
+  });
+  it("maps overlapping annotations to rows correctly", () => {
+    const annotation1 = {
+      start: 0,
+      end: 9,
+      id: "a"
+    };
+    const annotation2 = {
+      start: 0,
+      end: 9,
+      id: "b"
+    };
+    const annotations = [annotation1, annotation2];
+    const sequenceLength = 10;
+    const bpsPerRow = 5;
+    const annotationsToRowsMap = mapAnnotationsToRows(
+      annotations,
+      sequenceLength,
+      bpsPerRow
+    );
+    expect(annotationsToRowsMap).to.deep.equal({
+      0: [
+        {
+          annotation: annotation1,
+          start: 0,
+          end: 4,
+          id: annotation1.id,
+          yOffset: 0,
+          enclosingRangeType: "beginningAndEnd"
+        },
+        {
+          start: 0,
+          end: 4,
+          id: annotation2.id,
+          yOffset: 1,
+          annotation: annotation2,
+          enclosingRangeType: "beginningAndEnd"
+        }
+      ],
+      1: [
+        {
+          annotation: annotation1,
+          start: 5,
+          end: 9,
+          id: annotation1.id,
+          yOffset: 0,
+          enclosingRangeType: "beginningAndEnd"
+        },
+        {
+          start: 5,
+          end: 9,
+          id: annotation2.id,
+          yOffset: 1,
+          annotation: annotation2,
+          enclosingRangeType: "beginningAndEnd"
+        }
+      ]
+    });
+  });
+  it("correctly calculates y-offset for annotation split by origin", () => {
+    const annotation1 = {
+      start: 7,
+      end: 9,
+      id: "a"
+    };
+    const annotation2 = {
+      start: 5,
+      end: 3,
+      id: "b"
+    };
+    const annotations = [annotation1, annotation2];
+    const sequenceLength = 10;
+    const bpsPerRow = 10;
+    const annotationsToRowsMap = mapAnnotationsToRows(
+      annotations,
+      sequenceLength,
+      bpsPerRow
+    );
+    expect(annotationsToRowsMap).to.deep.equal({
+      0: [
+        {
+          start: 7,
+          end: 9,
+          id: annotation1.id,
+          yOffset: 0,
+          annotation: annotation1,
+          enclosingRangeType: "beginningAndEnd"
+        },
+        {
+          annotation: annotation2,
+          start: 0,
+          end: 3,
+          id: annotation2.id,
+          yOffset: 1,
+          enclosingRangeType: "end"
+        },
+        {
+          annotation: annotation2,
+          start: 5,
+          end: 9,
+          id: annotation2.id,
+          yOffset: 1,
+          enclosingRangeType: "beginning"
+        }
+      ]
+    });
+  });
+  it("correctly calculates y-offset for annotation split by origin (different ordering of annotations)", () => {
+    const annotation1 = {
+      start: 5,
+      end: 3,
+      id: "a"
+    };
+    const annotation2 = {
+      start: 7,
+      end: 9,
+      id: "b"
+    };
+    const annotations = [annotation1, annotation2];
+    const sequenceLength = 10;
+    const bpsPerRow = 10;
+    const annotationsToRowsMap = mapAnnotationsToRows(
+      annotations,
+      sequenceLength,
+      bpsPerRow
+    );
+    expect(annotationsToRowsMap).to.deep.equal({
+      0: [
+        {
+          annotation: annotation1,
+          start: 0,
+          end: 3,
+          id: annotation1.id,
+          yOffset: 0,
+          enclosingRangeType: "end"
+        },
+        {
+          annotation: annotation1,
+          start: 5,
+          end: 9,
+          id: annotation1.id,
+          yOffset: 0,
+          enclosingRangeType: "beginning"
+        },
+        {
+          start: 7,
+          end: 9,
+          id: annotation2.id,
+          yOffset: 1,
+          annotation: annotation2,
+          enclosingRangeType: "beginningAndEnd"
+        }
+      ]
+    });
+  });
+
+  it("maps single annotation to rows correctly", () => {
+    const annotation1 = {
+      start: 0,
+      end: 9,
+      id: "a"
+    };
+    const annotations = [annotation1];
+    const sequenceLength = 10;
+    const bpsPerRow = 5;
+    const annotationsToRowsMap = mapAnnotationsToRows(
+      annotations,
+      sequenceLength,
+      bpsPerRow
+    );
+    expect(annotationsToRowsMap).to.deep.equal({
+      0: [
+        {
+          annotation: annotation1,
+          start: 0,
+          end: 4,
+          id: annotation1.id,
+          yOffset: 0,
+          enclosingRangeType: "beginningAndEnd"
+        }
+      ],
+      1: [
+        {
+          annotation: annotation1,
+          start: 5,
+          end: 9,
+          id: annotation1.id,
+          yOffset: 0,
+          enclosingRangeType: "beginningAndEnd"
+        }
+      ]
+    });
+  });
+  it("maps annotations to rows correctly when the annotations are passed as an object", () => {
+    const annotation1 = {
+      start: 0,
+      end: 9,
+      id: "a"
+    };
+    const annotations = { a: annotation1 };
+    const sequenceLength = 10;
+    const bpsPerRow = 5;
+    const annotationsToRowsMap = mapAnnotationsToRows(
+      annotations,
+      sequenceLength,
+      bpsPerRow
+    );
+    expect(annotationsToRowsMap).to.deep.equal({
+      0: [
+        {
+          annotation: annotation1,
+          start: 0,
+          end: 4,
+          id: annotation1.id,
+          yOffset: 0,
+          enclosingRangeType: "beginningAndEnd"
+        }
+      ],
+      1: [
+        {
+          annotation: annotation1,
+          start: 5,
+          end: 9,
+          id: annotation1.id,
+          yOffset: 0,
+          enclosingRangeType: "beginningAndEnd"
+        }
+      ]
+    });
+  });
+});

package/src/prepareCircularViewData.js

@@ -0,0 +1,17 @@
+import { cloneDeep } from 'lodash';
+import { getYOffsetsForPotentiallyCircularRanges } from '@teselagen/range-utils';
+import { annotationTypes } from './annotationTypes';
+
+//basically just adds yOffsets to the annotations
+export default function prepareCircularViewData(sequenceData) {
+  const clonedSeqData = cloneDeep(sequenceData);
+  annotationTypes.forEach((annotationType) => {
+    if (annotationType !== 'cutsites') {
+      const maxYOffset = getYOffsetsForPotentiallyCircularRanges(
+        clonedSeqData[annotationType]
+      ).maxYOffset;
+      clonedSeqData[annotationType].maxYOffset = maxYOffset;
+    }
+  });
+  return clonedSeqData;
+}