Source: model/Triplet.js

  1. /**
  2.  * @file Class Triplet.
  3.  * @version March 12, 2017
  4.  *
  5.  * @author Olivier Pirson --- http://www.opimedia.be/
  6.  * @license GPLv3 --- Copyright (C) 2017 Olivier Pirson
  7.  */
  9. /**
  10.  * A triplet of points.
  11.  */
  12. class Triplet {
  13.     /**
  14.      * Constructs a triplet (a, b, c) of points.
  15.      *
  16.      * @param {Point} a
  17.      * @param {Point} b
  18.      * @param {Point} c
  19.      */
  20.     constructor(a, b, c) {
  21.         assert(a instanceof Point, a);
  22.         assert(b instanceof Point, b);
  23.         assert(c instanceof Point, c);
  25.         this._a = a;
  26.         this._b = b;
  27.         this._c = c;
  28.     }
  32.     /**
  33.      * Returns the first point.
  34.      *
  35.      * @returns {Point}
  36.      */
  37.     get a() { return this._a; }
  40.     /**
  41.      * Returns the second point.
  42.      *
  43.      * @returns {Point}
  44.      */
  45.     get b() { return this._b; }
  48.     /**
  49.      * Returns the third point.
  50.      *
  51.      * @returns {Point}
  52.      */
  53.     get c() { return this._c; }
  57.     /**
  58.      * Returns a new triplet, copied of this.
  59.      *
  60.      * @returns {Triplet}
  61.      */
  62.     copy() {
  63.         return new Triplet(this.a, this.b, this.c);
  64.     }
  67.     /**
  68.      * Returns the cross product of the vector ab and bc.
  69.      *
  70.      * @returns {number}
  71.      */
  72.     crossProductMagnitude() {
  73.         const a = this.a;
  74.         const b = this.b;
  75.         const c = this.c;
  77.         return (b.x - a.x)*(c.y - a.y) - (c.x - a.x)*(b.y - a.y);
  78.     }
  81.     /**
  82.      * Returns true iff a, b and c are on the same line.
  83.      *
  84.      * @returns {boolean}
  85.      */
  86.     isCollinear() {
  87.         return isFloat0(this.orientation());
  88.     }
  91.     /**
  92.      * Returns true iff p is in the triangle formed by the triplet.
  93.      *
  94.      * Cf. http://stackoverflow.com/a/2049593/1333666
  95.      *
  96.      * @param {Point} p
  97.      *
  98.      * @returns {boolean}
  99.      */
  100.     isIn(p) {
  101.         assert(p instanceof Point, p);
  103.         const ps = [this.a, this.b, this.c];
  105.         sortRadiallyAroundFirst(ps);
  107.         const a = ps[0];
  108.         const b = ps[1];
  109.         const c = ps[2];
  111.         const orient1 = (new Triplet(p, a, b)).isLeftOn();
  112.         const orient2 = (new Triplet(p, b, c)).isLeftOn();
  113.         const orient3 = (new Triplet(p, c, a)).isLeftOn();
  115.         return (orient1 === orient2) && (orient2 === orient3);
  116.     }
  119.     /**
  120.      * Returns true iff c is left to ab.
  121.      *
  122.      * @returns {boolean}
  123.      */
  124.     isLeft() {
  125.         return (this.orientation() > 0);
  126.     }
  129.     /**
  130.      * Returns true iff c is left to ab or collinear.
  131.      *
  132.      * @returns {boolean}
  133.      */
  134.     isLeftOn() {
  135.         return (this.orientation() >= 0);
  136.     }
  139.     /**
  140.      * Returns true iff c is right to ab.
  141.      *
  142.      * @returns {boolean}
  143.      */
  144.     isRight() {
  145.         return (this.orientation() < 0);
  146.     }
  149.     /**
  150.      * Returns true iff c is right to ab or collinear.
  151.      *
  152.      * @returns {boolean}
  153.      */
  154.     isRightOn() {
  155.         return (this.orientation() <= 0);
  156.     }
  159.     /**
  160.      * Returns the orientation of the point c compared to ab.
  161.      *
  162.      * If     -1 then c is on the right,
  163.      * else if 0 then c is on the same line that ab,
  164.      * else if 1 then c is on the left.
  165.      *
  166.      * @returns {number} -1, 0 or 1
  167.      */
  168.     orientation() {
  169.         const magnitude = this.crossProductMagnitude();
  171.         return Math.sign(magnitude);
  172.     }
  175.     /**
  176.      * Returns a string representation of the triplet.
  177.      *
  178.      * Each number is represented with at most precision figures after the decimal point.
  179.      *
  180.      * @returns {String}
  181.      */
  182.     toString(precision=2) {
  183.         assert(Number.isInteger(precision), precision);
  184.         assert(precision >= 0, precision);
  186.         return (this.a.toString(precision)
  187.                 + ":" + this.b.toString(precision)
  188.                 + ":" + this.c.toString(precision));
  189.     }
  190. }