@eturnity/eturnity_maths 7.4.0-splitLine.2 → 7.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eturnity/eturnity_maths",
-  "version": "7.4.0-splitLine.2",
+  "version": "7.10.0",
   "author": "Eturnity Team",
   "main": "src/index.js",
   "private": false,

package/src/geometry.js

@@ -151,9 +151,14 @@ export function get3DDistanceBetweenPoints(firstPoint, secondPoint) {
   }
 
   export function getDegree(H, I, J) {
-    const a = get3DDistanceBetweenPoints(H, I)
-    const b = get3DDistanceBetweenPoints(I, J)
-    const c = get3DDistanceBetweenPoints(H, J)
+    let distanceFunction = get3DDistanceBetweenPoints
+    if(H.z==undefined || I.z==undefined || J.z==undefined || isNaN(H.z) || isNaN(I.z) || isNaN(J.z) ){
+      distanceFunction=getDistanceBetweenPoints
+    }
+    const a = distanceFunction(H, I)
+    const b = distanceFunction(I, J)
+    const c = distanceFunction(H, J)
+  
   
     let angle = (Math.acos((a * a + b * b - c * c) / (2 * a * b)) * 180) / Math.PI
     
@@ -952,76 +957,32 @@ export function get3DDistanceBetweenPoints(firstPoint, secondPoint) {
       let area = vectorLength(product)/2
       return area
   }
-  export function getIndexesOfBiggestTriangle(points){
-    return getIndexesOfBiggestTriangleWithFixedIndexes(points,[])
-  }
-  export function arrayIntersection(array1,array2){
-    return array1.filter(value => array2.includes(value));
+  export function getIndexesOfBiggestTrangle(points){
+    return getIndexesOfBiggestTrangleWithFixedIndexes(points,[])
   }
-  export function getIndexesOfBiggestTriangleWithFixedIndexes(points,fixedIndexes,preferedIndexes=[]){
+  export function getIndexesOfBiggestTrangleWithFixedIndexes(points,fixedIndexes){
     if(points.length<3){
       throw new Error("not enough points to make a triangle")
       return 
     }
-    let preferedAndFixedIndexes=[...fixedIndexes,...preferedIndexes]
-    preferedAndFixedIndexes=[...new Set(preferedAndFixedIndexes)]
     let maxArea = -1
-    let maxNumberOfPreferedOrFixedIndexes = -1
     let maxTriangle = [ 0, 1, 2]
-    fixedIndexes=[...new Set(fixedIndexes)].slice(0,3)
+    fixedIndexes=[...new Set(...fixedIndexes)].slice(0,3)
     if(fixedIndexes.length==3){return fixedIndexes}
-    //if(preferedAndFixedIndexes.length==3){return preferedAndFixedIndexes}
       for (let i = 0; i < points.length - 2; i++) {
+        if(fixedIndexes.length==0 || fixedIndexes.includes(i)){
           for (let j = i + 1; j < points.length - 1; j++) {
+            if(fixedIndexes.length<2 || fixedIndexes.includes(j)){
               for (let k = j + 1; k < points.length; k++) {
-                if(arrayIntersection(fixedIndexes,[i,j,k]).length==fixedIndexes.length){
-                  const numberOfPreferedOrFixedIndexes = arrayIntersection(preferedAndFixedIndexes,[i,j,k]).length
-
-                  if(numberOfPreferedOrFixedIndexes >= maxNumberOfPreferedOrFixedIndexes){
-                    const area = triangleArea(points[i], points[j], points[k]);
-                    if (area > maxArea || (numberOfPreferedOrFixedIndexes > maxNumberOfPreferedOrFixedIndexes && (maxArea+1)/(area+1)<4 )) {
-                        maxArea = area
-                        maxNumberOfPreferedOrFixedIndexes = numberOfPreferedOrFixedIndexes
-                        maxTriangle = [i, j, k]
-                    }
-                  }
+                const area = triangleArea(points[i], points[j], points[k]);
+                if (area > maxArea) {
+                    maxArea = area;
+                    maxTriangle = [i, j, k];
                 }
               }
-            
+            }
           }
-        
-      }
-    return maxTriangle
-  }
-  export function getIndexesOfBiggestTriangleWithTwoFixedIndexes(points,fixedIndexes,preferedIndexes=[]){
-    fixedIndexes=[...new Set(fixedIndexes)]
-    let preferedAndFixedIndexes=[...fixedIndexes,...preferedIndexes]
-    preferedAndFixedIndexes=[...new Set(preferedAndFixedIndexes)]
-    if(points.length<3 || fixedIndexes.length<3){
-      throw new Error("not enough points to make a triangle")
-      return 
-    }
-    let maxArea = -1
-    let maxNumberOfPreferedOrFixedIndexes = -1
-    let maxTriangle = [ 0, 1, 2]
-      for (let i = 0; i < points.length - 2; i++) {
-          for (let j = i + 1; j < points.length - 1; j++) {
-              for (let k = j + 1; k < points.length; k++) {
-               if(arrayIntersection(fixedIndexes,[i,j,k]).length==2){
-                const numberOfPreferedOrFixedIndexes = arrayIntersection(preferedAndFixedIndexes,[i,j,k]).length
-                  if(numberOfPreferedOrFixedIndexes >= maxNumberOfPreferedOrFixedIndexes){
-                    const area = triangleArea(points[i], points[j], points[k]);
-                    if (area > maxArea || (numberOfPreferedOrFixedIndexes > maxNumberOfPreferedOrFixedIndexes && (maxArea+1)/(area+1)<4 )) {
-                        maxArea = area
-                        maxNumberOfPreferedOrFixedIndexes = numberOfPreferedOrFixedIndexes
-                        maxTriangle = [i, j, k];
-                    }
-                  }
-                }
-              }
-            
-          }
-        
+        }
       }
     return maxTriangle
   }

package/src/objects/derivedState/updateComputedGeometryPolygon.js

@@ -87,7 +87,7 @@ export function updateComputedGeometryPolygon(polygon) {
   if(polygon.layer=="moduleField"){
     let trimedOutline=[]
     if(polygon.panels.length>0){
-            trimedOutline = getConcaveOutline(polygon.panels,polygon.panels[0].outline)
+      trimedOutline = getConcaveOutline(polygon.panels,polygon.panels[0].outline)
       trimedOutline = trimedOutline.map(p=>{return{
         x:p.x,
         y:p.y,