@eturnity/eturnity_maths 7.20.0 → 7.24.1

package/src/splitMergePolygons.js

@@ -1,579 +1,643 @@
 import { PlanarFaceTree } from 'planar-face-discovery'
 import {
-  substractVector,
-  addVector,
-  multiplyVector,
-  dotProduct,
-  vectorLength
+	substractVector,
+	addVector,
+	multiplyVector,
+	dotProduct,
+	vectorLength
 } from './vector'
 import {
-  isAlmostSamePoint2D,
-  getPointOnLine,
-  getDistanceBetweenPoints,
-  isPointBetweenSegment,
-  isInsidePolygon,
-  verticalProjectionOnPlane,
-  polygonsHaveSame2DOutline
+	isAlmostSamePoint2D,
+	getPointOnLine,
+	getDistanceBetweenPoints,
+	isPointBetweenSegment,
+	isInsidePolygon,
+	verticalProjectionOnPlane,
+	polygonsHaveSame2DOutline,
+	calculateArea
 } from './geometry'
 import { groupBy } from 'lodash'
 import { Polygon } from './objects/Polygon'
 import { defaultBaseHeight, mmTolerance } from './config'
+import { intersectOutlines } from './intersectionPolygon'
 
-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) ||
+export function mergePolygons(polygonIdsToMerge, edges, layer, polygons) {
+	console.log('mergePolygon')
+	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 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
+	const polygonList = []
+	for (let k = 0; k < outlineList.length; k++) {
+		//check if roof with same outline already exist:
+		let polygon = polygons.find((polygon) =>
+			polygonsHaveSame2DOutline(outlineList[k], polygon.outline)
+		)
+		if (!polygon) {
+			let newPolygon = new Polygon(outlineList[k], layer)
+			polygonList.push(newPolygon)
+		}else{
+			polygonList.push(polygon)
+		}
+	}
+	return polygonList
 }
 
 export async function trySplitPolygons(
-  constructionPolyline,
-  edges,
-  roofs,
-  isClosedContructionPolyline
+	constructionPolyline,
+	edges,
+	roofs,
+	isClosedContructionPolyline
 ) {
-  let result=roofs
-  try {
-      result = splitPolygons(
-        constructionPolyline,
-        edges,
-        roofs,
-        isClosedContructionPolyline
-      )
-  } catch (error) {
-    console.error('An error occurred:', error);
-  } finally {
-    return result
-  }
+	let result = roofs
+	try {
+		result = splitPolygons(
+			constructionPolyline,
+			edges,
+			roofs,
+			isClosedContructionPolyline
+		)
+	} catch (error) {
+		console.error('An error occurred:', error)
+	} finally {
+		return result
+	}
 }
 
 export async function splitPolygons(
-  constructionPolyline,
-  edges,
-  roofs,
-  isClosedContructionPolyline
+	constructionPolyline,
+	edges,
+	roofs,
+	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++) {
-    //check if roof with same outline already exist: 
-      let roof = roofs.find((roof) =>
-        polygonsHaveSame2DOutline(outlineList[k], roof.outline)
-      )
-      let newRoof=new Polygon(outlineList[k], 'roof')
-      if (roof) {
-        newRoof.id=roof.id
-      }
-    polygonList.push(newRoof)
-  }
-  return polygonList
+	console.log('splitPolygon')
+	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++) {
+		//check if roof with same outline already exist:
+		let roof = roofs.find((roof) =>
+			polygonsHaveSame2DOutline(outlineList[k], roof.outline)
+		)
+		if (roof) {
+			polygonList.push(roof)
+		} else {
+			let newRoof = new Polygon(outlineList[k], 'roof')
+			polygonList.push(newRoof)
+		}
+	}
+	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 &&
+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
+	)
+	return intersections
 }
 
 export function getNodeList(intersections, edges, constructionPolyline) {
-  let nodeList = []
-  edges.forEach((edge) => {
-    nodeList.push(edge.outline[0])
-    nodeList.push(edge.outline[1])
-  })
+	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 =
+	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
+		}
+		nodeList.push(p)
+	})
+	intersections.forEach((inter) => {
+		const edge = edges[inter.edgeIndex]
+		inter.point.z =
+      edge.outline[0].z +
+      inter.edgeParam * (edge.outline[1].z - edge.outline[0].z)
+		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])
-  }
+	//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
+	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
+	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
+	//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 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 untouchedEdgeIndexes = [...Array(edges.length).keys()].filter(
+		(k) => !edgeUsedIndexes.includes(k)
+	)
 
-  const untouchedPolylineIndexes = [
-    ...Array(
-      constructionPolyline.outline.length - 1 + isClosedContructionPolyline
-    ).keys()
-  ].filter((k) => !polylineUsedIndexes.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])
+	//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])
-    }
+		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])
+		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])
-    }
+		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 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)
-    }
-  })
+	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
+	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]
-  }
+	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())
+	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(for z value)
-  outlines = outlines.map((outline) => {
-    let roof = roofs.find((roof) =>
-      polygonsHaveSame2DOutline(outline, roof.outline)
-    )
-    if (roof) {
-      outline = JSON.parse(JSON.stringify(roof.outline))
-    }
-    return outline
-  })
-  return outlines
+	//check for existing roofs(for z value)
+	outlines = outlines.map((outline) => {
+		let roof = roofs.find((roof) =>
+			polygonsHaveSame2DOutline(outline, roof.outline)
+		)
+		if (roof) {
+			outline = JSON.parse(JSON.stringify(roof.outline))
+		} else {
+			let underneathRoofsIntersectionsData = roofs.map((roof) => {
+				const intersections = intersectOutlines(roof.outline, outline)
+				let area = 0
+				if (intersections.length) {
+					area = calculateArea(intersections[0])
+				}
+				return {
+					roof,
+					intersectionLength: intersections.length,
+					intersections,
+					area
+				}
+			})
+			underneathRoofsIntersectionsData =
+        underneathRoofsIntersectionsData.filter((d) => d.intersectionLength > 0)
+			if (underneathRoofsIntersectionsData.length > 0) {
+				underneathRoofsIntersectionsData.sort(
+					(a, b) => a.roof.area - b.roof.area
+				)
+				let roofUnderneath = underneathRoofsIntersectionsData[0].roof
+				outline = outline.map((p) =>
+					verticalProjectionOnPlane(
+						p,
+						roofUnderneath.normalVector,
+						roofUnderneath.flatOutline[0]
+					)
+				)
+			}
+		}
+		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 ||
+	A = { ...A, z: 0 }
+	B = { ...B, z: 0 }
+	C = { ...C, z: 0 }
+	D = { ...D, z: 0 }
+	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
-    }
-  ]
+		) {
+			//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
+		}
+	]
 }