@eturnity/eturnity_maths 7.4.0-splitLine.0 → 7.4.0-splitLine.2

package/package.json

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

package/src/geometry.js

@@ -952,32 +952,76 @@ export function get3DDistanceBetweenPoints(firstPoint, secondPoint) {
       let area = vectorLength(product)/2
       return area
   }
-  export function getIndexesOfBiggestTrangle(points){
-    return getIndexesOfBiggestTrangleWithFixedIndexes(points,[])
+  export function getIndexesOfBiggestTriangle(points){
+    return getIndexesOfBiggestTriangleWithFixedIndexes(points,[])
   }
-  export function getIndexesOfBiggestTrangleWithFixedIndexes(points,fixedIndexes){
+  export function arrayIntersection(array1,array2){
+    return array1.filter(value => array2.includes(value));
+  }
+  export function getIndexesOfBiggestTriangleWithFixedIndexes(points,fixedIndexes,preferedIndexes=[]){
     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++) {
-                const area = triangleArea(points[i], points[j], points[k]);
-                if (area > maxArea) {
-                    maxArea = area;
-                    maxTriangle = [i, j, 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]
+                    }
+                  }
                 }
               }
-            }
+            
           }
-        }
+        
+      }
+    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,