Source: model/Segment.js

  1. /**
  2.  * @file Class Segment.
  3.  * @version March 22, 2017
  4.  *
  5.  * @author Olivier Pirson --- http://www.opimedia.be/
  6.  * @license GPLv3 --- Copyright (C) 2017 Olivier Pirson
  7.  */
  9. /**
  10.  * A segment,
  11.  * represented by its two points.
  12.  */
  13. class Segment {
  14.     /**
  15.      * Constructs a segment from point a to point b.
  16.      *
  17.      * @param a: Point
  18.      * @param b: Point != a
  19.      */
  20.     constructor(a, b) {
  21.         assert(a instanceof Point, a);
  22.         assert(b instanceof Point, b);
  23.         assert(!a.isEquals(b));
  25.         this._a = a;
  26.         this._b = b;
  27.     }
  30.     /**
  31.      * Returns the first point.
  32.      *
  33.      * @returns {Point}
  34.      */
  35.     get a() { return this._a; }
  38.     /**
  39.      * Returns the second point.
  40.      *
  41.      * @returns {Point}
  42.      */
  43.     get b() { return this._b; }
  47.     /**
  48.      * Compare two segments before with min points
  49.      * and maybe after with max points.
  50.      *
  51.      * @param {Segment} other
  52.      *
  53.      * @returns {number} -1, 0 or 1
  54.      */
  55.     compare(other) {
  56.         assert(other instanceof Segment, other);
  58.         const compA = this.a.compare(this.b);
  59.         const compOtherA = other.a.compare(other.b);
  61.         let comp = (compA <= 0
  62.                     ? (compOtherA <= 0
  63.                        ? this.a.compare(other.a)
  64.                        : this.a.compare(other.b))
  65.                     : (compOtherA <= 0
  66.                        ? this.b.compare(other.a)
  67.                        : this.b.compare(other.b)));
  69.         return (comp !== 0
  70.                 ? comp
  71.                 : (compA <= 0
  72.                    ? (compOtherA <= 0
  73.                       ? this.b.compare(other.b)
  74.                       : this.b.compare(other.a))
  75.                    : (compOtherA <= 0
  76.                       ? this.a.compare(other.b)
  77.                       : this.a.compare(other.a))));
  78.     }
  81.     /**
  82.      * Returns true iff have at leat one common endpoint.
  83.      */
  84.     isCommonEndPoint(other) {
  85.         assert(other instanceof Segment, other);
  87.         return (this.a.isEquals(other.a) || this.a.isEquals(other.b)
  88.                 || this.b.isEquals(other.b) || this.b.isEquals(other.a));
  89.     }
  92.     /**
  93.      * Returns true iff the segment is equals to the segment other,
  94.      * namely iff they are same points (regardless of the order).
  95.      *
  96.      * @param {Segment} other
  97.      *
  98.      * @returns {boolean}
  99.      */
  100.     isEquals(other) {
  101.         assert(other instanceof Segment, other);
  103.         return (((this.a === other.a) && (this.b === other.b))
  104.                 || ((this.a === other.b) && (this.b === other.a)));
  105.     }
  108.     /**
  109.      * Returns true iff point is an extremity point of the segment.
  110.      *
  111.      * @param {Point} point
  112.      *
  113.      * @returns {boolean}
  114.      */
  115.     isExtremityPoint(point) {
  116.         assert(point instanceof Point, point);
  118.         return point.isEquals(this.a) || point.isEquals(this.b);
  119.     }
  122.     /**
  123.      * Returns true iff is a horizontal segment
  124.      *
  125.      * @returns {boolean}
  126.      */
  127.     isHorizontal() {
  128.         return (this.a.y === this.b.y);
  129.     }
  132.     /**
  133.      * Returns true iff p is in the segment (inclusive its extremities).
  134.      *
  135.      * @param {Point} p
  136.      *
  137.      * @returns {boolean}
  138.      */
  139.     isIn(p) {
  140.         assert(p instanceof Point, p);
  142.         if (!this.isInSameLine(p)) {   // not on the same line
  143.             return false;
  144.         }
  145.         else if (this.isVertical()) {  // on the same vertical line
  146.             return ((this.a.x <= p.x) && (p.x <= this.b.x)) || ((this.b.x <= p.x) && (p.x <= this.a.x));
  147.         }
  148.         else {                         // on the same line, not vertical
  149.             return ((this.a.y <= p.y) && (p.y <= this.b.y)) || ((this.b.y <= p.y) && (p.y <= this.a.y));
  150.         }
  151.     }
  154.     /**
  155.      * Returns true iff p is in the same line that the segment.
  156.      *
  157.      * @param {Point} p
  158.      *
  159.      * @returns {boolean}
  160.      */
  161.     isInSameLine(p) {
  162.         assert(p instanceof Point, p);
  164.         return (new Triplet(this.a, this.b, p)).isCollinear();
  165.     }
  168.     /**
  169.      * Returns true iff two segments intersect.
  170.      *
  171.      * @param {Segment} other
  172.      *
  173.      * @returns {boolean}
  174.      */
  175.     isIntersect(other) {
  176.         assert(other instanceof Segment, other);
  178.         return (this.isProperIntersect(other)
  179.                 || this.isIn(other.a) || this.isIn(other.b)
  180.                 || other.isIn(this.a) || other.isIn(this.b));
  181.     }
  184.     /**
  185.      * Returns true iff p is in the segment (exclusive its extremities).
  186.      *
  187.      * @param {Point} p
  188.      *
  189.      * @returns {boolean}
  190.      */
  191.     isProperIn(p) {
  192.         assert(p instanceof Point, p);
  194.         if (!this.isInSameLine(p)) {   // not on the same line
  195.             return false;
  196.         }
  197.         else if (this.isVertical()) {  // on the same line, not vertical
  198.             return ((this.a.x < p.x) && (p.x < this.b.x)) || ((this.b.x < p.x) && (p.x < this.a.x));
  199.         }
  200.         else {                         // on the same vertical line
  201.             return ((this.a.y < p.y) && (p.y < this.b.y)) || ((this.b.y < p.y) && (p.y < this.a.y));
  202.         }
  203.     }
  206.     /**
  207.      * Returns true iff two segments intersect without their endpoints.
  208.      *
  209.      * @param {Segment} other
  210.      *
  211.      * @returns {boolean}
  212.      */
  213.     isProperIntersect(other) {
  214.         assert(other instanceof Segment, other);
  216.         const abc_abd = ((new Triplet(this.a, this.b, other.a)).orientation()
  217.                          *(new Triplet(this.a, this.b, other.b)).orientation());
  218.         const cda_cdb = ((new Triplet(other.a, other.b, this.a)).orientation()
  219.                          *(new Triplet(other.a, other.b, this.b)).orientation());
  221.         return (abc_abd * cda_cdb !== 0) && (abc_abd < 0) && (cda_cdb < 0);
  222.     }
  225.     /**
  226.      * Returns true iff the horizontal line of vertical coordonate y
  227.      * (strictically) intersect the segment.
  228.      */
  229.     isProperIntersectWithHorizontalLine(y) {
  230.         assert(typeof y === "number", y);
  232.         return (((this.a.y < y) && (y < this.b.y))
  233.                 || ((this.b.y < y) && (y < this.a.y)));
  234.     }
  237.     /**
  238.      * Returns true iff is a vertical segment
  239.      *
  240.      * @returns {boolean}
  241.      */
  242.     isVertical() {
  243.         return (this.a.x === this.b.x);
  244.     }
  247.     /**
  248.      * If segment.a <= segment.b
  249.      * then return this,
  250.      * else return a new segment with points swapped.
  251.      *
  252.      * @returns {Segment}
  253.      */
  254.     ordonned() {
  255.         return (this.a.compare(this.b) <= 0
  256.                 ? this
  257.                 : new Segment(this.b, this.a));
  258.     }
  261.     /**
  262.      * Returns the slope of the segment.
  263.      * If the segment is vertical, then return null.
  264.      *
  265.      * @returns {number|null}
  266.      */
  267.     slope() {
  268.         const diff_x = this.a.x - this.b.x;
  270.         return (this.isVertical()
  271.                 ? null
  272.                 : (this.a.y - this.b.y)/diff_x);
  273.     }
  276.     /**
  277.      * Returns a string representation of the segment.
  278.      *
  279.      * Each number is represented with at most precision figures after the decimal point.
  280.      *
  281.      * @returns {String}
  282.      */
  283.     toString(precision=2) {
  284.         assert(Number.isInteger(precision), precision);
  285.         assert(precision >= 0, precision);
  287.         return (this.a.toString(precision)
  288.                 + ":" + this.b.toString(precision));
  289.     }
  292.     /**
  293.      * Returns the y coordinate for the given x coordinate.
  294.      * If the segment is vertical, then return null.
  295.      *
  296.      * @param {number} x
  297.      *
  298.      * @returns {number|null}
  299.      */
  300.     yOnLine(x) {
  301.         assert(typeof x === "number", x);
  303.         return (this.isVertical()
  304.                 ? null
  305.                 : this.slope()*(x - this.a.x) + this.a.y);
  306.     }
  307. }