!1341 优化:见光面封边判断

src/Add-on/SetSmoothEdge/SetSmoothEdgeFace.ts

@@ -4,7 +4,7 @@ import { equaln, equalv3 } from "../../Geometry/GeUtils";
 import { Arc } from "../../DatabaseServices/Entity/Arc";
 import { GetBoardSealingCurves, GetBoardHighSeal, HandleRectBoardSealingData } from "../../GraphicsSystem/CalcEdgeSealing";
 import { Face } from "../../Geometry/DrillParse/Face";
-import { Matrix4, Vector3 } from "three";
+import { Box3, Matrix4, Vector3 } from "three";
 import { Polyline } from "../../DatabaseServices/Entity/Polyline";
 import { Board } from "../../DatabaseServices/Entity/Board";
 import { Box3Ext } from "../../Geometry/Box";
@@ -18,6 +18,7 @@ class SetSmoothEdgeFaces extends BoardGetFace
     highSealingData: IHighSealedItem[];
     private sealCus: Curve[];
     private _ArcFaceIndexs: Set<number>;
+    private _CoveredWidthFaceMap = new Map<Face, Box3[]>();
     constructor(public Board: Board)
     {
         super(Board);
@@ -101,24 +102,54 @@ class SetSmoothEdgeFaces extends BoardGetFace
                     else
                         continue;
                 }
-
+                let f1CoverBoxes = this._CoveredWidthFaceMap.get(f1) ?? [];
+                let f2CoverBoxes = bg._CoveredWidthFaceMap.get(f2) ?? [];
                 if (f1.type === f2.type)
                 {
-                    if (f1.IsIntersect(f2, scale))
+                    let intRes = f1.IsIntersect(f2, scale, f1CoverBoxes);
+                    if (intRes.isInt)
+                    {
                         this.SmoothFace.add(f1);
-                    if (f2.IsIntersect(f1, scale))
+                        this._CoveredWidthFaceMap.delete(f1);
+                    }
+                    else
+                        this._CoveredWidthFaceMap.set(f1, intRes.coverBoxesList);
+
+                    intRes = f2.IsIntersect(f1, scale, f2CoverBoxes);
+                    if (intRes.isInt)
+                    {
                         bg.SmoothFace.add(f2);
+                        bg._CoveredWidthFaceMap.delete(f2);
+                    }
+                    else
+                        bg._CoveredWidthFaceMap.set(f2, intRes.coverBoxesList);
                 }
                 else
-                    if (f1.IsIntersect(f2, scale))
+                {
+                    let intRes = f1.IsIntersect(f2, scale, f1.type === BoardFaceType.Side ? f1CoverBoxes : f2CoverBoxes);
+                    if (intRes.isInt)
                     {
                         if (f1.type === BoardFaceType.Side)
                         {
                             this.SmoothFace.add(f1);
+                            this._CoveredWidthFaceMap.delete(f1);
                         }
                         if (f2.type === BoardFaceType.Side)
                         {
                             bg.SmoothFace.add(f2);
+                            bg._CoveredWidthFaceMap.delete(f2);
+                        }
+                    }
+                    else
+                    {
+                        if (f1.type === BoardFaceType.Side)
+                        {
+                            this._CoveredWidthFaceMap.set(f1, intRes.coverBoxesList);
+                        }
+                        if (f2.type === BoardFaceType.Side)
+                        {
+                            bg._CoveredWidthFaceMap.set(f2, intRes.coverBoxesList);
+                        }
                     }
                 }
             }

src/Geometry/DrillParse/Face.ts

@@ -1,4 +1,4 @@
-import { Matrix4, Vector3 } from "three";
+import { Box3, Matrix4, Vector3 } from "three";
 import { MatrixPlanarizere } from "../../Common/Matrix4Utils";
 import { Board } from "../../DatabaseServices/Entity/Board";
 import { Region } from "../../DatabaseServices/Entity/Region";
@@ -145,7 +145,7 @@ export class Face
         }
         return newFaces;
     }
-    IsIntersect(f: Face, fuzz = 1e-6): boolean
+    IsIntersect(f: Face, fuzz = 1e-6, currentCoverBoxes: Box3[] = []): { isInt: boolean, coverBoxesList?: Box3[]; }
     {
         //获得侧面和非侧面
         let [sideFace, noSideFace] = this.type === BoardFaceType.Side ? [this, f] : [f, this];
@@ -169,19 +169,55 @@ export class Face
             let size = box.getSize(new Vector3);
 
             if (equaln(size.x * size.y, 0))
-                return false;
+                return { isInt: false, coverBoxesList: currentCoverBoxes };
 
             let con1 = Contour.CreateContour(c1);
             let con2 = Contour.CreateContour(c2);
             let cs = con1.IntersectionBoolOperation(con2);
-
+            let width = 0;
+            let boxList: Box3[] = [];
+            //当前碰撞区域如果遮光直接退出
             for (let c of cs)
             {
-                c.BoundingBox.getSize(size);
+                let b = c.BoundingBox;
-                if (size.x / sideFace.Length > fuzz)
+                b.getSize(size);
-                    return true;
+                width += size.x;
+                if (width / sideFace.Length > fuzz)
+                    return { isInt: true };
+                boxList.push(b);
+            }
+            if (currentCoverBoxes.length === 0)
+            {
+                return { isInt: false, coverBoxesList: boxList };
+            }
+            //与旧盒子合并后测试是否遮光
+            width = 0;
+            while (currentCoverBoxes.length > 0)
+            {
+                let b = currentCoverBoxes.pop();
+                let isInt = false;
+                for (let box of boxList)
+                {
+                    if (box.intersectsBox(b))
+                    {
+                        isInt = true;
+                        box.union(b);
+                        break;
+                    }
+                }
+                if (!isInt)
+                    boxList.push(b);
+            }
+
+            for (let b of boxList)
+            {
+                b.getSize(size);
+                width += size.x;
+                if (width / sideFace.Length > fuzz)
+                    return { isInt: true };
             }
-            return false;
+
+            return { isInt: false, coverBoxesList: boxList };
         }
         else
         {
@@ -195,10 +231,38 @@ export class Face
             {
                 retBox.intersect(box3);
                 let size = retBox.getSize(new Vector3());
-                return !equaln(size.x * size.y, 0) && size.x / sideFace.Length > fuzz && size.y / sideFace.Width > fuzz;
+                if (equaln(size.x * size.y, 0) || size.y / sideFace.Width <= fuzz)
+                    return { isInt: false, coverBoxesList: currentCoverBoxes };
+
+                if (size.x / sideFace.Length > fuzz)
+                    return { isInt: true };
+                if (currentCoverBoxes.length === 0)
+                {
+                    return { isInt: false, coverBoxesList: [retBox] };
+                }
+                for (let b of currentCoverBoxes)
+                {
+                    if (b.intersectsBox(retBox))
+                    {
+                        b.union(retBox);
+                        retBox = null;
+                        break;
+                    }
                 }
+                if (retBox)
+                    currentCoverBoxes.push(retBox);
+                let width = 0;
+                for (let b of currentCoverBoxes)
+                {
+                    b.getSize(size);
+                    width += size.x;
+                    if (width / sideFace.Length > fuzz)
+                        return { isInt: true };
                 }
 
-        return false;
+                return { isInt: false, coverBoxesList: currentCoverBoxes };
+            }
+            return { isInt: false, coverBoxesList: currentCoverBoxes };
+        }
     }
 }