classes/segment.js

  1. /**
  2.  * Created by Alex Bol on 3/10/2017.
  3.  */
  6. "use strict";
  8. module.exports = function (Flatten) {
  9.     /**
  10.      * Class representing a segment
  11.      * @type {Segment}
  12.      */
  13.     Flatten.Segment = class Segment {
  14.         /**
  15.          *
  16.          * @param {Point} ps - start point
  17.          * @param {Point} pe - end point
  18.          */
  19.         constructor(...args) {
  20.             /**
  21.              * Start point
  22.              * @type {Point}
  23.              */
  24.             this.ps = new Flatten.Point();
  25.             /**
  26.              * End Point
  27.              * @type {Point}
  28.              */
  29.             this.pe = new Flatten.Point();
  31.             if (args.length == 0) {
  32.                 return;
  33.             }
  35.             if (args.length == 1 && args[0] instanceof Array && args[0].length == 4) {
  36.                 let coords = args[0];
  37.                 this.ps = new Flatten.Point(coords[0], coords[1]);
  38.                 this.pe = new Flatten.Point(coords[2], coords[3]);
  39.                 return;
  40.             }
  42.             if (args.length == 1 && args[0] instanceof Object && args[0].name === "segment") {
  43.                 let {ps,pe} = args[0];
  44.                 this.ps = new Flatten.Point(ps.x, ps.y);
  45.                 this.pe = new Flatten.Point(pe.x, pe.y);
  46.                 return;
  47.             }
  49.             if (args.length == 2 && args[0] instanceof Flatten.Point && args[1] instanceof Flatten.Point) {
  50.                 this.ps = args[0].clone();
  51.                 this.pe = args[1].clone();
  52.                 return;
  53.             }
  55.             if (args.length == 4) {
  56.                 this.ps = new Flatten.Point(args[0], args[1]);
  57.                 this.pe = new Flatten.Point(args[2], args[3]);
  58.                 return;
  59.             }
  61.             throw Flatten.Errors.ILLEGAL_PARAMETERS;
  62.         }
  64.         /**
  65.          * Method clone copies segment and returns a new instance
  66.          * @returns {Segment}
  67.          */
  68.         clone() {
  69.             return new Flatten.Segment(this.start, this.end);
  70.         }
  72.         /**
  73.          * Start point
  74.          * @returns {Point}
  75.          */
  76.         get start() {
  77.             return this.ps;
  78.         }
  80.         /**
  81.          * End point
  82.          * @returns {Point}
  83.          */
  84.         get end() {
  85.             return this.pe;
  86.         }
  89.         /**
  90.          * Returns array of start and end point
  91.          * @returns [Point,Point]
  92.          */
  93.         get vertices() {
  94.             return [this.ps.clone(), this.pe.clone()];
  95.         }
  97.         /**
  98.          * Length of a segment
  99.          * @returns {number}
  100.          */
  101.         get length() {
  102.             return this.start.distanceTo(this.end)[0];
  103.         }
  105.         /**
  106.          * Slope of the line - angle to axe x in radians from 0 to 2PI
  107.          * @returns {number}
  108.          */
  109.         get slope() {
  110.             let vec = new Flatten.Vector(this.start, this.end);
  111.             return vec.slope;
  112.         }
  114.         /**
  115.          * Bounding box
  116.          * @returns {Box}
  117.          */
  118.         get box() {
  119.             return new Flatten.Box(
  120.                 Math.min(this.start.x, this.end.x),
  121.                 Math.min(this.start.y, this.end.y),
  122.                 Math.max(this.start.x, this.end.x),
  123.                 Math.max(this.start.y, this.end.y)
  124.             )
  125.         }
  127.         /**
  128.          * Returns true if equals to query segment, false otherwise
  129.          * @param {Seg} seg - query segment
  130.          * @returns {boolean}
  131.          */
  132.         equalTo(seg) {
  133.             return this.ps.equalTo(seg.ps) && this.pe.equalTo(seg.pe);
  134.         }
  136.         /**
  137.          * Returns true if segment contains point
  138.          * @param {Point} pt Query point
  139.          * @returns {boolean}
  140.          */
  141.         contains(pt) {
  142.             return Flatten.Utils.EQ_0(this.distanceToPoint(pt));
  143.         }
  145.         /**
  146.          * Returns array of intersection points between segment and other shape
  147.          * @param {Shape} shape - Shape of the one of supported types <br/>
  148.          * @returns {Point[]}
  149.          */
  150.         intersect(shape) {
  151.             if (shape instanceof Flatten.Point) {
  152.                 return this.contains(shape) ? [shape] : [];
  153.             }
  155.             if (shape instanceof Flatten.Line) {
  156.                 return Segment.intersectSegment2Line(this, shape);
  157.             }
  159.             if (shape instanceof Flatten.Segment) {
  160.                 return Segment.intersectSegment2Segment(this, shape);
  161.             }
  163.             if (shape instanceof Flatten.Circle) {
  164.                 return Segment.intersectSegment2Circle(this, shape);
  165.             }
  167.             if (shape instanceof Flatten.Arc) {
  168.                 return Segment.intersectSegment2Arc(this, shape);
  169.             }
  171.             if (shape instanceof Flatten.Polygon) {
  172.                 return Flatten.Polygon.intersectShape2Polygon(this, shape);
  173.             }
  174.         }
  176.         /**
  177.          * Calculate distance and shortest segment from segment to shape and return as array [distance, shortest segment]
  178.          * @param {Shape} shape Shape of the one of supported types Point, Line, Circle, Segment, Arc, Polygon or Planar Set
  179.          * @returns {number} distance from segment to shape
  180.          * @returns {Segment} shortest segment between segment and shape (started at segment, ended at shape)
  181.          */
  182.         distanceTo(shape) {
  183.             let {Distance} = Flatten;
  185.             if (shape instanceof Flatten.Point) {
  186.                 let [dist, shortest_segment] = Distance.point2segment(shape, this);
  187.                 shortest_segment = shortest_segment.reverse();
  188.                 return [dist, shortest_segment];
  189.             }
  191.             if (shape instanceof Flatten.Circle) {
  192.                 let [dist, shortest_segment] = Distance.segment2circle(this, shape);
  193.                 return [dist, shortest_segment];
  194.             }
  196.             if (shape instanceof Flatten.Line) {
  197.                 let [dist, shortest_segment] = Distance.segment2line(this, shape);
  198.                 return [dist, shortest_segment];
  199.             }
  201.             if (shape instanceof Flatten.Segment) {
  202.                 let [dist, shortest_segment] = Distance.segment2segment(this, shape);
  203.                 return [dist, shortest_segment];
  204.             }
  206.             if (shape instanceof Flatten.Arc) {
  207.                 let [dist, shortest_segment] = Distance.segment2arc(this, shape);
  208.                 return [dist, shortest_segment];
  209.             }
  211.             if (shape instanceof Flatten.Polygon) {
  212.                 let [dist, shortest_segment] = Distance.shape2polygon(this, shape);
  213.                 return [dist, shortest_segment];
  214.             }
  216.             if (shape instanceof Flatten.PlanarSet) {
  217.                 let [dist, shortest_segment] = Distance.shape2planarSet(this, shape);
  218.                 return [dist, shortest_segment];
  219.             }
  220.         }
  222.         /**
  223.          * Returns unit vector in the direction from start to end
  224.          * @returns {Vector}
  225.          */
  226.         tangentInStart() {
  227.             let vec = new Flatten.Vector(this.start, this.end);
  228.             return vec.normalize();
  229.         }
  231.         /**
  232.          * Return unit vector in the direction from end to start
  233.          * @returns {Vector}
  234.          */
  235.         tangentInEnd() {
  236.             let vec = new Flatten.Vector(this.end, this.start);
  237.             return vec.normalize();
  238.         }
  240.         /**
  241.          * Returns new segment with swapped start and end points
  242.          * @returns {Segment}
  243.          */
  244.         reverse() {
  245.             return new Segment(this.end, this.start);
  246.         }
  248.         /**
  249.          * When point belongs to segment, return array of two segments split by given point,
  250.          * if point is inside segment. Returns clone of this segment if query point is incident
  251.          * to start or end point of the segment. Returns empty array if point does not belong to segment
  252.          * @param {Point} pt Query point
  253.          * @returns {Segment[]}
  254.          */
  255.         split(pt) {
  256.             if (!this.contains(pt))
  257.                 return [];
  259.             if (this.start.equalTo(this.end))
  260.                 return [this.clone()];
  262.             if (this.start.equalTo(pt) || this.end.equalTo(pt))
  263.                 return [this];
  265.             return [
  266.                 new Flatten.Segment(this.start, pt),
  267.                 new Flatten.Segment(pt, this.end)
  268.             ]
  269.         }
  271.         /**
  272.          * Return middle point of the segment
  273.          * @returns {Point}
  274.          */
  275.         middle() {
  276.             return new Flatten.Point((this.start.x + this.end.x)/2, (this.start.y + this.end.y)/2);
  277.         }
  279.         distanceToPoint(pt) {
  280.             let [dist, ...rest] = Flatten.Distance.point2segment(pt, this);
  281.             return dist;
  282.         };
  284.         definiteIntegral(ymin = 0.0) {
  285.             let dx = this.end.x - this.start.x;
  286.             let dy1 = this.start.y - ymin;
  287.             let dy2 = this.end.y - ymin;
  288.             return ( dx * (dy1 + dy2) / 2 );
  289.         }
  291.         /**
  292.          * Returns new segment translated by vector vec
  293.          * @param {Vector} vec
  294.          * @returns {Segment}
  295.          */
  296.         translate(...args) {
  297.             return new Segment(this.ps.translate(...args), this.pe.translate(...args));
  298.         }
  300.         /**
  301.          * Return new segment rotated by given angle around given point
  302.          * If point omitted, rotate around origin (0,0)
  303.          * Positive value of angle defines rotation counter clockwise, negative - clockwise
  304.          * @param {number} angle - rotation angle in radians
  305.          * @param {Point} center - center point, default is (0,0)
  306.          * @returns {Segment}
  307.          */
  308.         rotate(angle = 0, center = new Flatten.Point()) {
  309.             let m = new Flatten.Matrix();
  310.             m = m.translate(center.x, center.y).rotate(angle).translate(-center.x, -center.y);
  311.             return this.transform(m);
  312.         }
  314.         /**
  315.          * Return new segment transformed using affine transformation matrix
  316.          * @param {Matrix} matrix - affine transformation matrix
  317.          * @returns {Segment} - transformed segment
  318.          */
  319.         transform(matrix = new Flatten.Matrix()) {
  320.             return new Segment(this.ps.transform(matrix), this.pe.transform(matrix))
  321.         }
  323.         /**
  324.          * Returns true if segment start is equal to segment end up to DP_TOL
  325.          * @returns {boolean}
  326.          */
  327.         isZeroLength() {
  328.             return this.ps.equalTo(this.pe)
  329.         }
  331.         static intersectSegment2Line(seg, line) {
  332.             let ip = [];
  334.             // Boundary cases
  335.             if (seg.ps.on(line)) {
  336.                 ip.push(seg.ps);
  337.             }
  338.             // If both ends lay on line, return two intersection points
  339.             if (seg.pe.on(line) && !seg.isZeroLength()) {
  340.                 ip.push(seg.pe);
  341.             }
  343.             if (ip.length > 0) {
  344.                 return ip;          // done, intersection found
  345.             }
  347.             // If zero-length segment and nothing found, return no intersections
  348.             if (seg.isZeroLength()) {
  349.                 return ip;
  350.             }
  352.             // Not a boundary case, check if both points are on the same side and
  353.             // hence there is no intersection
  354.             if (seg.ps.leftTo(line) && seg.pe.leftTo(line) ||
  355.                 !seg.ps.leftTo(line) && !seg.pe.leftTo(line)) {
  356.                 return ip;
  357.             }
  359.             // Calculate intersection between lines
  360.             let line1 = new Flatten.Line(seg.ps, seg.pe);
  361.             return line1.intersect(line);
  362.         }
  364.         static intersectSegment2Segment(seg1, seg2) {
  365.             let ip = [];
  367.             // quick reject
  368.             if (seg1.box.not_intersect(seg2.box)) {
  369.                 return ip;
  370.             }
  372.             // Special case of seg1 zero length
  373.             if (seg1.isZeroLength()) {
  374.                 if (seg1.ps.on(seg2)) {
  375.                     ip.push(seg1.ps);
  376.                 }
  377.                 return ip;
  378.             }
  380.             // Special case of seg2 zero length
  381.             if (seg2.isZeroLength()) {
  382.                 if (seg2.ps.on(seg1)) {
  383.                     ip.push(seg2.ps);
  384.                 }
  385.                 return ip;
  386.             }
  388.             // Neither seg1 nor seg2 is zero length
  389.             let line1 = new Flatten.Line(seg1.ps, seg1.pe);
  390.             let line2 = new Flatten.Line(seg2.ps, seg2.pe);
  392.             // Check overlapping between segments in case of incidence
  393.             // If segments touching, add one point. If overlapping, add two points
  394.             if (line1.incidentTo(line2)) {
  395.                 if (seg1.ps.on(seg2)) {
  396.                     ip.push(seg1.ps);
  397.                 }
  398.                 if (seg1.pe.on(seg2)) {
  399.                     ip.push(seg1.pe);
  400.                 }
  401.                 if (seg2.ps.on(seg1) && !seg2.ps.equalTo(seg1.ps) && !seg2.ps.equalTo(seg1.pe)) {
  402.                     ip.push(seg2.ps);
  403.                 }
  404.                 if (seg2.pe.on(seg1) && !seg2.pe.equalTo(seg1.ps) && !seg2.pe.equalTo(seg1.pe)) {
  405.                     ip.push(seg2.pe);
  406.                 }
  407.             }
  408.             else {                /* not incident - parallel or intersect */
  409.                 // Calculate intersection between lines
  410.                 let new_ip = line1.intersect(line2);
  411.                 if (new_ip.length > 0 && new_ip[0].on(seg1) && new_ip[0].on(seg2)) {
  412.                     ip.push(new_ip[0]);
  413.                 }
  414.             }
  416.             return ip;
  417.         }
  419.         static intersectSegment2Circle(segment, circle) {
  420.             let ips = [];
  422.             if (segment.box.not_intersect(circle.box)) {
  423.                 return ips;
  424.             }
  426.             // Special case of zero length segment
  427.             if (segment.isZeroLength()) {
  428.                 let [dist,shortest_segment] = segment.ps.distanceTo(circle.pc);
  429.                 if (Flatten.Utils.EQ(dist, circle.r)) {
  430.                     ips.push(segment.ps);
  431.                 }
  432.                 return ips;
  433.             }
  435.             // Non zero-length segment
  436.             let line = new Flatten.Line(segment.ps, segment.pe);
  438.             let ips_tmp = line.intersect(circle);
  440.             for (let ip of ips_tmp) {
  441.                 if (ip.on(segment)) {
  442.                     ips.push(ip);
  443.                 }
  444.             }
  446.             return ips;
  447.         }
  449.         static intersectSegment2Arc(segment, arc) {
  450.             let ip = [];
  452.             if (segment.box.not_intersect(arc.box)) {
  453.                 return ip;
  454.             }
  456.             // Special case of zero-length segment
  457.             if (segment.isZeroLength()) {
  458.                 if (segment.ps.on(arc)) {
  459.                     ip.push(segment.ps);
  460.                 }
  461.                 return ip;
  462.             }
  464.             // Non-zero length segment
  465.             let line = new Flatten.Line(segment.ps, segment.pe);
  466.             let circle = new Flatten.Circle(arc.pc, arc.r);
  468.             let ip_tmp = line.intersect(circle);
  470.             for (let pt of ip_tmp) {
  471.                 if (pt.on(segment) && pt.on(arc)) {
  472.                     ip.push(pt);
  473.                 }
  474.             }
  475.             return ip;
  477.         }
  479.         /**
  480.          * Return string to draw segment in svg
  481.          * @param {Object} attrs - an object with attributes for svg path element,
  482.          * like "stroke", "strokeWidth" <br/>
  483.          * Defaults are stroke:"black", strokeWidth:"1"
  484.          * @returns {string}
  485.          */
  486.         svg(attrs = {}) {
  487.             let {stroke, strokeWidth, id, className} = attrs;
  488.             // let rest_str = Object.keys(rest).reduce( (acc, key) => acc += ` ${key}="${rest[key]}"`, "");
  489.             let id_str = (id && id.length > 0) ? `id="${id}"` : "";
  490.             let class_str = (className && className.length > 0) ? `class="${className}"` : "";
  492.             return `\n<line x1="${this.start.x}" y1="${this.start.y}" x2="${this.end.x}" y2="${this.end.y}" stroke="${stroke || "black"}" stroke-width="${strokeWidth || 1}" ${id_str} ${class_str} />`;
  494.         }
  496.         /**
  497.          * This method returns an object that defines how data will be
  498.          * serialized when called JSON.stringify() method
  499.          * @returns {Object}
  500.          */
  501.         toJSON() {
  502.             return Object.assign({},this,{name:"segment"});
  503.         }
  504.     };
  506.     /**
  507.      * Shortcut method to create new segment
  508.      */
  509.     Flatten.segment = (...args) => new Flatten.Segment(...args);
  510. };