@jbrowse/plugin-circular-view 1.6.8 → 1.7.1

package/dist/CircularView/models/slices.js

@@ -0,0 +1,111 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Slice = void 0;
+exports.calculateStaticSlices = calculateStaticSlices;
+exports.sliceIsVisible = sliceIsVisible;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _util = require("@jbrowse/core/util");
+
+var _viewportVisibleRegion = require("./viewportVisibleRegion");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var Slice = /*#__PURE__*/function () {
+  function Slice(view, region, currentRadianOffset, radianWidth) {
+    (0, _classCallCheck2["default"])(this, Slice);
+    this.region = region;
+    this.radianWidth = radianWidth;
+    (0, _defineProperty2["default"])(this, "key", void 0);
+    (0, _defineProperty2["default"])(this, "offsetRadians", void 0);
+    (0, _defineProperty2["default"])(this, "startRadians", void 0);
+    (0, _defineProperty2["default"])(this, "endRadians", void 0);
+    (0, _defineProperty2["default"])(this, "bpPerRadian", void 0);
+    (0, _defineProperty2["default"])(this, "flipped", void 0);
+    var bpPerRadian = view.bpPerRadian;
+    this.key = (0, _util.assembleLocString)(region);
+    this.offsetRadians = currentRadianOffset;
+    this.bpPerRadian = bpPerRadian;
+    this.flipped = false;
+    this.startRadians = this.offsetRadians;
+    this.endRadians = region.widthBp / this.bpPerRadian + this.offsetRadians;
+    Object.freeze(this);
+  }
+
+  (0, _createClass2["default"])(Slice, [{
+    key: "bpToXY",
+    value: function bpToXY(bp, radiusPx) {
+      var offsetBp;
+
+      if (this.region.elided) {
+        offsetBp = this.region.widthBp / 2;
+      } else if (this.flipped) {
+        offsetBp = this.region.end - bp;
+      } else {
+        offsetBp = bp - this.region.start;
+      }
+
+      var totalRadians = offsetBp / this.bpPerRadian + this.offsetRadians;
+      return (0, _util.polarToCartesian)(radiusPx, totalRadians);
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return (0, _util.objectFromEntries)(Object.entries(this));
+    }
+  }]);
+  return Slice;
+}(); // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+
+exports.Slice = Slice;
+
+function calculateStaticSlices(self) {
+  var slices = [];
+  var currentRadianOffset = 0;
+
+  var _iterator = _createForOfIteratorHelper(self.elidedRegions),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _region = _step.value;
+
+      var _radianWidth = _region.widthBp / self.bpPerRadian + self.spacingPx / self.pxPerRadian;
+
+      slices.push(new Slice(self, _region, currentRadianOffset, _radianWidth));
+      currentRadianOffset += _radianWidth;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return slices;
+} // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+
+function sliceIsVisible(self, slice) {
+  var _self$visibleSection$ = (0, _slicedToArray2["default"])(self.visibleSection.theta, 2),
+      visibleThetaMin = _self$visibleSection$[0],
+      visibleThetaMax = _self$visibleSection$[1];
+
+  return (0, _viewportVisibleRegion.thetaRangesOverlap)(slice.offsetRadians + self.offsetRadians, slice.radianWidth, visibleThetaMin, visibleThetaMax - visibleThetaMin);
+}

package/dist/CircularView/models/slices.test.js

@@ -0,0 +1,83 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _slices2 = require("./slices");
+
+test('one slice', function () {
+  var view = {
+    elidedRegions: [{
+      refName: 'toast',
+      start: 0,
+      end: 10000,
+      widthBp: 10000
+    }],
+    spacingPx: 5,
+    radiusPx: 1000,
+    totalBp: 10000,
+    bpPerRadian: 10000 / (2 * Math.PI),
+    pxPerRadian: 1000
+  };
+  var slices = (0, _slices2.calculateStaticSlices)(view); // console.log(slices)
+
+  expect(slices.length).toBe(1);
+
+  var _slices = (0, _slicedToArray2["default"])(slices, 1),
+      slice = _slices[0]; // expect(slices).toMatchSnapshot()
+
+
+  expect(slice).toMatchSnapshot();
+});
+test('two slices', function () {
+  var view = {
+    elidedRegions: [{
+      refName: 'toast',
+      start: 0,
+      end: 10000,
+      widthBp: 10000
+    }, {
+      refName: 'teest',
+      start: 0,
+      end: 10000,
+      widthBp: 10000
+    }],
+    spacingPx: 5,
+    radiusPx: 1000,
+    pxPerRadian: 1000,
+    totalBp: 20000,
+    bpPerRadian: 20000 / (2 * Math.PI)
+  };
+  var slices = (0, _slices2.calculateStaticSlices)(view); // console.log(slices)
+
+  expect(slices.length).toBe(2);
+  expect(slices).toMatchSnapshot();
+});
+test('volvox', function () {
+  var totalBp = 50001 + 6079;
+  var view = {
+    elidedRegions: [{
+      refName: 'ctgA',
+      start: 0,
+      end: 50001,
+      assemblyName: 'volvox',
+      widthBp: 50001
+    }, {
+      refName: 'ctgB',
+      start: 0,
+      end: 6079,
+      assemblyName: 'volvox',
+      widthBp: 6079
+    }],
+    spacingPx: 5,
+    radiusPx: 1000,
+    pxPerRadian: 1000,
+    totalBp: totalBp,
+    bpPerRadian: totalBp / (2 * Math.PI)
+  };
+  var slices = (0, _slices2.calculateStaticSlices)(view); // console.log(slices)
+
+  expect(slices.length).toBe(2);
+  expect(slices).toMatchSnapshot();
+});

package/dist/CircularView/models/viewportVisibleRegion.d.ts

@@ -1,6 +1,6 @@
-export declare function cartesianToPolar(x: number, y: number): number[];
-export declare function thetaRangesOverlap(r1start: number, r1length: number, r2start: number, r2length: number): boolean;
-export declare function viewportVisibleSection(viewSides: [number, number, number, number], circleCenter: [number, number], circleRadius: number): {
-    rho: number[];
-    theta: number[];
-};
+export declare function cartesianToPolar(x: number, y: number): number[];
+export declare function thetaRangesOverlap(r1start: number, r1length: number, r2start: number, r2length: number): boolean;
+export declare function viewportVisibleSection(viewSides: [number, number, number, number], circleCenter: [number, number], circleRadius: number): {
+    rho: number[];
+    theta: number[];
+};

package/dist/CircularView/models/viewportVisibleRegion.js

@@ -0,0 +1,280 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cartesianToPolar = cartesianToPolar;
+exports.thetaRangesOverlap = thetaRangesOverlap;
+exports.viewportVisibleSection = viewportVisibleSection;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+function findCircleIntersectionX(y, cx, cy, r, resultArray) {
+  var d = Math.abs(y - cy);
+
+  if (d > r) {
+    return;
+  }
+
+  if (d === r) {
+    resultArray.push([cx, y]);
+  }
+
+  var solution = Math.sqrt(r * r - d * d);
+  resultArray.push([cx - solution, y]);
+  resultArray.push([cx + solution, y]);
+}
+
+function findCircleIntersectionY(x, cx, cy, r, resultArray) {
+  var d = Math.abs(x - cx);
+
+  if (d > r) {
+    return;
+  }
+
+  if (d === r) {
+    resultArray.push([x, cy]);
+  }
+
+  var solution = Math.sqrt(r * r - d * d);
+  resultArray.push([x, cy - solution]);
+  resultArray.push([x, cy + solution]);
+}
+
+function cartesianToTheta(x, y) {
+  var theta = (Math.atan(y / x) + 2 * Math.PI) % (2 * Math.PI);
+
+  if (x < 0) {
+    if (y <= 0) {
+      theta += Math.PI;
+    } else {
+      theta -= Math.PI;
+    }
+  }
+
+  return theta;
+}
+
+function cartesianToPolar(x, y) {
+  var rho = Math.sqrt(x * x + y * y);
+
+  if (rho === 0) {
+    return [0, 0];
+  }
+
+  var theta = cartesianToTheta(x, y);
+  return [rho, theta];
+}
+
+var twoPi = 2 * Math.PI;
+
+function thetaRangesOverlap(r1start, r1length, r2start, r2length) {
+  if (r1length <= 0 || r2length <= 0) {
+    return false;
+  }
+
+  if (r1length + 0.0001 >= twoPi || r2length + 0.0001 >= twoPi) {
+    return true;
+  } // put both range starts between 2π and 4π
+
+
+  r1start = (r1start % twoPi + twoPi) % twoPi + twoPi;
+  r2start = (r2start % twoPi + twoPi) % twoPi + twoPi;
+
+  if (r1start < r2start + r2length && r1start + r1length > r2start) {
+    return true;
+  } // move r2 2π to the left and check
+
+
+  r2start -= twoPi;
+
+  if (r1start < r2start + r2length && r1start + r1length > r2start) {
+    return true;
+  } // move it 2π to the right and check
+
+
+  r2start += twoPi + twoPi;
+  return r1start < r2start + r2length && r1start + r1length > r2start;
+} // return which arc range has any part of the circle visible in the viewport
+
+
+function viewportVisibleSection(viewSides, circleCenter, circleRadius) {
+  var _viewSides = (0, _slicedToArray2["default"])(viewSides, 4),
+      viewL = _viewSides[0],
+      viewR = _viewSides[1],
+      viewT = _viewSides[2],
+      viewB = _viewSides[3];
+
+  var _circleCenter = (0, _slicedToArray2["default"])(circleCenter, 2),
+      cx = _circleCenter[0],
+      cy = _circleCenter[1]; // transform coordinate system to center of circle
+
+
+  viewL -= cx;
+  viewR -= cx;
+  viewT -= cy;
+  viewB -= cy;
+  var centerIsInsideViewport = viewL < 0 && viewR > 0 && viewT < 0 && viewB > 0;
+
+  if (centerIsInsideViewport) {
+    var _vertices = [[viewL, viewT], [viewR, viewT], [viewL, viewB], [viewR, viewB]];
+    var maxRho = -Infinity;
+
+    for (var i = 0; i < _vertices.length; i += 1) {
+      var _vertices$i = (0, _slicedToArray2["default"])(_vertices[i], 2),
+          x = _vertices$i[0],
+          y = _vertices$i[1];
+
+      var rho = Math.sqrt(x * x + y * y);
+
+      if (rho > maxRho) {
+        maxRho = rho;
+      }
+    }
+
+    return {
+      rho: [0, Math.min(circleRadius, maxRho)],
+      theta: [0, 2 * Math.PI]
+    };
+  } // const viewportCompletelyContainsCircle =
+  //   circleCenter[0] - viewL >= circleRadius &&
+  //   viewR - circleCenter[0] >= circleRadius &&
+  //   circleCenter[1] - viewT >= circleRadius &&
+  //   viewB - circleCenter[1] >= circleRadius
+  // if (viewportCompletelyContainsCircle) {
+  //   return [0, 2 * Math.PI]
+  // }
+  // const distToCenterSquared = ([x, y]) => {
+  //   const [cx, cy] = circleCenter
+  //   const sq = n => n * n
+  //   return sq(x - cx) + sq(y - cy)
+  // }
+  // const circleRadiusSquared = circleRadius * circleRadius
+  // const tlInside = distToCenterSquared([viewL, viewT]) <= circleRadiusSquared
+  // const trInside = distToCenterSquared([viewR, viewT]) <= circleRadiusSquared
+  // const blInside = distToCenterSquared([viewL, viewB]) <= circleRadiusSquared
+  // const brInside = distToCenterSquared([viewR, viewB]) <= circleRadiusSquared
+  // const noIntersection = !tlInside && !trInside && !blInside && !brInside
+  // if (noIntersection) return undefined
+  // const circleCompletelyContainsViewport =
+  //   tlInside && trInside && blInside && brInside
+  // if (circleCompletelyContainsViewport) {
+  //   // viewport is in the circle, but the center is not in it, so take max
+  //   // and min of thetas to the center
+  //   const thetas = [
+  //     Math.atan(viewT / viewL),
+  //     Math.atan(viewT / viewR),
+  //     Math.atan(viewB / viewL),
+  //     Math.atan(viewB / viewR),
+  //   ]
+  //   return [Math.min(...thetas), Math.max(...thetas)]
+  // }
+  // if we get here, the viewport is partly in, partly out of the circle
+  // const viewLIntersects = Math.abs(viewL - circleCenter[0]) <= circleRadius
+  // const viewRIntersects = Math.abs(viewR - circleCenter[0]) <= circleRadius
+  // const viewTIntersects = Math.abs(viewT - circleCenter[1]) <= circleRadius
+  // const viewBIntersects = Math.abs(viewB - circleCenter[1]) <= circleRadius
+  // const numIntersectingSides =
+  //   Number(viewLIntersects) +
+  //   Number(viewRIntersects) +
+  //   Number(viewTIntersects) +
+  //   Number(viewBIntersects)
+  // if (numIntersectingSides === 4) return [0, 2 * Math.PI]
+  // if (numIntersectingSides === 3) {
+  //   // TODO calculate the thetas of the
+  // } else if (numIntersectingSides === 2) {
+  //   // TODO calculate the thetas of the 2 intersection points
+  // } else if (numIntersectingSides === 1) {
+  //   // TODO calculate the thetas of the 1-2 intersection points of the line, and the angle between
+  // }
+  // make a list of vertices-of-interest that lie inside both shapes to examine
+  // to determine the range covered by their intersection
+  // transform coordinates to have the circle as the origin and find the intersections
+  // of the circle and the view rectangle
+
+
+  var vertices = [[viewL, viewT], [viewR, viewT], [viewL, viewB], [viewR, viewB]];
+  findCircleIntersectionY(viewL, 0, 0, circleRadius, vertices);
+  findCircleIntersectionY(viewR, 0, 0, circleRadius, vertices);
+  findCircleIntersectionX(viewT, 0, 0, circleRadius, vertices);
+  findCircleIntersectionX(viewB, 0, 0, circleRadius, vertices); // for each edge, also look at the closest point to center if it is inside the circle
+
+  if (-viewL < circleRadius) {
+    vertices.push([viewL, 0]);
+  }
+
+  if (viewR < circleRadius) {
+    vertices.push([viewR, 0]);
+  }
+
+  if (-viewT < circleRadius) {
+    vertices.push([0, viewT]);
+  }
+
+  if (viewB < circleRadius) {
+    vertices.push([0, viewB]);
+  } // const verticesOriginal = vertices.map(([x, y]) => [x + cx, y + cy])
+  // now convert them all to polar and take the max and min of rho and theta
+  // const viewportCenterTheta = cartesianToTheta(viewR + viewL, viewT + viewB)
+
+
+  var reflect = viewL >= 0 ? -1 : 1; // viewportCenterTheta < Math.PI / 2 || viewportCenterTheta > 1.5 * Math.PI
+  //   ? -1
+  //   : 1
+
+  var rhoMin = Infinity;
+  var rhoMax = -Infinity;
+  var thetaMin = Infinity;
+  var thetaMax = -Infinity;
+
+  for (var _i = 0; _i < vertices.length; _i += 1) {
+    // ignore vertex if outside the viewport
+    var _vertices$_i = (0, _slicedToArray2["default"])(vertices[_i], 2),
+        vx = _vertices$_i[0],
+        vy = _vertices$_i[1];
+
+    if (vx >= viewL && vx <= viewR && vy >= viewT && vy <= viewB) {
+      var _cartesianToPolar = cartesianToPolar(vx * reflect, vy * reflect),
+          _cartesianToPolar2 = (0, _slicedToArray2["default"])(_cartesianToPolar, 2),
+          _rho = _cartesianToPolar2[0],
+          theta = _cartesianToPolar2[1]; // ignore vertex if outside the circle
+
+
+      if (_rho <= circleRadius + 0.001) {
+        // ignore theta if rho is 0
+        if (theta < thetaMin && _rho > 0.0001) {
+          thetaMin = theta;
+        }
+
+        if (theta > thetaMax && _rho > 0.0001) {
+          thetaMax = theta;
+        }
+
+        if (_rho < rhoMin) {
+          rhoMin = _rho;
+        }
+
+        if (_rho > rhoMax) {
+          rhoMax = _rho;
+        }
+      }
+    }
+  }
+
+  if (reflect === -1) {
+    thetaMin += Math.PI;
+    thetaMax += Math.PI;
+  }
+
+  if (thetaMin > 2 * Math.PI && thetaMax > 2 * Math.PI) {
+    thetaMin -= 2 * Math.PI;
+    thetaMax -= 2 * Math.PI;
+  }
+
+  return {
+    rho: [rhoMin, Math.min(circleRadius, rhoMax)],
+    theta: [thetaMin, thetaMax]
+  };
+}

package/dist/CircularView/models/viewportVisibleRegion.test.js

@@ -0,0 +1,130 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _viewportVisibleRegion = require("./viewportVisibleRegion");
+
+describe('viewportVisibleSection', function () {
+  // test('circle contained in viewport', () => {
+  //   const result = viewportVisibleSection([0, 1, 0, 1], [0.5, 0.5], 0.3)
+  //   expect(result).toEqual({ rho: [0, 0.3], theta: [0, 2 * Math.PI] })
+  // })
+  // test('viewport completely inside circle', () => {
+  //   const result = viewportVisibleSection([0, 1, 0, 1], [0.5, 0.5], 20)
+  //   expect(result.theta).toEqual([0, 2 * Math.PI])
+  //   expect(result.rho[0]).toEqual(0)
+  //   expect(result.rho[1]).toBeCloseTo(0.7071)
+  // })
+  // test('viewport on left half of circle', () => {
+  //   const result = viewportVisibleSection([200, 500, 0, 1000], [500, 500], 20)
+  //   expect(result).toEqual({
+  //     rho: [0, 20],
+  //     theta: [Math.PI / 2, 1.5 * Math.PI],
+  //   })
+  // })
+  // test('viewport on right half of circle', () => {
+  //   const result = viewportVisibleSection([200, 500, 0, 1000], [200, 500], 20)
+  //   expect(result).toEqual({
+  //     rho: [0, 20],
+  //     theta: [1.5 * Math.PI, 2.5 * Math.PI],
+  //   })
+  // })
+  // test('viewport corner in circle', () => {
+  //   const { theta, rho } = viewportVisibleSection(
+  //     [200, 500, 0, 700],
+  //     [199, 701],
+  //     100,
+  //   )
+  //   expect(rho).toEqual([1.4142135623730951, 100])
+  //   expect(theta[0]).toBeCloseTo(1.5 * Math.PI, 1)
+  //   expect(theta[1]).toBeCloseTo(2 * Math.PI, 1)
+  // })
+  // test('viewport on center right', () => {
+  //   const { theta, rho } = viewportVisibleSection(
+  //     [1102, 2153, 880, 1280],
+  //     [1068.8119697255406, 1068.8119697255406],
+  //     1048.8119697255406,
+  //   )
+  //   expect(theta[1]).toBeGreaterThan(2 * Math.PI)
+  //   expect(theta[1]).toBeLessThan(2.5 * Math.PI)
+  //   expect(theta[0]).toBeGreaterThan(1.5 * Math.PI)
+  //   expect(theta[0]).toBeLessThan(2 * Math.PI)
+  // })
+  // test('viewport on center right 2', () => {
+  //   const { theta, rho } = viewportVisibleSection(
+  //     [1816, 2937, 1074, 1474],
+  //     [1468.6015446723616, 1468.6015446723616],
+  //     1448.6015446723616,
+  //   )
+  //   expect(theta[1]).toBeGreaterThan(2 * Math.PI)
+  //   expect(theta[1]).toBeLessThan(2.5 * Math.PI)
+  //   expect(theta[0]).toBeGreaterThan(1.5 * Math.PI)
+  //   expect(theta[0]).toBeLessThan(2 * Math.PI)
+  // })
+  // test('viewport on lower center', () => {
+  //   const { theta, rho } = viewportVisibleSection(
+  //     [259, 1350, 1176, 1576],
+  //     [787.7952717090081, 787.7952717090081],
+  //     767.7952717090081,
+  //   )
+  //   expect(theta[1]).toBeGreaterThan(Math.PI / 2)
+  //   expect(theta[1]).toBeLessThan(Math.PI)
+  //   expect(theta[0]).toBeGreaterThan(0)
+  //   expect(theta[0]).toBeLessThan(Math.PI / 2)
+  // })
+  // test('viewport on upper center', () => {
+  //   const { theta, rho } = viewportVisibleSection(
+  //     [286, 1377, 0, 400],
+  //     [787.7952717090081, 787.7952717090081],
+  //     767.7952717090081,
+  //   )
+  //   expect(theta[1]).toBeGreaterThan(1.5 * Math.PI)
+  //   expect(theta[1]).toBeLessThan(2 * Math.PI)
+  //   expect(theta[0]).toBeGreaterThan(Math.PI)
+  //   expect(theta[0]).toBeLessThan(1.5 * Math.PI)
+  // })
+  test('viewport on upper center 2', function () {
+    // [180.48708681644143, 359.3411680673888] [4.6042679453532855, 541.6042679453533]
+    // see '~/Desktop/Screen Shot 2019-06-28 at 3.01.22 PM.png'
+    var _viewportVisibleSecti = (0, _viewportVisibleRegion.viewportVisibleSection)([0, 962, 157, 557], [561.6042679453533, 561.6042679453533], 541.6042679453533),
+        theta = _viewportVisibleSecti.theta;
+
+    expect(theta[1]).toBeGreaterThan(1.75 * Math.PI);
+    expect(theta[1]).toBeLessThan(2 * Math.PI);
+    expect(theta[0]).toBeGreaterThan(Math.PI);
+    expect(theta[0]).toBeLessThan(1.1 * Math.PI);
+  });
+});
+describe('cartesian to polar', function () {
+  ;
+  [[[-1, -1], [1.414, 180 + 45]], [[-1, 1], [1.414, 90 + 45]], [[1, 1], [1.414, 45]], [[1, -1], [1.414, 360 - 45]], [[0, 1], [1, 90]], [[0, -1], [1, 270]], [[-1, 0], [1, 180]], [[1, 0], [1, 0]]].forEach(function (testCase) {
+    var _testCase = (0, _slicedToArray2["default"])(testCase, 2),
+        input = _testCase[0],
+        output = _testCase[1];
+
+    test("".concat(input, " -> ").concat(output), function () {
+      var result = _viewportVisibleRegion.cartesianToPolar.apply(void 0, (0, _toConsumableArray2["default"])(input));
+
+      expect(result[0]).toBeCloseTo(output[0]);
+      expect(result[1] * 180 / Math.PI).toBeCloseTo(output[1]);
+    });
+  });
+});
+describe('theta overlap testing', function () {
+  ;
+  [[[0, 2 * Math.PI, 0, 2 * Math.PI], true], [[6.1, Math.PI / 2, 0, Math.PI / 2], true], [[6.1, Math.PI / 2, 0, 0.1], true], [[6.1, 0.1, 6.12, 0.05], true], [[-12, 0.1, -12.05, 0.05], false], [[-12, 0.1, -12.05, 0.06], true]].forEach(function (testCase) {
+    var _testCase2 = (0, _slicedToArray2["default"])(testCase, 2),
+        input = _testCase2[0],
+        output = _testCase2[1];
+
+    test("".concat(input, " -> ").concat(output), function () {
+      var result = _viewportVisibleRegion.thetaRangesOverlap.apply(void 0, (0, _toConsumableArray2["default"])(input));
+
+      expect(result).toBe(output);
+    });
+  });
+});

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import PluginManager from '@jbrowse/core/PluginManager';
-import Plugin from '@jbrowse/core/Plugin';
-export default class CircularViewPlugin extends Plugin {
-    name: string;
-    install(pluginManager: PluginManager): void;
-    configure(pluginManager: PluginManager): void;
-}
-export { BaseChordDisplayModel, baseChordDisplayConfig, BaseChordDisplayComponentFactory, } from './BaseChordDisplay';
+import PluginManager from '@jbrowse/core/PluginManager';
+import Plugin from '@jbrowse/core/Plugin';
+export default class CircularViewPlugin extends Plugin {
+    name: string;
+    install(pluginManager: PluginManager): void;
+    configure(pluginManager: PluginManager): void;
+}
+export { BaseChordDisplayModel, baseChordDisplayConfig, BaseChordDisplayComponentFactory, } from './BaseChordDisplay';