@eturnity/eturnity_maths 7.20.0 → 7.24.0

package/src/objects/Polygon.js

@@ -1,252 +1,333 @@
-
-import {
-  translate2D,
-  getDegree
-} from '../geometry'
+import { translate2D, getDegree } from '../geometry'
 import {
-  substractVector,
-  normalizeVector,
-  multiplyVector,
-  addVector
+	substractVector,
+	normalizeVector,
+	multiplyVector,
+	addVector
 } from '../vector'
 
 import { v4 as uuidv4 } from 'uuid'
-import {updateComputedGeometryPolygon} from './derivedState/updateComputedGeometryPolygon'
+import { updateComputedGeometryPolygon } from './derivedState/updateComputedGeometryPolygon'
+import { rotateTransformation } from '../matrix'
 
 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.priority = 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)
+	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.roofs = []
+		this.layer = layer
+		this.isClosed = isClosed
+		this.highlight = false
+		this.visible = true
+		this.heightReference = 0
+		this.priority = 0
+		this.margins = {
+			isSameMargin: true,
+			sameMargin: 200,
+			innerOutline: [],
+			outterOutline: [],
+			distances: []
+		}
+		this.isLoading = false
+		this.positionOffset = { x: 0, y: 0, z: 0 }
+		this.angleOffset = 0
+		if (this.layer == 'obstacle') {
+			this.isParallel = true
+		}
+	}
 
-    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 {
-        x: p.x,
-        y: p.y,
-        z: p.z,
-        selected:p.selected,
-        open:p.open,
-        }
-      }),
-      holes: this.holes.map((p) => p.id),
-      layer: this.layer,
-      highlight: this.highlight,
-      visible: this.visible,
-      margins: {
-        isSameMargin:this.margins.isSameMargin,
-        sameMargin:this.margins.sameMargin,
-        distances:JSON.parse(JSON.stringify(this.margins.distances))
-      }
-    }
-    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') {
-      const modules=[]
-      if(this.panels){
-        this.panels.forEach((p) => {
-            modules.push({ id: p.id, index: p.index, outline: p.outline, status: p.status || "active",clipped:p.clipped || false })
-          })
-      }
-      if(this.userDeactivatedPanels){
-        this.userDeactivatedPanels.forEach((p) => {
-            modules.push({ id: p.id, index: p.index, outline: p.outline, status: p.status || "user_deactivated",clipped:p.clipped || false })
-          })
-      }
-      extraSerialization.data = {...this.data,modules:[...this.data.modules]}
-      extraSerialization.roof = { id: this.roof.id }
-      extraSerialization.pvData = this.pvData?{...this.pvData}:null
-      extraSerialization.mountingData = this.mountingData?{...this.mountingData}:null
-      extraSerialization.modules = modules
-      extraSerialization.needsOptimisation = this.needsOptimisation
-      extraSerialization.priority = this.priority
+	clone() {
+		const polygon = new Polygon()
+		Object.keys(this).forEach((key) => {
+			polygon[key] = this[key]
+		})
+		polygon.id = uuidv4()
+		return polygon
+	}
+	getAngle(i) {
+		i = parseInt(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)
+	}
+	getAngleFromTop(i) {
+		const length = this.outline.length
+		const firstPoint = { ...this.outline[(i - 1 + length) % length], z: 0 }
+		const secondPoint = { ...this.outline[i % length], z: 0 }
+		const thirdPoint = { ...this.outline[(i + 1) % length], z: 0 }
+		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)
 
-    } 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,
-        shading_data: this.shadingData ? this.shadingData : undefined
-      }
-    } 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.data.modules
-      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,
-        base_line_index: this.data.base_line_index,
-        justify_percent: this.data.justify_percent,
+		return [toCanvasRef(D), toCanvasRef(F), toCanvasRef(E)]
+	}
+	rotate(deltaAngle, center = { x: 0, y: 0 }) {
+		this.version++
+		this.angleOffset += deltaAngle
+		this.outline.forEach((point) => {
+			const newPoint = rotateTransformation(point, deltaAngle, center)
+			point.x = newPoint.x
+			point.y = newPoint.y
+		})
+		if (this.layer == 'moduleField' && this.data && this.data.modules) {
+			if (this.data.panel_direction_degrees != null) {
+				this.data.panel_direction_degrees += (deltaAngle * 180) / Math.PI
+			}
 
-        number_of_panels_override:!!this.data.number_of_panels_override,
-        number_of_panels:this.data.number_of_panels,
-        yearly_yield_manual_entry:this.data.yearly_yield_manual_entry,
-        yearly_yield_kwh_kwp:this.data.yearly_yield_kwh_kwp,
-        yearly_yield_kwh_kwp_2:this.data.yearly_yield_kwh_kwp_2
-      }
-    } 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
-        }
-      }
-    }
-  }
-}
+			this.data.modules.forEach((module) => {
+				module.outline.forEach((p) => {
+					const newPoint = rotateTransformation(
+						{ x: p[0], y: p[1] },
+						deltaAngle,
+						center
+					)
+					p[0] = newPoint.x
+					p[1] = newPoint.y
+				})
+			})
+		}
+		updateComputedGeometryPolygon(this)
+	}
+	rotateOffset(newAngleOffset, center = { x: 0, y: 0 }) {
+		const deltaAngle = newAngleOffset - this.angleOffset
+		this.rotate(deltaAngle, center)
+	}
+	translate(vectorInMm) {
+		this.version++
+		if(this.roofs){
+			this.roofs.forEach(r=>r.version++)
+		}
+		this.positionOffset.x += vectorInMm.x
+		this.positionOffset.y += vectorInMm.y
+		if (vectorInMm.z) {
+			this.positionOffset.z += vectorInMm.z
+		}
+		this.outline = this.outline.map((point) => {
+			return translate2D(point, vectorInMm)
+		})
+		if (this.layer == 'moduleField' && this.data && this.data.modules) {
+			this.data.modules.forEach((module) => {
+				module.outline.forEach((p) => {
+					p[0] += vectorInMm.x
+					p[1] += vectorInMm.y
+				})
+			})
+		}
+		updateComputedGeometryPolygon(this)
+	}
+	translateOffset(newPositionOffset, center = { x: 0, y: 0 }) {
+		const shift = substractVector(newPositionOffset, this.positionOffset)
+		this.translate(shift)
+	}
+	serialize() {
+		const baseSerialization = {
+			id: this.id,
+			version: this.version,
+			name: this.name,
+			type: this.type,
+			outline: this.outline.map((p) => {
+				return {
+					x: p.x,
+					y: p.y,
+					z: p.z,
+					selected: p.selected,
+					locked: p.locked,
+					open: p.open
+				}
+			}),
+			holes: this.holes.map((p) => p.id),
+			layer: this.layer,
+			highlight: this.highlight,
+			visible: this.visible,
+			margins: {
+				isSameMargin: this.margins.isSameMargin,
+				sameMargin: this.margins.sameMargin,
+				distances: JSON.parse(JSON.stringify(this.margins.distances))
+			}
+		}
+		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') {
+			const modules = []
+			if (this.panels) {
+				this.panels.forEach((p) => {
+					modules.push({
+						id: p.id,
+						index: p.index,
+						outline: p.outline,
+						status: p.status || 'active',
+						clipped: p.clipped || false
+					})
+				})
+			}
+			if (this.userDeactivatedPanels) {
+				this.userDeactivatedPanels.forEach((p) => {
+					modules.push({
+						id: p.id,
+						index: p.index,
+						outline: p.outline,
+						status: p.status || 'user_deactivated',
+						clipped: p.clipped || false
+					})
+				})
+			}
+			extraSerialization.data = {
+				...this.data,
+				modules: [...this.data.modules]
+			}
+			extraSerialization.roof = { id: this.roof.id }
+			extraSerialization.pvData = this.pvData ? { ...this.pvData } : null
+			extraSerialization.mountingData = this.mountingData
+				? { ...this.mountingData }
+				: null
+			extraSerialization.modules = modules
+			extraSerialization.needsOptimisation = this.needsOptimisation
+			extraSerialization.priority = this.priority
+		} 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,
+				shading_data: this.shadingData ? this.shadingData : undefined
+			}
+		} 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.data.modules
+			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,
+				base_line_index: this.data.base_line_index,
+				justify_percent: this.data.justify_percent,
+				pv_module_id: this.pvModuleId,
+				mounting_system_id: this.mountingSystemId,
+				number_of_panels_override: !!this.data.number_of_panels_override,
+				number_of_panels: this.data.number_of_panels,
+				yearly_yield_manual_entry: this.data.yearly_yield_manual_entry,
+				yearly_yield_kwh_kwp: this.data.yearly_yield_kwh_kwp,
+				yearly_yield_kwh_kwp_2: this.data.yearly_yield_kwh_kwp_2
+			}
+		} 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
+				}
+			}
+		}
+	}
+}