summit/frontend/node_modules/maath/dist/triangle-33ffdfef.cjs.dev.js

'use strict';

var isNativeReflectConstruct = require('./isNativeReflectConstruct-ddc4ebc1.cjs.dev.js');
var THREE = require('three');
var matrix_dist_maathMatrix = require('./matrix-fb190f60.cjs.dev.js');

function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}

function _iterableToArrayLimit(arr, i) {
  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];

  if (_i == null) return;
  var _arr = [];
  var _n = true;
  var _d = false;

  var _s, _e;

  try {
    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
      _arr.push(_s.value);

      if (i && _arr.length === i) break;
    }
  } catch (err) {
    _d = true;
    _e = err;
  } finally {
    try {
      if (!_n && _i["return"] != null) _i["return"]();
    } finally {
      if (_d) throw _e;
    }
  }

  return _arr;
}

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;
}

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 _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}

function _slicedToArray(arr, i) {
  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
}

function _arrayWithoutHoles(arr) {
  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
}

function _iterableToArray(iter) {
  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}

function _nonIterableSpread() {
  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}

function _toConsumableArray(arr) {
  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
}

function _construct(Parent, args, Class) {
  if (isNativeReflectConstruct._isNativeReflectConstruct()) {
    _construct = Reflect.construct;
  } else {
    _construct = function _construct(Parent, args, Class) {
      var a = [null];
      a.push.apply(a, args);
      var Constructor = Function.bind.apply(Parent, a);
      var instance = new Constructor();
      if (Class) isNativeReflectConstruct._setPrototypeOf(instance, Class.prototype);
      return instance;
    };
  }

  return _construct.apply(null, arguments);
}

/**
 *
 * @param point
 *
 * @param triangle
 *
 * @returns {boolean} true if the point is in the triangle
 *
 * TODO: Find explainer
 */
function isPointInTriangle(point, triangle) {
  var _triangle$ = _slicedToArray(triangle[0], 2),
      ax = _triangle$[0],
      ay = _triangle$[1];

  var _triangle$2 = _slicedToArray(triangle[1], 2),
      bx = _triangle$2[0],
      by = _triangle$2[1];

  var _triangle$3 = _slicedToArray(triangle[2], 2),
      cx = _triangle$3[0],
      cy = _triangle$3[1];

  var _point = _slicedToArray(point, 2),
      px = _point[0],
      py = _point[1]; // TODO Sub with static calc


  var matrix = new THREE.Matrix4(); // prettier-ignore

  matrix.set(ax, ay, ax * ax + ay * ay, 1, bx, by, bx * bx + by * by, 1, cx, cy, cx * cx + cy * cy, 1, px, py, px * px + py * py, 1);
  return matrix.determinant() <= 0;
}
function triangleDeterminant(triangle) {
  var _triangle$4 = _slicedToArray(triangle[0], 2),
      x1 = _triangle$4[0],
      y1 = _triangle$4[1];

  var _triangle$5 = _slicedToArray(triangle[1], 2),
      x2 = _triangle$5[0],
      y2 = _triangle$5[1];

  var _triangle$6 = _slicedToArray(triangle[2], 2),
      x3 = _triangle$6[0],
      y3 = _triangle$6[1]; // prettier-ignore


  return matrix_dist_maathMatrix.determinant3(x1, y1, 1, x2, y2, 1, x3, y3, 1);
}
/**
 * Uses triangle area determinant to check if 3 points are collinear.
 * If they are, they can't make a triangle, so the determinant will be 0!
 *
 *      0     1     2
 * ─────■─────■─────■
 *
 *
 * Fun fact, you can use this same determinant to check the order of the points in the triangle
 *
 * NOTE: Should this use a buffer instead? NOTE: Should this use a buffer instead? [x0, y0, x1, y1, x2, y2]?
 *
 */

function arePointsCollinear(points) {
  return triangleDeterminant(points) === 0;
} // TODO This is the same principle as the prev function, find a way to make it have sense

function isTriangleClockwise(triangle) {
  return triangleDeterminant(triangle) < 0;
}
/**
 
The circumcircle is a circle touching all the vertices of a triangle or polygon.

             ┌───┐             
             │ B │             
             └───┘             
           .───●───.           
        ,─'   ╱ ╲   '─.        
      ,'     ╱   ╲     `.      
     ╱      ╱     ╲      ╲     
    ;      ╱       ╲      :    
    │     ╱         ╲     │    
    │    ╱           ╲    │    
    :   ╱             ╲   ;    
     ╲ ╱               ╲ ╱     
┌───┐ ●─────────────────● ┌───┐
│ A │  `.             ,'  │ C │
└───┘    '─.       ,─'    └───┘
            `─────'                         
 */

/**
 *
 * @param triangle
 *
 * @returns {number} circumcircle
 */
// https://math.stackexchange.com/a/1460096

function getCircumcircle(triangle) {
  // TS-TODO the next few lines are ignored because the types aren't current to the change in vectors (that can now be iterated)
  // @ts-ignore
  var _triangle$7 = _slicedToArray(triangle[0], 2),
      ax = _triangle$7[0],
      ay = _triangle$7[1]; // @ts-ignore


  var _triangle$8 = _slicedToArray(triangle[1], 2),
      bx = _triangle$8[0],
      by = _triangle$8[1]; // @ts-ignore


  var _triangle$9 = _slicedToArray(triangle[2], 2),
      cx = _triangle$9[0],
      cy = _triangle$9[1];

  if (arePointsCollinear(triangle)) return null; // points are collinear

  var m = new THREE.Matrix4(); // prettier-ignore

  m.set(1, 1, 1, 1, ax * ax + ay * ay, ax, ay, 1, bx * bx + by * by, bx, by, 1, cx * cx + cy * cy, cx, cy, 1);
  var m11 = matrix_dist_maathMatrix.getMinor(m, 1, 1);
  var m13 = matrix_dist_maathMatrix.getMinor(m, 1, 3);
  var m12 = matrix_dist_maathMatrix.getMinor(m, 1, 2);
  var m14 = matrix_dist_maathMatrix.getMinor(m, 1, 4);
  var x0 = 0.5 * (m12 / m11);
  var y0 = 0.5 * (m13 / m11);
  var r2 = x0 * x0 + y0 * y0 + m14 / m11;
  return {
    x: Math.abs(x0) === 0 ? 0 : x0,
    y: Math.abs(y0) === 0 ? 0 : -y0,
    r: Math.sqrt(r2)
  };
} // https://stackoverflow.com/questions/39984709/how-can-i-check-wether-a-point-is-inside-the-circumcircle-of-3-points

function isPointInCircumcircle(point, triangle) {
  var _ref = Array.isArray(triangle[0]) ? triangle[0] : triangle[0].toArray(),
      _ref2 = _slicedToArray(_ref, 2),
      ax = _ref2[0],
      ay = _ref2[1];

  var _ref3 = Array.isArray(triangle[1]) ? triangle[1] : triangle[1].toArray(),
      _ref4 = _slicedToArray(_ref3, 2),
      bx = _ref4[0],
      by = _ref4[1];

  var _ref5 = Array.isArray(triangle[2]) ? triangle[2] : triangle[2].toArray(),
      _ref6 = _slicedToArray(_ref5, 2),
      cx = _ref6[0],
      cy = _ref6[1];

  var _point2 = _slicedToArray(point, 2),
      px = _point2[0],
      py = _point2[1];

  if (arePointsCollinear(triangle)) throw new Error("Collinear points don't form a triangle");
  /**
          | ax-px, ay-py, (ax-px)² + (ay-py)² |
    det = | bx-px, by-py, (bx-px)² + (by-py)² |
          | cx-px, cy-py, (cx-px)² + (cy-py)² |
  */

  var x1mpx = ax - px;
  var aympy = ay - py;
  var bxmpx = bx - px;
  var bympy = by - py;
  var cxmpx = cx - px;
  var cympy = cy - py; // prettier-ignore

  var d = matrix_dist_maathMatrix.determinant3(x1mpx, aympy, x1mpx * x1mpx + aympy * aympy, bxmpx, bympy, bxmpx * bxmpx + bympy * bympy, cxmpx, cympy, cxmpx * cxmpx + cympy * cympy); // if d is 0, the point is on C

  if (d === 0) {
    return true;
  }

  return !isTriangleClockwise(triangle) ? d > 0 : d < 0;
} // From https://algorithmtutor.com/Computational-Geometry/Determining-if-two-consecutive-segments-turn-left-or-right/

var mv1 = new THREE.Vector2();
var mv2 = new THREE.Vector2();
/**
 
     ╱      ╲     
    ╱        ╲    
   ▕          ▏   
                  
 right      left  

 * NOTE: Should this use a buffer instead? [x0, y0, x1, y1]?
 */

function doThreePointsMakeARight(points) {
  var _points$map = points.map(function (p) {
    if (Array.isArray(p)) {
      return _construct(THREE.Vector2, _toConsumableArray(p));
    }

    return p;
  }),
      _points$map2 = _slicedToArray(_points$map, 3),
      p1 = _points$map2[0],
      p2 = _points$map2[1],
      p3 = _points$map2[2];

  if (arePointsCollinear(points)) return false; // @ts-ignore

  var p2p1 = mv1.subVectors(p2, p1); // @ts-ignore

  var p3p1 = mv2.subVectors(p3, p1);
  var cross = p3p1.cross(p2p1);
  return cross > 0;
}

var triangle = /*#__PURE__*/Object.freeze({
  __proto__: null,
  isPointInTriangle: isPointInTriangle,
  triangleDeterminant: triangleDeterminant,
  arePointsCollinear: arePointsCollinear,
  isTriangleClockwise: isTriangleClockwise,
  getCircumcircle: getCircumcircle,
  isPointInCircumcircle: isPointInCircumcircle,
  doThreePointsMakeARight: doThreePointsMakeARight
});

exports._slicedToArray = _slicedToArray;
exports._toConsumableArray = _toConsumableArray;
exports.arePointsCollinear = arePointsCollinear;
exports.doThreePointsMakeARight = doThreePointsMakeARight;
exports.getCircumcircle = getCircumcircle;
exports.isPointInCircumcircle = isPointInCircumcircle;
exports.isPointInTriangle = isPointInTriangle;
exports.isTriangleClockwise = isTriangleClockwise;
exports.triangle = triangle;
exports.triangleDeterminant = triangleDeterminant;