@eturnity/eturnity_maths 1.0.2

package/src/objects/Circle.js

@@ -0,0 +1,51 @@
+
+import {
+  getDistanceBetweenPoints,
+  translate2D,
+} from '../geometry'
+import { v4 as uuidv4 } from 'uuid'
+import {Point} from './Point'
+
+
+
+export class Circle {
+  constructor(center, radius, layer) {
+    this.id = uuidv4()
+    this.type = 'circle'
+    this.version = 0
+    this.center = center
+    this.radius = radius
+    this.layer = layer
+    this.visible = true
+  }
+
+  clone() {
+    const circle = new Circle(
+      new Point(this.point.x, this.point.y),
+      this.radius,
+      this.layer
+    )
+    circle.id = uuidv4()
+    return circle
+  }
+  getPxDistanceTo(point, canvasContext) {
+    const toCanvasRef = canvasContext.toCanvasRef
+    let pxCenter = toCanvasRef(this.center)
+    let pxRadius = this.radius / canvasContext.mmPerPx
+    return Math.abs(getDistanceBetweenPoints(point, pxCenter) - pxRadius)
+  }
+  getProjectedPoint(point) {
+    let distance = getDistanceBetweenPoints(point, this.center)
+    if (distance == 0) {
+      console.error("can't project center to cercle", this)
+      return null
+    }
+    let x = this.center.x + (point.x - this.center.x) * (this.radius / distance)
+    let y = this.center.y + (point.y - this.center.y) * (this.radius / distance)
+    let P = new Point(x, y, 0, this.layer)
+    return P
+  }
+  translate(vectorInMm) {
+    this.center = translate2D(this.center, vectorInMm)
+  }
+}

package/src/objects/Line.js

@@ -0,0 +1,110 @@
+
+import {
+  getDistanceBetweenPoints,
+  getPointOnLine,
+  isSamePoint3D,
+  translate2D,
+  midPoint,
+} from '../geometry'
+import { v4 as uuidv4 } from 'uuid'
+import {Point} from './Point'
+
+
+export class Line {
+  constructor(firstPoint, lastPoint, layer, infiniteLine = false) {
+    this.id = uuidv4()
+    this.version = 0
+    this.type = 'line'
+    if (firstPoint && lastPoint) {
+      this.outline = [firstPoint, lastPoint]
+    } else {
+      this.outline = []
+    }
+    this.layer = layer
+    this.visible = true
+    this.infiniteLine = infiniteLine
+  }
+  clone() {
+    const line = new Line()
+    this.outline.forEach((p) => {
+      line.outline.push(new Point(p.x, p.y, p.z))
+    })
+    line.id = uuidv4()
+    line.layer = this.layer
+    line.infiniteLine = this.infiniteLine
+    return line
+  }
+  pxLength(canvasContext) {
+    return (
+      getDistanceBetweenPoints(this.outline[0], this.outline[1]) /
+      canvasContext.mmPerPx
+    )
+  }
+  mmLength(canvasContext) {
+    return getDistanceBetweenPoints(this.outline[0], this.outline[1])
+  }
+  
+  getMidPoint() {
+    return midPoint(this.outline[0], this.outline[1])
+  }
+  getAngleDeg(){
+    const angle = Math.atan2(
+      this.outline[1].y - this.outline[0].y,
+      this.outline[0].x - this.outline[1].x
+    )
+    return (angle * 180) / Math.PI
+  }
+  getPxDistanceTo(point, canvasContext) {
+    const toCanvasRef = canvasContext.toCanvasRef
+    const toRealityRef = canvasContext.toRealityRef
+
+    if (this.outline.length < 2) {
+      console.error('line undefined')
+      return null
+    }
+    if (isSamePoint3D(this.outline[0], this.outline[1])) {
+      console.error('line undefined')
+      return null
+    }
+
+    let realityRefPoint = toRealityRef(point)
+    let P = getPointOnLine(realityRefPoint, this.outline[0], this.outline[1])
+    return getDistanceBetweenPoints(realityRefPoint, P) / canvasContext.mmPerPx
+  }
+  getProjectedPoint(point) {
+    if (this.outline.length == 0) {
+      return null
+    }
+    if (isSamePoint3D(this.outline[0], this.outline[1])) {
+      console.error("A == B Can't project point on Line")
+      return null
+    }
+    let P = getPointOnLine(point, this.outline[0], this.outline[1])
+    return P
+  }
+  translate(vectorInMm) {
+    this.outline = this.outline.map((point) => {
+      return translate2D(point, vectorInMm)
+    })
+  }
+  serialize() {
+    if (!this.belongsTo) {
+      this.belongsTo = []
+    }
+    const belongsTo = this.belongsTo.map((item) => {
+      return {
+        polygon: item.polygon.serialize(),
+        polygonId: item.polygonId,
+        index: item.index
+      }
+    })
+    const serializedEdge={
+      outline: [this.outline[0], this.outline[1]],
+      layer: this.layer,
+      type: this.type,
+      belongsTo: belongsTo || [],
+      itemType: this.itemType
+    }
+    return JSON.parse(JSON.stringify(serializedEdge))
+  }
+}

package/src/objects/Point.js

@@ -0,0 +1,57 @@
+
+import {
+  getDistanceBetweenPoints,
+  translate2D,
+} from '../geometry'
+import { v4 as uuidv4 } from 'uuid'
+
+export class Point {
+  constructor(x = 0, y = 0, z = 0, layer = null) {
+    this.id = uuidv4()
+    this.type = 'point'
+    this.version = 0
+    this.x = x
+    this.y = y
+    this.z = z
+    this.layer = layer
+    this.open = false
+    this.selected = false
+    this.visible = true
+    this.hasWarning = false
+  }  
+  getPxDistanceTo(point, canvasContext) {
+    const toRealityRef = canvasContext.toRealityRef
+    const realityPoint = toRealityRef(point)
+    return getDistanceBetweenPoints(realityPoint, this) / canvasContext.mmPerPx
+  }
+  getProjectedPoint(point) {
+    return this
+  }
+  translate(vectorInMm) {
+    let translatedPoint = translate2D({ x: this.x, y: this.y }, vectorInMm)
+    this.x = translatedPoint.x
+    this.y = translatedPoint.y
+  }
+  serialize() {
+    if (!this.belongsTo) {
+      this.belongsTo = []
+    }
+    const belongsTo = this.belongsTo.map((item) => {
+      return {
+        polygon: item.polygon.serialize(),
+        polygonId: item.polygonId,
+        index: item.index
+      }
+    })
+
+    return {
+      x: this.x,
+      y: this.y,
+      z: this.z,
+      layer: this.layer,
+      type: this.type,
+      belongsTo: belongsTo || [],
+      itemType: this.itemType
+    }
+  }
+}

package/src/objects/Polygon.js

@@ -0,0 +1,240 @@
+
+import {
+  translate2D,
+  getDegree
+} from '../geometry'
+import {
+  substractVector,
+  normalizeVector,
+  multiplyVector,
+  addVector
+} from '../vector'
+
+import { v4 as uuidv4 } from 'uuid'
+import {updateComputedGeometryPolygon} from './derivedState/updateComputedGeometryPolygon'
+
+export class Polygon {
+  constructor(outline = [], layer, isClosed = true) {
+    this.id = uuidv4()
+    this.name = ''
+    this.version = 0
+    this.type = 'polygon'
+    this.outline = JSON.parse(JSON.stringify(outline))
+    this.holes = []
+    this.layer = layer
+    this.isClosed = isClosed
+    this.highlight = false
+    this.visible = true
+    this.heightReference = 0
+    this.margins = {
+      isSameMargin: true,
+      sameMargin: 200,
+      innerOutline: [],
+      outterOutline: [],
+      distances: []
+    }
+    this.isLoading = false
+    if (this.layer == 'obstacle') {
+      this.isParallel = true
+    }
+  }
+
+  clone() {
+    const polygon = new Polygon()
+    this.outline.forEach((p) => {
+      polygon.outline.push({ ...p })
+    })
+    this.holes.forEach((h) => {
+      polygon.holes.push({ ...h })
+    })
+    polygon.id = uuidv4()
+    polygon.layer = this.layer
+    polygon.isClosed = this.isClosed
+    return polygon
+  }
+  getAngle(i){
+        const length=this.outline.length
+        const firstPoint = this.outline[(i-1+length) % length]
+        const secondPoint = this.outline[i % length]
+        const thirdPoint = this.outline[(i + 1) % length]
+        return getDegree(firstPoint, secondPoint, thirdPoint)
+  }
+  getDirectionSnapAngle(){
+    let angles=[]
+    for(let k=0;k<this.outline.length;k++){
+      let p_0=this.outline[k]
+      let p_1=this.outline[(k+1)%this.outline.length]
+      let angle = Math.atan2(
+        p_0.x - p_1.x,
+        p_0.y - p_1.y
+      )
+      angle*=180/Math.PI
+      angles.push(angle+90%360)
+      angles.push(angle+270%360)
+    }
+    return angles
+  }
+  getBounds(){
+    let bounds=this.outline.reduce((acc,cur)=>{
+      return{
+        xMin:Math.min(acc.xMin,cur.x),
+        yMin:Math.min(acc.yMin,cur.y),
+        xMax:Math.max(acc.xMax,cur.x),
+        yMax:Math.max(acc.yMax,cur.y),
+      }
+  },{xMin:Infinity,xMax:-Infinity,yMin:Infinity,yMax:-Infinity})
+    let center={
+      x:(bounds.xMax+bounds.xMin)/2,
+      y:(bounds.yMax+bounds.yMin)/2,
+    }
+    let radius=Math.hypot(bounds.xMax-bounds.xMin,bounds.yMax-bounds.yMin)/2
+    return {...bounds,radius,center}
+  }
+  get4pointsSquareAngle(i,canvasContext){
+    const length=this.outline.length
+    const A = this.outline[(i-1+length) % length]
+    const B = this.outline[i % length]
+    const C = this.outline[(i + 1) % length]
+    const toCanvasRef = canvasContext.toCanvasRef
+    //angle in B
+    const BD=multiplyVector(15*canvasContext.mmPerPx,normalizeVector(substractVector(A,B)))
+    const BE=multiplyVector(15*canvasContext.mmPerPx,normalizeVector(substractVector(C,B)))
+    const D=addVector(B,BD)
+    const E=addVector(B,BE)
+    const F=addVector(D,BE)
+
+    return [toCanvasRef(D),toCanvasRef(F),toCanvasRef(E)]
+  }
+  
+  translate(vectorInMm) {
+    this.version++
+    this.outline = this.outline.map((point) => {
+      return translate2D(point, vectorInMm)
+    })
+    updateComputedGeometryPolygon(this)
+  }
+  serialize() {
+    const baseSerialization = {
+      id: this.id,
+      version: this.version,
+      name: this.name,
+      type: this.type,
+      outline: this.outline.map(p=>{return {...p}}),
+      holes: this.holes.map((p) => p.id),
+      layer: this.layer,
+      highlight: this.highlight,
+      visible: this.visible,
+      margins: JSON.parse(JSON.stringify(this.margins))
+    }
+    const extraSerialization = {}
+    if (this.layer == 'roof') {
+      extraSerialization.moduleFields = this.moduleFields.map((m) => {
+        return {
+          id: m.id
+        }
+      })
+    } else if (this.layer == 'obstacle') {
+      extraSerialization.isParallel = this.isParallel
+      extraSerialization.height = this.height
+      extraSerialization.roofs = this.roofs.map((roof) => {
+        return { id: roof.id }
+      })
+    } else if (this.layer == 'moduleField') {
+      extraSerialization.data = {...this.data}
+      extraSerialization.roof = { id: this.roof.id }
+      extraSerialization.pvData = this.pvData?{...this.pvData}:null
+      extraSerialization.mountingData = this.mountingData?{...this.mountingData}:null
+      extraSerialization.panels = this.panels
+        ? this.panels.map((p) => {
+            return { id: p.id, index: p.index, outline: p.outline }
+          })
+        : []
+      extraSerialization.userDeactivatedPanels = this.userDeactivatedPanels
+        ? this.userDeactivatedPanels.map((p) => {
+            return { id: p.id, index: p.index, outline: p.outline }
+          })
+        : []
+    } else if (this.layer == 'panel') {
+      extraSerialization.index = this.index
+      extraSerialization.moduleField = { id: this.moduleField.id }
+    } else if (this.layer == 'user_deactivated_panel') {
+      extraSerialization.index = this.index
+      extraSerialization.moduleField = { id: this.moduleField.id }
+    }
+    return JSON.parse(JSON.stringify({ ...baseSerialization, ...extraSerialization }))
+  }
+  serializeForBEStorage() {
+    if (this.layer == 'roof') {
+      const margins_roof_mm = this.margins.isSameMargin
+        ? Array(this.outline.length).fill(this.margins.sameMargin)
+        : this.margins.distances
+      return {
+        roof_uuid: this.id,
+        version: this.version,
+        roof_outline: this.outline.map((v) => [v.x, v.y, v.z]),
+        roof_margins_mm: margins_roof_mm,
+        roof_slope_degrees: this.incline,
+        roof_orientation_degrees: this.direction,
+        roof_name: this.name
+      }
+    } else if (this.layer == 'obstacle') {
+      const margins_obstacle_mm = this.margins.isSameMargin
+        ? Array(this.outline.length).fill(this.margins.sameMargin)
+        : this.margins.distances
+      return {
+        obstacle_uuid: this.id,
+        version: this.version,
+        obstacle_outline: this.outline.map((v) => [v.x, v.y, v.z]),
+        obstacle_margins_mm: margins_obstacle_mm,
+        obstacle_height_above_ground_mm: this.height,
+        obstacle_slope_is_parallel_to_roof: this.isParallel
+      }
+    } else if (['moduleField', 'tmpModuleField'].includes(this.layer)) {
+      if (!this.panels) {
+        this.panels = []
+      }
+      if (!this.userDeactivatedPanels) {
+        this.userDeactivatedPanels = []
+      }
+      const modules = this.panels.map((p) => {
+        return {
+          index: p.index,
+          outline: p.outline.map((v) => [v.x, v.y, v.z])
+        }
+      })
+      const user_deactivated_modules = this.userDeactivatedPanels.map((p) => {
+        return {
+          index: p.index,
+          outline: p.outline.map((v) => [v.x, v.y, v.z])
+        }
+      })
+      return {
+        module_field_uuid: this.id,
+        roof_uuid: this.roof.id,
+        version: this.version,
+        module_field_outline: this.outline.map((v) => [v.x, v.y, v.z]),
+        col_spacing_mm: this.data.col_spacing_mm,
+        row_spacing_mm: this.data.row_spacing_mm,
+        offset_percent: this.data.offset_percent,
+        panel_orientation: this.data.panel_orientation,
+        panel_direction_degrees: this.data.panel_direction_degrees,
+        component_id_pv_module: this.data.component_id_pv_module,
+        component_id_mounting_system: this.data.component_id_mounting_system,
+        modules: modules,
+        module_tilt_degrees: this.data.module_tilt_degrees,
+        user_deactivated_modules: user_deactivated_modules,
+        base_line_index: this.data.base_line_index,
+        justify_percent: this.data.justify_percent
+      }
+    } else if (['panel', 'user_deactivated_panel'].includes(this.layer)) {
+      return {
+        id: this.id,
+        index: this.index,
+        outline: this.outline.map((v) => [v.x, v.y, v.z]),
+        moduleField: {
+          id: this.moduleField.id
+        }
+      }
+    }
+  }
+}

package/src/objects/derivedState/AddMargin.js

@@ -0,0 +1,109 @@
+import {
+    multiplyVector
+  } from '../../vector'
+import {getMarginPoint} from '../../geometry'
+  //update and calculate margins for all polygon
+  export function updateMarginsOutline(state){
+    state.polygons.forEach(polygon=>{
+      polygon=updateMarginOutlinePolygon(polygon)
+    })
+    return state
+  }  
+
+  export function updateMarginOutlinePolygon(polygon){
+    if(polygon.layer=="roof"){
+      return getRoofMarginOutline(polygon)
+    }else if(polygon.layer=='obstacle'){
+      return getObstacleMarginOutline(polygon)
+    }else{
+      return polygon
+    }
+  }
+  //FYI: polygon.margins={
+    //  distances:array[#point] //primitives
+    //  isSameMargin:Boolean //primitives
+    //  sameMargin:Number //primitives
+    //  outterOutline:array[Vector3D] //derived (for roof this is the wall)
+    //  innerOutline:array[Vector3D] //derived (for obstacle this is the wall)
+    //  }
+    
+export function getRoofMarginOutline(polygon){
+    let clockwiseNormalVector=polygon.normalVector
+    if(!polygon.isClockwise){
+      clockwiseNormalVector=multiplyVector(-1,clockwiseNormalVector)
+    }
+    //outterOutline is the outline close to the wall
+    polygon.margins.outterOutline=polygon.flatOutline
+    polygon.margins.innerOutline=[]
+    const length=polygon.outline.length
+    for(let index=0;index<length;index++){
+      const B=polygon.margins.outterOutline[index]
+      //A,B,C three consecutive points on the polygon.
+      //n is a vector in the plan normal to AB of length margin[A] directed towards the inside
+      //m is a vector in the plan normal to BC of length margin[B] directed towards the inside
+      //K is the margin outline linked with B
+      const A=polygon.margins.outterOutline[(index-1+length)%length]
+      const C=polygon.margins.outterOutline[(index+1)%length]
+      //filling the margins values if not initiated.
+      let marginA
+      let marginB
+      if(polygon.margins.isSameMargin){
+        marginA=polygon.margins.sameMargin
+        marginB=polygon.margins.sameMargin
+        polygon.margins.distances[index]=polygon.margins.sameMargin
+      }else{
+        if(!polygon.margins.distances[(index-1+length)%length]===undefined){
+          polygon.margins.distances[(index-1+length)%length]=polygon.margins.sameMargin
+        }
+        if(!polygon.margins.distances[index]===undefined){
+          polygon.margins.distances[index]=polygon.margins.sameMargin
+        }
+        marginA=polygon.margins.distances[(index-1+length)%length]
+        marginB=polygon.margins.distances[index]
+      }
+      let K=getMarginPoint(A,B,C,marginA,marginB,clockwiseNormalVector)
+      polygon.margins.innerOutline.push(K)
+    }
+    return polygon
+  }
+
+
+export function getObstacleMarginOutline(polygon){
+  let clockwiseNormalVector=polygon.normalVector
+  if(polygon.isClockwise){
+    clockwiseNormalVector=multiplyVector(-1,clockwiseNormalVector)
+  }
+  //outterOutline is the outline close to the wall
+  polygon.margins.innerOutline=polygon.flatOutline
+  polygon.margins.outterOutline=[]
+  const length=polygon.margins.innerOutline.length
+  for(let index=0;index<length;index++){
+    const B=polygon.margins.innerOutline[index]
+    //A,B,C three consecutive points on the polygon.
+    //n is a vector in the plan normal to AB of length margin[A] directed towards the inside
+    //m is a vector in the plan normal to BC of length margin[B] directed towards the inside
+    //K is the margin outline linked with B
+    const A=polygon.margins.innerOutline[(index-1+length)%length]
+    const C=polygon.margins.innerOutline[(index+1)%length]
+    //filling the margins values if not initiated.
+    let marginA
+    let marginB
+    if(polygon.margins.isSameMargin){
+      marginA=polygon.margins.sameMargin
+      marginB=polygon.margins.sameMargin
+      polygon.margins.distances[index]=polygon.margins.sameMargin
+    }else{
+      if(polygon.margins.distances[(index-1+length)%length]===undefined){
+        polygon.margins.distances[(index-1+length)%length]=polygon.margins.sameMargin
+      }
+      if(polygon.margins.distances[index]===undefined){
+        polygon.margins.distances[index]=polygon.margins.sameMargin
+      }
+      marginA=polygon.margins.distances[(index-1+length)%length]
+      marginB=polygon.margins.distances[index]
+    }
+    let K=getMarginPoint(A,B,C,marginA,marginB,clockwiseNormalVector)
+    polygon.margins.outterOutline.push(K)
+  }
+  return polygon
+  }

package/src/objects/derivedState/UpdateRoofModuleFieldRelations.js

@@ -0,0 +1,119 @@
+import {
+  isInsidePolygon,
+  verticalProjectionOnPlane,
+} from '../../geometry'
+//this function just update the "roof" and "moduleField(s)" properties of panels,moduleFields and roofs
+export function UpdateRoofModuleFieldRelations(state) {
+  const roofPolygons = state.polygons.filter((poly) => poly.layer == 'roof')
+  const moduleFieldPolygons = state.polygons.filter(
+    (poly) => poly.layer == 'moduleField'
+    )
+  const panelPolygons = state.polygons.filter((poly) =>
+    ['panel', 'user_deactivated_panel'].includes(poly.layer)
+  )
+  //let's remove all moduleFields from roofs
+  roofPolygons.forEach((roofPolygon) => {
+    //breaking circular reference for memory management
+    for (let k in roofPolygon.moduleFields) {
+      roofPolygon.moduleFields[k] = null
+    }
+    roofPolygon.moduleFields = []
+  })
+  moduleFieldPolygons.forEach((moduleFieldPolygon) => {
+    moduleFieldPolygon.roof = null
+  })
+  panelPolygons.forEach((panelPolygon) => {
+    panelPolygon.roof = null
+  })
+
+  for (let k in moduleFieldPolygons) {
+    const moduleField = moduleFieldPolygons[k]
+    //check if everypoint is in the same roof and if they are not too far from the flat surface.(at least above)
+    const roofPolygonCandidates = roofPolygons.filter((roof) =>
+      {
+        return moduleField.outline.every(p=>isInsidePolygon(p, roof.margins.innerOutline))
+      }
+    )
+    //roofs on roof can lead to multiple roof under a point. moduleField is in the smallest
+    let smallestRoof = null
+    for (let roof of roofPolygonCandidates) {
+      if (!smallestRoof || smallestRoof.area > roof.area) {
+        smallestRoof = roof
+      }
+    }
+    let roofPolygon = smallestRoof
+
+    if (!roofPolygon) {
+      //no roof found under first node of moduleField => moduleField will be deleted
+      continue
+    }
+    let moduleFieldBelongsToRoof = true
+    moduleField.outline.forEach((p) => {
+      const distanceToFlatRoof =
+        p.z -
+        verticalProjectionOnPlane(
+          p,
+          roofPolygon.normalVector,
+          roofPolygon.flatOutline[0]
+        ).z
+      if (
+        !isInsidePolygon(p, roofPolygon.margins.innerOutline) ||
+        distanceToFlatRoof < -1 ||
+        distanceToFlatRoof > 50
+      ) {
+        // one point from moduleField is not inside the roof or too far from it's flat surface => moduleField will be deleted
+        moduleFieldBelongsToRoof = false
+      }
+    })
+    if (moduleFieldBelongsToRoof) {
+      roofPolygon.moduleFields.push(moduleField)
+      moduleField.roof = roofPolygon
+      moduleField.panels.forEach((panel) => (panel.roof = roofPolygon))
+      panelPolygons.forEach((p) => {
+        if (p.moduleField.id == moduleField.id) {
+          p.roof = roofPolygon
+        }
+      })
+    }
+  }
+
+  let newPolygons = state.polygons.map((p) => {
+    if (
+      !['roof', 'moduleField', 'panel', 'user_deactivated_panel'].includes(
+        p.layer
+      )
+    )
+      return p
+    if (p.layer == 'roof') return roofPolygons.find((r) => r.id == p.id)
+    if (p.layer == 'moduleField')
+      return moduleFieldPolygons.find((mf) => mf.id == p.id)
+    if (['panel', 'user_deactivated_panel'].includes(p.layer))
+      return panelPolygons.find((panel) => panel.id == p.id)
+  })
+  state = { ...state, polygons: newPolygons }
+  state = removeModuleFieldAndPanelsOnNoOrMultipleRoofs(state)
+  return state
+}
+
+export function removeModuleFieldAndPanelsOnNoOrMultipleRoofs(state) {
+  const remainingPolygons = state.polygons.filter((polygon) =>
+    ['roof', 'obstacle'].includes(polygon.layer)
+  )
+  const remainingModuleFields = state.polygons.filter(
+    (polygon) => polygon.layer == 'moduleField' && !!polygon.roof
+  )
+  const remainingPanels = state.polygons.filter(
+    (polygon) => polygon.layer == 'panel' && !!polygon.roof
+  )
+  const remainingUserDeactivatedPanels = state.polygons.filter(
+    (polygon) => polygon.layer == 'user_deactivated_panel' && !!polygon.roof
+  )
+  
+  state.polygons = [
+    ...remainingPolygons,
+    ...remainingModuleFields,
+    ...remainingPanels,
+    ...remainingUserDeactivatedPanels
+  ]
+  return state
+}