08-27-周三_17-09-29

node_modules/dagre-d3-renderer/lib/intersect/index.js

@@ -0,0 +1,13 @@
+import node from './intersect-node'
+import circle from './intersect-circle'
+import ellipse from './intersect-ellipse'
+import polygon from './intersect-polygon'
+import rect from './intersect-rect'
+
+export default {
+  node,
+  circle,
+  ellipse,
+  polygon,
+  rect
+}

node_modules/dagre-d3-renderer/lib/intersect/intersect-circle.js

@@ -0,0 +1,7 @@
+import intersectEllipse from './intersect-ellipse'
+
+function intersectCircle (node, rx, point) {
+  return intersectEllipse(node, rx, rx, point)
+}
+
+export default intersectCircle

node_modules/dagre-d3-renderer/lib/intersect/intersect-ellipse.js

@@ -0,0 +1,24 @@
+function intersectEllipse (node, rx, ry, point) {
+  // Formulae from: http://mathworld.wolfram.com/Ellipse-LineIntersection.html
+
+  const cx = node.x
+  const cy = node.y
+
+  const px = cx - point.x
+  const py = cy - point.y
+
+  const det = Math.sqrt(rx * rx * py * py + ry * ry * px * px)
+
+  let dx = Math.abs(rx * ry * px / det)
+  if (point.x < cx) {
+    dx = -dx
+  }
+  let dy = Math.abs(rx * ry * py / det)
+  if (point.y < cy) {
+    dy = -dy
+  }
+
+  return {x: cx + dx, y: cy + dy}
+}
+
+export default intersectEllipse

node_modules/dagre-d3-renderer/lib/intersect/intersect-line.js

@@ -0,0 +1,65 @@
+/*
+ * Returns the point at which two lines, p and q, intersect or returns
+ * undefined if they do not intersect.
+ */
+function intersectLine (p1, p2, q1, q2) {
+  // Algorithm from J. Avro, (ed.) Graphics Gems, No 2, Morgan Kaufmann, 1994,
+  // p7 and p473.
+
+  // Compute a1, b1, c1, where line joining points 1 and 2 is F(x,y) = a1 x +
+  // b1 y + c1 = 0.
+  const a1 = p2.y - p1.y
+  const b1 = p1.x - p2.x
+  const c1 = (p2.x * p1.y) - (p1.x * p2.y)
+
+  // Compute r3 and r4.
+  const r3 = ((a1 * q1.x) + (b1 * q1.y) + c1)
+  const r4 = ((a1 * q2.x) + (b1 * q2.y) + c1)
+
+  // Check signs of r3 and r4. If both point 3 and point 4 lie on
+  // same side of line 1, the line segments do not intersect.
+  if ((r3 !== 0) && (r4 !== 0) && sameSign(r3, r4)) {
+    return /* DONT_INTERSECT */
+  }
+
+  // Compute a2, b2, c2 where line joining points 3 and 4 is G(x,y) = a2 x + b2 y + c2 = 0
+  const a2 = q2.y - q1.y
+  const b2 = q1.x - q2.x
+  const c2 = (q2.x * q1.y) - (q1.x * q2.y)
+
+  // Compute r1 and r2
+  const r1 = (a2 * p1.x) + (b2 * p1.y) + c2
+  const r2 = (a2 * p2.x) + (b2 * p2.y) + c2
+
+  // Check signs of r1 and r2. If both point 1 and point 2 lie
+  // on same side of second line segment, the line segments do
+  // not intersect.
+  if ((r1 !== 0) && (r2 !== 0) && (sameSign(r1, r2))) {
+    return /* DONT_INTERSECT */
+  }
+
+  // Line segments intersect: compute intersection point.
+  const denom = (a1 * b2) - (a2 * b1)
+  if (denom === 0) {
+    return /* COLLINEAR */
+  }
+
+  const offset = Math.abs(denom / 2)
+
+  // The denom/2 is to get rounding instead of truncating. It
+  // is added or subtracted to the numerator, depending upon the
+  // sign of the numerator.
+  let num = (b1 * c2) - (b2 * c1)
+  const x = (num < 0) ? ((num - offset) / denom) : ((num + offset) / denom)
+
+  num = (a2 * c1) - (a1 * c2)
+  const y = (num < 0) ? ((num - offset) / denom) : ((num + offset) / denom)
+
+  return { x, y }
+}
+
+function sameSign (r1, r2) {
+  return r1 * r2 > 0
+}
+
+export default intersectLine

node_modules/dagre-d3-renderer/lib/intersect/intersect-node.js

@@ -0,0 +1,5 @@
+function intersectNode (node, point) {
+  return node.intersect(point)
+}
+
+export default intersectNode

node_modules/dagre-d3-renderer/lib/intersect/intersect-polygon.js

@@ -0,0 +1,55 @@
+import intersectLine from './intersect-line'
+
+/*
+ * Returns the point ({x, y}) at which the point argument intersects with the
+ * node argument assuming that it has the shape specified by polygon.
+ */
+function intersectPolygon (node, polyPoints, point) {
+  const x1 = node.x
+  const y1 = node.y
+
+  const intersections = []
+
+  let minX = Number.POSITIVE_INFINITY
+  let minY = Number.POSITIVE_INFINITY
+  polyPoints.forEach(function (entry) {
+    minX = Math.min(minX, entry.x)
+    minY = Math.min(minY, entry.y)
+  })
+
+  const left = x1 - node.width / 2 - minX
+  const top = y1 - node.height / 2 - minY
+
+  for (let i = 0; i < polyPoints.length; i += 1) {
+    const p1 = polyPoints[i]
+    const p2 = polyPoints[i < polyPoints.length - 1 ? i + 1 : 0]
+    const intersect = intersectLine(node, point,
+      {x: left + p1.x, y: top + p1.y}, {x: left + p2.x, y: top + p2.y})
+    if (intersect) {
+      intersections.push(intersect)
+    }
+  }
+
+  if (!intersections.length) {
+    console.log('NO INTERSECTION FOUND, RETURN NODE CENTER', node)
+    return node
+  }
+
+  if (intersections.length > 1) {
+    // More intersections, find the one nearest to edge end point
+    intersections.sort(function (p, q) {
+      const pdx = p.x - point.x
+      const pdy = p.y - point.y
+      const distp = Math.sqrt(pdx * pdx + pdy * pdy)
+
+      const qdx = q.x - point.x
+      const qdy = q.y - point.y
+      const distq = Math.sqrt(qdx * qdx + qdy * qdy)
+
+      return (distp < distq) ? -1 : (distp === distq ? 0 : 1)
+    })
+  }
+  return intersections[0]
+}
+
+export default intersectPolygon

node_modules/dagre-d3-renderer/lib/intersect/intersect-rect.js

@@ -0,0 +1,32 @@
+function intersectRect (node, point) {
+  const x = node.x
+  const y = node.y
+
+  // Rectangle intersection algorithm from:
+  // http://math.stackexchange.com/questions/108113/find-edge-between-two-boxes
+  const dx = point.x - x
+  const dy = point.y - y
+  let w = node.width / 2
+  let h = node.height / 2
+
+  let sx, sy
+  if (Math.abs(dy) * w > Math.abs(dx) * h) {
+    // Intersection is top or bottom of rect.
+    if (dy < 0) {
+      h = -h
+    }
+    sx = dy === 0 ? 0 : h * dx / dy
+    sy = h
+  } else {
+    // Intersection is left or right of rect.
+    if (dx < 0) {
+      w = -w
+    }
+    sx = w
+    sy = dx === 0 ? 0 : w * dy / dx
+  }
+
+  return {x: x + sx, y: y + sy}
+}
+
+export default intersectRect