@eturnity/eturnity_maths 1.0.2

package/src/splitMergePolygons.js

@@ -0,0 +1,553 @@
+import { PlanarFaceTree } from 'planar-face-discovery'
+import {
+  substractVector,
+  addVector,
+  multiplyVector,
+  dotProduct,
+  vectorLength
+} from './vector'
+import {
+  isAlmostSamePoint2D,
+  getPointOnLine,
+  getDistanceBetweenPoints,
+  isPointBetweenSegment,
+  isInsidePolygon,
+  verticalProjectionOnPlane,
+  polygonsHasSame2DOutline
+} from './geometry'
+import { groupBy } from 'lodash'
+import { Polygon } from './objects/Polygon'
+import { defaultBaseHeight, mmTolerance } from './config'
+
+export function mergePolygons(polygonIdsToMerge, edges, layer) {
+  const outsideEdge = edges.filter((e) => e.belongsTo.length == 1)
+  const insideEdge = edges.filter((e) => e.belongsTo.length == 2)
+  const insideEdgeToKeep = insideEdge.filter((e) => {
+    return (
+      !polygonIdsToMerge.includes(e.belongsTo[0].polygonId) ||
+      !polygonIdsToMerge.includes(e.belongsTo[1].polygonId)
+    )
+  })
+  const newEdges = [...outsideEdge, ...insideEdgeToKeep]
+  //nodeList:
+  let dirtyNodeList = []
+  newEdges.forEach((edge) => {
+    dirtyNodeList.push(edge.outline[0])
+    dirtyNodeList.push(edge.outline[1])
+  })
+  const nodeList = []
+  for (let node of dirtyNodeList) {
+    const nodeFound = nodeList.find((n) => {
+      return n && isAlmostSamePoint2D(n, node, mmTolerance)
+    })
+    if (!nodeFound) {
+      nodeList.push(node)
+    }
+  }
+  //edgeList (just in term of indexes)
+  const edgeList = getEdgeListSimple(nodeList, newEdges)
+  const outlineList = getOutlineList(nodeList, edgeList)
+
+  const polygonList = []
+  for (let k = 0; k < outlineList.length; k++) {
+    polygonList.push(new Polygon(outlineList[k], layer))
+  }
+  return polygonList
+}
+
+export function splitPolygons(
+  constructionPolyline,
+  edges,
+  roofs,
+  isClosedContructionPolyline
+) {
+  //if(isClosedContructionPolyline){
+  constructionPolyline.outline.forEach((p) => {
+    let supportRoof = roofs.find((roof) => isInsidePolygon(p, roof.outline))
+    if (supportRoof) {
+      p.z = verticalProjectionOnPlane(
+        p,
+        supportRoof.normalVector,
+        supportRoof.flatOutline[0]
+      ).z
+    } else {
+      p.z = defaultBaseHeight
+    }
+  })
+  
+  isClosedContructionPolyline = isClosedContructionPolyline ? 1 : 0
+  //1. find intersection between constructionPolyline and edges
+  const roofEdge = edges.filter((e) => e.layer == 'roof')
+  let intersections = getIntersections(constructionPolyline, roofEdge,isClosedContructionPolyline)
+  //2. gather all nodes+intersection in a list[[x,y],[x,y]]
+  const nodeList = getNodeList(intersections, roofEdge, constructionPolyline)
+  //3. generate all edges not cut, those cut and those from construction polyline
+
+  const edgeList = getEdgeList(
+    nodeList,
+    intersections,
+    roofEdge,
+    constructionPolyline,
+    isClosedContructionPolyline
+  )
+  //4. run planar-face-discovery to get all cycles and rebuild our polygons
+  const outlineList = getOutlineList(nodeList, edgeList, roofs)
+  const polygonList = []
+  for (let k = 0; k < outlineList.length; k++) {
+    polygonList.push(new Polygon(outlineList[k], 'roof'))
+  }
+  return polygonList
+}
+
+export function getIntersections(constructionPolyline, edges, isClosedContructionPolyline=0) {
+  let intersections = []
+  const polylineLength = constructionPolyline.outline.length
+  for (let k = 0; k < polylineLength - 1 + isClosedContructionPolyline; k++) {
+    const segStart = constructionPolyline.outline[k]
+    const segEnd = constructionPolyline.outline[(k + 1) % polylineLength]
+    for (let j = 0; j < edges.length; j++) {
+      const edgeStart = edges[j].outline[0]
+      const edgeEnd = edges[j].outline[1]
+      const inters = getIntersectionSegmentWithParams(segStart, segEnd, edgeStart, edgeEnd)
+      inters.forEach((inter) => {
+        intersections.push({
+          polylineIndex: k,
+          edgeIndex: j,
+          polylineParam: inter.param1,
+          edgeParam: inter.param2,
+          point: inter.point
+        })
+      })
+    }
+  }
+  intersections = intersections.filter(
+    (inter) =>
+      inter.polylineParam >= 0 &&
+      inter.polylineParam <= 1 &&
+      inter.edgeParam >= 0 &&
+      inter.edgeParam <= 1
+  )
+  return intersections
+}
+
+export function getNodeList(intersections, edges, constructionPolyline) {
+  let nodeList = []
+  edges.forEach((edge) => {
+    nodeList.push(edge.outline[0])
+    nodeList.push(edge.outline[1])
+  })
+
+  constructionPolyline.outline.forEach((p) => {
+    const node = nodeList.find((n) => {
+      return isAlmostSamePoint2D(p, n, mmTolerance)
+    })
+    if (!node) {
+      nodeList.push(p)
+    }
+  })
+  const polylineLength = constructionPolyline.outline.length
+  const polylineStart = nodeList.find((p) => {
+    return isAlmostSamePoint2D(p, constructionPolyline.outline[0], mmTolerance)
+  })
+  const polylineEnd = nodeList.find((p) =>
+    isAlmostSamePoint2D(
+      p,
+      constructionPolyline.outline[polylineLength - 1],
+      mmTolerance
+    )
+  )
+  constructionPolyline.outline.forEach((p, index) => {
+    if (p.z == defaultBaseHeight || !p.z) {
+      p.z =
+        polylineStart.z +
+        (index / (polylineLength - 1)) * (polylineEnd.z - polylineStart.z)
+    }
+    nodeList.push(p)
+  })
+  intersections.forEach((inter) => {
+    nodeList.push(inter.point)
+  })
+  const nodeListClean = []
+  for (let k = 0; k < nodeList.length; k++) {
+    const node = nodeList[k]
+    const newNode = nodeListClean.find((n) => {
+      return n && isAlmostSamePoint2D(n, node, mmTolerance)
+    })
+    if (!newNode) {
+      nodeListClean.push(node)
+    }
+  }
+  return nodeListClean
+}
+
+function getEdgeListSimple(nodeList, edges) {
+  //create a list of edge in term of node Index from nodeList
+  const edgeList = []
+  for (let index in edges) {
+    const node_0_index = nodeList.findIndex((n) =>
+      isAlmostSamePoint2D(edges[index].outline[0], n, mmTolerance)
+    )
+    const node_1_index = nodeList.findIndex((n) =>
+      isAlmostSamePoint2D(edges[index].outline[1], n, mmTolerance)
+    )
+    edgeList.push([node_0_index, node_1_index])
+  }
+
+  const cleanEdgeList = []
+  edgeList.forEach((edge) => {
+    const cleanEdge = cleanEdgeList.find(
+      (cleanEdge) => edge[0] == cleanEdge[0] && edge[1] == cleanEdge[1]
+    )
+    if (!cleanEdge && edge[0] != edge[1]) {
+      cleanEdgeList.push(edge)
+    }
+  })
+  return cleanEdgeList
+}
+
+export function getEdgeList(
+  nodeList,
+  intersections,
+  edges,
+  constructionPolyline,
+  isClosedContructionPolyline
+) {
+  //to find all edges, edges untouched and untouched construction line are first added
+  //then we sort intersection according to their ratio within an edge to add cut edges,
+  //same operation for construction line.
+  const edgeList = []
+  let intersectionByEdge = groupBy(intersections, (inter) => {
+    return inter.edgeIndex
+  })
+  let intersectionByPolyline = groupBy(intersections, (inter) => {
+    return inter.polylineIndex
+  })
+  intersectionByEdge = Object.values(intersectionByEdge)
+  intersectionByPolyline = Object.values(intersectionByPolyline)
+  intersectionByEdge.forEach((intersections) =>
+    intersections.sort((a, b) => {
+      return a.edgeParam - b.edgeParam
+    })
+  )
+  intersectionByPolyline.forEach((intersections) =>
+    intersections.sort((a, b) => {
+      return a.polylineParam - b.polylineParam
+    })
+  )
+  //get used and untouched edge from polyline and edges
+
+  const polylineUsedIndexes = intersectionByPolyline.map(
+    (i) => i[0].polylineIndex
+  )
+  const edgeUsedIndexes = intersectionByEdge.map((i) => i[0].edgeIndex)
+
+  const untouchedEdgeIndexes = [...Array(edges.length).keys()].filter(
+    (k) => !edgeUsedIndexes.includes(k)
+  )
+
+  const untouchedPolylineIndexes = [
+    ...Array(
+      constructionPolyline.outline.length - 1 + isClosedContructionPolyline
+    ).keys()
+  ].filter((k) => !polylineUsedIndexes.includes(k))
+
+  //get untouchEdge edge
+  untouchedEdgeIndexes.forEach((index) => {
+    const node_0_index = nodeList.findIndex((n) =>
+      isAlmostSamePoint2D(edges[index].outline[0], n, mmTolerance)
+    )
+    const node_1_index = nodeList.findIndex((n) =>
+      isAlmostSamePoint2D(edges[index].outline[1], n, mmTolerance)
+    )
+    edgeList.push([node_0_index, node_1_index])
+  })
+  //get untouchPolyline edge
+  untouchedPolylineIndexes.forEach((index) => {
+    const length = constructionPolyline.outline.length
+    const node_0_index = nodeList.findIndex((n) =>
+      isAlmostSamePoint2D(constructionPolyline.outline[index], n, mmTolerance)
+    )
+    const node_1_index = nodeList.findIndex((n) =>
+      isAlmostSamePoint2D(
+        constructionPolyline.outline[(index + 1) % length],
+        n,
+        mmTolerance
+      )
+    )
+    edgeList.push([node_0_index, node_1_index])
+  })
+  //get touchedEdge edge
+  intersectionByEdge.forEach((intersectionOnEdge) => {
+    const length = intersectionOnEdge.length
+    const node_0_index_start = nodeList.findIndex((n) =>
+      isAlmostSamePoint2D(
+        edges[intersectionOnEdge[0].edgeIndex].outline[0],
+        n,
+        mmTolerance
+      )
+    )
+    const node_1_index_start = nodeList.findIndex((n) =>
+      isAlmostSamePoint2D(intersectionOnEdge[0].point, n, mmTolerance)
+    )
+    edgeList.push([node_0_index_start, node_1_index_start])
+
+    for (let k = 0; k < length - 1; k++) {
+      const node_0_index = nodeList.findIndex((n) =>
+        isAlmostSamePoint2D(intersectionOnEdge[k].point, n, mmTolerance)
+      )
+      const node_1_index = nodeList.findIndex((n) =>
+        isAlmostSamePoint2D(
+          intersectionOnEdge[(k + 1) % length].point,
+          n,
+          mmTolerance
+        )
+      )
+      edgeList.push([node_0_index, node_1_index])
+    }
+
+    const node_0_index_end = nodeList.findIndex((n) =>
+      isAlmostSamePoint2D(intersectionOnEdge[length - 1].point, n, mmTolerance)
+    )
+    const node_1_index_end = nodeList.findIndex((n) =>
+      isAlmostSamePoint2D(
+        edges[intersectionOnEdge[0].edgeIndex].outline[1],
+        n,
+        mmTolerance
+      )
+    )
+    edgeList.push([node_0_index_end, node_1_index_end])
+  })
+  //get touchedPolyline edge
+  intersectionByPolyline.forEach((intersectionOnPolyline) => {
+    const length = intersectionOnPolyline.length
+    const lengthPolyline = constructionPolyline.outline.length
+    const node_0_index_start = nodeList.findIndex((n) =>
+      isAlmostSamePoint2D(
+        constructionPolyline.outline[intersectionOnPolyline[0].polylineIndex],
+        n,
+        mmTolerance
+      )
+    )
+    const node_1_index_start = nodeList.findIndex((n) =>
+      isAlmostSamePoint2D(intersectionOnPolyline[0].point, n, mmTolerance)
+    )
+    edgeList.push([node_0_index_start, node_1_index_start])
+
+    for (let k = 0; k < length - 1; k++) {
+      const node_0_index = nodeList.findIndex((n) =>
+        isAlmostSamePoint2D(intersectionOnPolyline[k].point, n, mmTolerance)
+      )
+      const node_1_index = nodeList.findIndex((n) =>
+        isAlmostSamePoint2D(
+          intersectionOnPolyline[(k + 1) % length].point,
+          n,
+          mmTolerance
+        )
+      )
+      edgeList.push([node_0_index, node_1_index])
+    }
+
+    const node_0_index_end = nodeList.findIndex((n) =>
+      isAlmostSamePoint2D(
+        intersectionOnPolyline[length - 1].point,
+        n,
+        mmTolerance
+      )
+    )
+    const node_1_index_end = nodeList.findIndex((n) =>
+      isAlmostSamePoint2D(
+        constructionPolyline.outline[
+          (intersectionOnPolyline[0].polylineIndex + 1)%lengthPolyline
+        ],
+        n,
+        mmTolerance
+      )
+    )
+    edgeList.push([node_0_index_end, node_1_index_end])
+  })
+
+  const cleanEdgeList = []
+  edgeList.forEach((edge) => {
+    const cleanEdge = cleanEdgeList.find(
+      (cleanEdge) => edge[0] == cleanEdge[0] && edge[1] == cleanEdge[1]
+    )
+    if (!cleanEdge && edge[0] != edge[1]) {
+      cleanEdgeList.push(edge)
+    }
+  })
+
+  return cleanEdgeList
+}
+function forestRecursion(cycleTree) {
+  if (cycleTree.children.length > 0) {
+    let cycles = cycleTree.children.reduce(function (done, curr) {
+      done.push(...forestRecursion(curr))
+      return done
+    }, [])
+    if (cycleTree.cycle.length) {
+      //cycles.push(cycleTree.cycle)
+    }
+    return cycles
+  } else {
+    return [cycleTree.cycle]
+  }
+}
+export function getOutlineList(nodeList, edgeList, roofs = []) {
+  const mode = 'outline'
+  const minX = Math.min(...nodeList.map((n) => n.x))
+  const minY = Math.min(...nodeList.map((n) => n.y))
+  const nodes = nodeList.map((n) => [n.x - minX, n.y - minY])
+  const solver = new PlanarFaceTree()
+  const result = solver.discover(nodes, edgeList)
+  const cycles = []
+  if (mode == 'forest') {
+    return result.forest
+  }
+  for (let k in result.forest) {
+    const cycleTree = result.forest[k]
+    let cycleArray = forestRecursion(cycleTree)
+    cycles.push(...cycleArray)
+  }
+
+  let outlines = cycles
+    .map((cycle) => {
+      return cycle.map((index) => {
+        return {
+          x: nodeList[index].x,
+          y: nodeList[index].y,
+          z: nodeList[index].z
+        }
+      })
+    })
+    .filter((outline) => outline.length > 0)
+  outlines.forEach((outline) => outline.pop())
+
+  //check for existing roofs
+  outlines = outlines.map((outline) => {
+    let roof = roofs.find((roof) =>
+      polygonsHasSame2DOutline(outline, roof.outline)
+    )
+    if (roof) {
+      outline = JSON.parse(JSON.stringify(roof.outline))
+    }
+    return outline
+  })
+  return outlines
+}
+
+function getIntersectionSegmentWithParams(A, B, C, D) {
+  const u = substractVector(B, A)
+  const v = substractVector(D, C)
+  let h, j, M, P
+  //A+hu=C+jv
+  const u_normal = { x: -u.y, y: u.x, z: 0 }
+  const v_normal = { x: -v.y, y: v.x, z: 0 }
+  const denom_u = dotProduct(v, u_normal)
+  const denom_v = dotProduct(u, v_normal)
+  const AB = vectorLength(u)
+  const CD = vectorLength(v)
+  if (AB < mmTolerance && CD < mmTolerance) {
+    if (getDistanceBetweenPoints(A, C) < mmTolerance * 2) {
+      return [
+        {
+          point: A,
+          param1: 0.5,
+          param2: 0.5
+        }
+      ]
+    }
+  } else if (AB == 0) {
+    //let's check if CD go through A
+    P = getPointOnLine(A, C, D)
+    if (getDistanceBetweenPoints(P, A) < mmTolerance) {
+      j = vectorLength(substractVector(C, A)) / CD
+      return [
+        {
+          point: A,
+          param1: 0,
+          param2: j
+        }
+      ]
+    }
+  } else if (CD == 0) {
+    //let's check if AB go through C
+    M = getPointOnLine(C, A, B)
+    if (getDistanceBetweenPoints(M, C) < mmTolerance) {
+      h = vectorLength(substractVector(C, A)) / AB
+      return [
+        {
+          point: C,
+          param1: h,
+          param2: 0
+        }
+      ]
+    }
+  }
+  if (Math.abs(denom_u) / (AB * CD) < 0.01) {
+    //u,v parallel
+    //let's check if they are close
+    //distance from A to CD
+    P = getPointOnLine(A, C, D)
+    M = getPointOnLine(B, C, D)
+    if (
+      getDistanceBetweenPoints(A, P) < mmTolerance ||
+      getDistanceBetweenPoints(B, M) < mmTolerance
+    ) {
+      //AB and CD are colinear
+      //let's find which point are in the middle
+      const intersections = []
+      //A between CD?
+      if (isPointBetweenSegment(A, C, D)) {
+        j = getDistanceBetweenPoints(A, C) / CD
+        intersections.push({
+          point: A,
+          param1: 0,
+          param2: j
+        })
+      }
+      //B between CD
+      if (isPointBetweenSegment(B, C, D)) {
+        j = getDistanceBetweenPoints(B, C) / CD
+        intersections.push({
+          point: B,
+          param1: 1,
+          param2: j
+        })
+      }
+      //C between AB
+      if (isPointBetweenSegment(C, A, B)) {
+        h = getDistanceBetweenPoints(A, C) / AB
+        intersections.push({
+          point: C,
+          param1: h,
+          param2: 0
+        })
+      }
+      //D between AB
+      if (isPointBetweenSegment(D, A, B)) {
+        h = getDistanceBetweenPoints(A, D) / AB
+        intersections.push({
+          point: D,
+          param1: h,
+          param2: 1
+        })
+      }
+      return intersections
+    }
+    return []
+  }
+  j = dotProduct(substractVector(A, C), u_normal) / denom_u
+  h = dotProduct(substractVector(C, A), v_normal) / denom_v
+  if (j < 0 || j > 1 || h < 0 || h > 1) {
+    return []
+  }
+  const point = addVector(A, multiplyVector(h, u))
+  point.z = C.z + j * (D.z - C.z)
+  return [
+    {
+      point,
+      param1: h,
+      param2: j
+    }
+  ]
+}

package/src/test/maths.test.js

@@ -0,0 +1,10 @@
+import { deltaLatLngToDistance,distanceToDeltaLatLng } from "../index"
+
+test('deltaLatLngToDistance is inverse of distanceToDeltaLatLng x', () => {
+    let {lat,lng}=distanceToDeltaLatLng(1000, 2000,45)
+    expect(deltaLatLngToDistance(lat,lng,45).x).toBe(1000);
+  });
+test('deltaLatLngToDistance is inverse of distanceToDeltaLatLng y', () => {
+    let {lat,lng}=distanceToDeltaLatLng(1000, 2000,45)
+    expect(deltaLatLngToDistance(lat,lng,45).y).toBe(2000);
+  });

package/src/vector.js

@@ -0,0 +1,56 @@
+export function addVector(u, v) {
+    const result = {}
+    result.x = u.x + v.x
+    result.y = u.y + v.y
+    result.z = u.z + v.z
+    return result
+  }
+  
+  export function substractVector(u, v) {
+    const result = {}
+    result.x = u.x - v.x
+    result.y = u.y - v.y
+    result.z = u.z - v.z
+    return result
+  }
+  
+  export function multiplyVector(lambda, u) {
+    const result = {}
+    result.x = u.x * lambda
+    result.y = u.y * lambda
+    result.z = u.z * lambda
+    return result
+  }
+  export function dotProduct(u, v) {
+    const result = u.x * v.x + u.y * v.y + u.z * v.z
+    return result
+  }
+  export function crossProduct(u, v) {
+    const result = {}
+    result.x = u.y * v.z - u.z * v.y
+    result.y = u.z * v.x - u.x * v.z
+    result.z = u.x * v.y - u.y * v.x
+    return result
+  }
+  export function meanVector(listVector) {
+    let meanPoint = {}
+    let sumPoint = { x: 0, y: 0, z: 0 }
+    listVector.forEach((p) => {
+      sumPoint = addVector(sumPoint, p)
+    })
+    meanPoint = multiplyVector(1 / listVector.length, sumPoint)
+    return meanPoint
+  }
+  export function vectorLength(v) {
+    return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z)
+  }
+  export function vectorLength2D(v) {
+    return Math.sqrt(v.x * v.x + v.y * v.y)
+  }
+  export function normalizeVector(v) {
+    let length = vectorLength(v)
+    if (length == 0) {
+      return v
+    }
+    return multiplyVector(1 / length, v)
+  }

package/webpack.config.js

@@ -0,0 +1,11 @@
+const path = require('path')
+
+module.exports = {
+  configureWebpack: {
+    resolve: {
+      alias: {
+        '@': path.resolve(__dirname, '/')
+      }
+    }
+  }
+}