classes/edge.js

  1. /**
  2.  * Created by Alex Bol on 3/17/2017.
  3.  */
  5. import Flatten from '../flatten';
  6. import {ray_shoot} from "../algorithms/ray_shooting";
  8. /**
  9.  * Class representing an edge of polygon. Edge shape may be Segment or Arc.
  10.  * Each edge contains references to the next and previous edges in the face of the polygon.
  11.  *
  12.  * @type {Edge}
  13.  */
  14. export class Edge {
  15.     /**
  16.      * Construct new instance of edge
  17.      * @param {Shape} shape Shape of type Segment or Arc
  18.      */
  19.     constructor(shape) {
  20.         /**
  21.          * Shape of the edge: Segment or Arc
  22.          * @type {Segment|Arc}
  23.          */
  24.         this.shape = shape;
  25.         /**
  26.          * Pointer to the next edge in the face
  27.          * @type {Edge}
  28.          */
  29.         this.next = undefined;
  30.         /**
  31.          * Pointer to the previous edge in the face
  32.          * @type {Edge}
  33.          */
  34.         this.prev = undefined;
  35.         /**
  36.          * Pointer to the face containing this edge
  37.          * @type {Face}
  38.          */
  39.         this.face = undefined;
  40.         /**
  41.          * "Arc distance" from the face start
  42.          * @type {number}
  43.          */
  44.         this.arc_length = 0;
  45.         /**
  46.          * Start inclusion flag (inside/outside/boundary)
  47.          * @type {*}
  48.          */
  49.         this.bvStart = undefined;
  50.         /**
  51.          * End inclusion flag (inside/outside/boundary)
  52.          * @type {*}
  53.          */
  54.         this.bvEnd = undefined;
  55.         /**
  56.          * Edge inclusion flag (Flatten.INSIDE, Flatten.OUTSIDE, Flatten.BOUNDARY)
  57.          * @type {*}
  58.          */
  59.         this.bv = undefined;
  60.         /**
  61.          * Overlap flag for boundary edge (Flatten.OVERLAP_SAME/Flatten.OVERLAP_OPPOSITE)
  62.          * @type {*}
  63.          */
  64.         this.overlap = undefined;
  65.     }
  67.     /**
  68.      * Get edge start point
  69.      */
  70.     get start() {
  71.         return this.shape.start;
  72.     }
  74.     /**
  75.      * Get edge end point
  76.      */
  77.     get end() {
  78.         return this.shape.end;
  79.     }
  81.     /**
  82.      * Get edge length
  83.      */
  84.     get length() {
  85.         return this.shape.length;
  86.     }
  88.     /**
  89.      * Get bounding box of the edge
  90.      * @returns {Box}
  91.      */
  92.     get box() {
  93.         return this.shape.box;
  94.     }
  96.     get isSegment() {
  97.         return this.shape instanceof Flatten.Segment;
  98.     }
  100.     get isArc() {
  101.         return this.shape instanceof Flatten.Arc;
  102.     }
  104.     get isLine() {
  105.         return this.shape instanceof Flatten.Line;
  106.     }
  108.     get isRay() {
  109.         return this.shape instanceof Flatten.Ray
  110.     }
  112.     /**
  113.      * Get middle point of the edge
  114.      * @returns {Point}
  115.      */
  116.     middle() {
  117.         return this.shape.middle();
  118.     }
  120.     /**
  121.      * Get point at given length
  122.      * @param {number} length - The length along the edge
  123.      * @returns {Point}
  124.      */
  125.     pointAtLength(length) {
  126.         return this.shape.pointAtLength(length);
  127.     }
  129.     /**
  130.      * Returns true if point belongs to the edge, false otherwise
  131.      * @param {Point} pt - test point
  132.      */
  133.     contains(pt) {
  134.         return this.shape.contains(pt);
  135.     }
  137.     /**
  138.      * Set inclusion flag of the edge with respect to another polygon
  139.      * Inclusion flag is one of Flatten.INSIDE, Flatten.OUTSIDE, Flatten.BOUNDARY
  140.      * @param polygon
  141.      */
  142.     setInclusion(polygon) {
  143.         if (this.bv !== undefined) return this.bv;
  145.         if (this.shape instanceof Flatten.Line || this.shape instanceof Flatten.Ray) {
  146.             this.bv = Flatten.OUTSIDE;
  147.             return this.bv;
  148.         }
  150.         if (this.bvStart === undefined) {
  151.             this.bvStart = ray_shoot(polygon, this.start);
  152.         }
  153.         if (this.bvEnd === undefined) {
  154.             this.bvEnd = ray_shoot(polygon, this.end);
  155.         }
  156.         /* At least one end outside - the whole edge outside */
  157.         if (this.bvStart === Flatten.OUTSIDE || this.bvEnd == Flatten.OUTSIDE) {
  158.             this.bv = Flatten.OUTSIDE;
  159.         }
  160.         /* At least one end inside - the whole edge inside */
  161.         else if (this.bvStart === Flatten.INSIDE || this.bvEnd == Flatten.INSIDE) {
  162.             this.bv = Flatten.INSIDE;
  163.         }
  164.         /* Both are boundary - check the middle point */
  165.         else {
  166.             let bvMiddle = ray_shoot(polygon, this.middle());
  167.             // let boundary = this.middle().distanceTo(polygon)[0] < 10*Flatten.DP_TOL;
  168.             // let bvMiddle = boundary ? Flatten.BOUNDARY : ray_shoot(polygon, this.middle());
  169.             this.bv = bvMiddle;
  170.         }
  171.         return this.bv;
  172.     }
  174.     /**
  175.      * Set overlapping between two coincident boundary edges
  176.      * Overlapping flag is one of Flatten.OVERLAP_SAME or Flatten.OVERLAP_OPPOSITE
  177.      * @param edge
  178.      */
  179.     setOverlap(edge) {
  180.         let flag = undefined;
  181.         let shape1 = this.shape;
  182.         let shape2 = edge.shape;
  184.         if (shape1 instanceof Flatten.Segment && shape2 instanceof Flatten.Segment) {
  185.             if (shape1.start.equalTo(shape2.start) && shape1.end.equalTo(shape2.end)) {
  186.                 flag = Flatten.OVERLAP_SAME;
  187.             } else if (shape1.start.equalTo(shape2.end) && shape1.end.equalTo(shape2.start)) {
  188.                 flag = Flatten.OVERLAP_OPPOSITE;
  189.             }
  190.         } else if (shape1 instanceof Flatten.Arc && shape2 instanceof Flatten.Arc) {
  191.             if (shape1.start.equalTo(shape2.start) && shape1.end.equalTo(shape2.end) && /*shape1.counterClockwise === shape2.counterClockwise &&*/
  192.                 shape1.middle().equalTo(shape2.middle())) {
  193.                 flag = Flatten.OVERLAP_SAME;
  194.             } else if (shape1.start.equalTo(shape2.end) && shape1.end.equalTo(shape2.start) && /*shape1.counterClockwise !== shape2.counterClockwise &&*/
  195.                 shape1.middle().equalTo(shape2.middle())) {
  196.                 flag = Flatten.OVERLAP_OPPOSITE;
  197.             }
  198.         } else if (shape1 instanceof Flatten.Segment && shape2 instanceof Flatten.Arc ||
  199.             shape1 instanceof Flatten.Arc && shape2 instanceof Flatten.Segment) {
  200.             if (shape1.start.equalTo(shape2.start) && shape1.end.equalTo(shape2.end) && shape1.middle().equalTo(shape2.middle())) {
  201.                 flag = Flatten.OVERLAP_SAME;
  202.             } else if (shape1.start.equalTo(shape2.end) && shape1.end.equalTo(shape2.start) && shape1.middle().equalTo(shape2.middle())) {
  203.                 flag = Flatten.OVERLAP_OPPOSITE;
  204.             }
  205.         }
  207.         /* Do not update overlap flag if already set on previous chain */
  208.         if (this.overlap === undefined) this.overlap = flag;
  209.         if (edge.overlap === undefined) edge.overlap = flag;
  210.     }
  212.     svg() {
  213.         if (this.shape instanceof Flatten.Segment) {
  214.             return ` L${this.shape.end.x},${this.shape.end.y}`;
  215.         } else if (this.shape instanceof Flatten.Arc) {
  216.             let arc = this.shape;
  217.             let largeArcFlag;
  218.             let sweepFlag = arc.counterClockwise ? "1" : "0";
  220.             // Draw full circe arc as special case: split it into two half-circles
  221.             if (Flatten.Utils.EQ(arc.sweep, 2 * Math.PI)) {
  222.                 let sign = arc.counterClockwise ? 1 : -1;
  223.                 let halfArc1 = new Flatten.Arc(arc.pc, arc.r, arc.startAngle, arc.startAngle + sign * Math.PI, arc.counterClockwise);
  224.                 let halfArc2 = new Flatten.Arc(arc.pc, arc.r, arc.startAngle + sign * Math.PI, arc.endAngle, arc.counterClockwise);
  226.                 largeArcFlag = "0";
  228.                 return ` A${halfArc1.r},${halfArc1.r} 0 ${largeArcFlag},${sweepFlag} ${halfArc1.end.x},${halfArc1.end.y}
  229.                     A${halfArc2.r},${halfArc2.r} 0 ${largeArcFlag},${sweepFlag} ${halfArc2.end.x},${halfArc2.end.y}`
  230.             } else {
  231.                 largeArcFlag = arc.sweep <= Math.PI ? "0" : "1";
  233.                 return ` A${arc.r},${arc.r} 0 ${largeArcFlag},${sweepFlag} ${arc.end.x},${arc.end.y}`;
  234.             }
  235.         }
  236.     }
  238.     toJSON() {
  239.         return this.shape.toJSON();
  240.     }
  241. };
  243. Flatten.Edge = Edge;