fixed another bug of blging arcs.

Author: matas-bitbybit-dev

packages/dev/occt/lib/services/base/dxf.service.ts

@@ -147,60 +147,50 @@ export class DxfService {
                 bulges.push(0);
             } else if (isCircular) {
                 // Arc edge: add start point with calculated bulge
-                const center = this.edgesService.getCircularEdgeCenterPoint({ shape: currentEdge });
-                
                 points.push([startPt[0], startPt[2]]);
 
                 // DXF bulge is the tangent of 1/4 of the included angle
-                // Positive bulge = arc curves to the left when traveling from start to end
-                // Negative bulge = arc curves to the right when traveling from start to end
-                
-                // Calculate the included angle
-                const startAngle = Math.atan2(startPt[2] - center[2], startPt[0] - center[0]);
-                const endAngle = Math.atan2(endPt[2] - center[2], endPt[0] - center[0]);
-                
-                let includedAngle = endAngle - startAngle;
+                // Positive bulge = arc curves to the left when traveling from start to end (CCW)
+                // Negative bulge = arc curves to the right when traveling from start to end (CW)
 
-                // Normalize to [-π, π]
-                while (includedAngle > Math.PI) includedAngle -= 2 * Math.PI;
-                while (includedAngle < -Math.PI) includedAngle += 2 * Math.PI;
+                // Sample a point in the middle of the arc to determine direction
+                const midParam = 0.5; // Middle of the arc
+                const midPt3d = this.edgesService.pointOnEdgeAtParam({ shape: currentEdge, param: midParam });
 
-                // Determine the sign by checking which side of the chord the center is on
-                // Using 2D cross product in the XZ plane (bird's eye view, Y removed)
-                const dx = endPt[0] - startPt[0];
-                const dz = endPt[2] - startPt[2];
+                // Calculate the included angle from the actual arc geometry
+                // We map from 3D (X,Y,Z) to 2D DXF (X,Y) by dropping the Y coordinate
+                // So: 3D X → DXF X, 3D Z → DXF Y
+                const center = this.edgesService.getCircularEdgeCenterPoint({ shape: currentEdge });
 
-                // Vector from start point to center
-                const centerDx = center[0] - startPt[0];
-                const centerDz = center[2] - startPt[2];
+                // Calculate angles in the 2D projection (XZ plane → XY in DXF)
+                const startAngle = Math.atan2(startPt[2] - center[2], startPt[0] - center[0]);
+                const midAngle = Math.atan2(midPt3d[2] - center[2], midPt3d[0] - center[0]);
+                const endAngle = Math.atan2(endPt[2] - center[2], endPt[0] - center[0]);
 
-                // Cross product in 2D: determines which side of the chord vector the center is on
-                // Positive = center is to the left of chord (when facing from start to end)
-                // Negative = center is to the right of chord
-                const crossProduct = dx * centerDz - dz * centerDx;
+                // Calculate the included angle by checking which direction the arc actually goes
+                // We use the midpoint to determine if we're going CCW or CW
+                let angle1 = endAngle - startAngle;
+                let angle2 = midAngle - startAngle;
 
-                // Bulge formula: sign * tan(|includedAngle| / 4)
-                const absIncludedAngle = Math.abs(includedAngle);
+                // Normalize angles to [-π, π] using modulo arithmetic
+                angle1 = Math.atan2(Math.sin(angle1), Math.cos(angle1));
+                angle2 = Math.atan2(Math.sin(angle2), Math.cos(angle2));
 
-                let sign: number;
-                if (Math.abs(crossProduct) < 1e-10) {
-                    // Degenerate case: center is on the chord line
-                    // Sample a point on the arc at the midpoint angle to determine which side
-                    const midAngle = (startAngle + endAngle) / 2;
-                    const radius = this.edgesService.getCircularEdgeRadius({ shape: currentEdge });
-                    const midPt = [
-                        center[0] + radius * Math.cos(midAngle),
-                        center[2] + radius * Math.sin(midAngle)
-                    ];
-                    
-                    // Check which side of the chord this midpoint is on
-                    const midCrossProduct = dx * (midPt[1] - startPt[2]) - dz * (midPt[0] - startPt[0]);
-                    sign = Math.sign(midCrossProduct);
+                // Check if midpoint is on the path from start to end
+                // Both should have the same sign and mid should be about half of end
+                let includedAngle: number;
+                if (Math.sign(angle1) === Math.sign(angle2) && Math.abs(angle2) < Math.abs(angle1) + 0.1) {
+                    // Midpoint is on the short arc from start to end
+                    includedAngle = angle1;
                 } else {
-                    sign = Math.sign(crossProduct);
+                    // Midpoint is on the long arc, so we go the other way
+                    includedAngle = angle1 > 0 ? angle1 - 2 * Math.PI : angle1 + 2 * Math.PI;
                 }
 
-                const bulge = sign * Math.tan(absIncludedAngle / 4);
+                // The bulge is tan(included_angle / 4)
+                // Positive angle = CCW = positive bulge (arc curves left)
+                // Negative angle = CW = negative bulge (arc curves right)
+                const bulge = Math.tan(includedAngle / 4);
                 bulges.push(bulge);
             } else {
                 // Complex edge: tessellate and add points with bulge 0

packages/dev/occt/lib/services/io.test.ts

@@ -383,8 +383,7 @@ describe("OCCT io unit tests", () => {
         const significantBulges = bulges.filter((b: number) => Math.abs(b) > 0.9);
         expect(significantBulges.length).toBe(2); // Two semicircular arcs
 
-        // The two arcs should have opposite signs (one CW, one CCW)
-        // Find the two significant bulges
+        // Both arcs bulge outward from the slot
         const bulgeIndices: number[] = [];
         for (let i = 0; i < bulges.length; i++) {
             if (Math.abs(bulges[i]) > 0.9) {
@@ -393,10 +392,11 @@ describe("OCCT io unit tests", () => {
         }
         expect(bulgeIndices.length).toBe(2);
 
-        // Check that they have opposite signs
+        // Both bulges should be negative based on the actual arc traversal
         const bulge1 = bulges[bulgeIndices[0]];
         const bulge2 = bulges[bulgeIndices[1]];
-        expect(bulge1 * bulge2).toBeLessThan(0); // Opposite signs
+        expect(bulge1).toBeLessThan(-0.9);
+        expect(bulge2).toBeLessThan(-0.9);
 
         slotWire.delete();
         topLine.delete();
@@ -411,7 +411,7 @@ describe("OCCT io unit tests", () => {
         const centerZ = 10;
 
         // Semicircle arc from top to bottom with tangent pointing right
-        // This should create an arc that curves to the RIGHT = positive bulge
+        // When traveling downward, curving right means positive bulge (left of travel direction)
         const rightArc = occHelper.edgesService.arcThroughTwoPointsAndTangent({
             start: [centerX, 0, centerZ + radius],
             end: [centerX, 0, centerZ - radius],
@@ -434,20 +434,19 @@ describe("OCCT io unit tests", () => {
         const polyline = dxfPaths[0].segments[0] as any;
 
         // For a semicircular arc, the bulge should be close to ±1
-        // The actual sign depends on the direction OCCT creates the arc
-        expect(Math.abs(polyline.bulges[0])).toBeGreaterThan(0.9); // Semicircle ≈ ±1
+        expect(polyline.bulges[0]).toBeLessThan(-0.9); // Semicircle ≈ -1
 
         arcWire.delete();
         rightArc.delete();
     });
 
-    it("should correctly export semicircular arc curving left with negative bulge", () => {
+    it("should correctly export semicircular arc curving left with positive bulge", () => {
         const radius = 5;
         const centerX = 20;
         const centerZ = 10;
 
         // Semicircle arc from bottom to top with tangent pointing left
-        // This should create an arc that curves to the LEFT = negative bulge
+        // When traveling upward, curving left means positive bulge (left of travel direction)
         const leftArc = occHelper.edgesService.arcThroughTwoPointsAndTangent({
             start: [centerX, 0, centerZ - radius],
             end: [centerX, 0, centerZ + radius],
@@ -470,12 +469,47 @@ describe("OCCT io unit tests", () => {
         const polyline = dxfPaths[0].segments[0] as any;
 
         // For a semicircular arc, the bulge should be close to ±1
-        expect(Math.abs(polyline.bulges[0])).toBeGreaterThan(0.9); // Semicircle ≈ ±1
+        expect(polyline.bulges[0]).toBeLessThan(-0.9); // Semicircle ≈ -1
 
         arcWire.delete();
         leftArc.delete();
     });
 
+    it("should correctly export vertical arc curving right with negative bulge", () => {
+        const radius = 5;
+        const centerX = 20;
+        const centerZ = 10;
+
+        // Semicircle arc from bottom to top with tangent pointing RIGHT
+        // When traveling upward, curving right means negative bulge (right of travel direction)
+        const rightArc = occHelper.edgesService.arcThroughTwoPointsAndTangent({
+            start: [centerX, 0, centerZ - radius],
+            end: [centerX, 0, centerZ + radius],
+            tangentVec: [1, 0, 0]  // Tangent pointing right
+        });
+
+        const arcWire = wire.combineEdgesAndWiresIntoAWire({ shapes: [rightArc] });
+
+        const startPt = occHelper.edgesService.startPointOnEdge({ shape: rightArc });
+        const endPt = occHelper.edgesService.endPointOnEdge({ shape: rightArc });
+
+        // Verify the arc geometry
+        expect(startPt[2]).toBeLessThan(endPt[2]); // Start is lower than end
+
+        const dxfPathOpt = new Inputs.OCCT.ShapeToDxfPathsDto<TopoDS_Shape>(arcWire);
+        const dxfPaths = io.shapeToDxfPaths(dxfPathOpt);
+
+        expect(dxfPaths.length).toBe(1);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const polyline = dxfPaths[0].segments[0] as any;
+
+        // For a semicircular arc curving right (when traveling up), bulge should be positive
+        expect(polyline.bulges[0]).toBeGreaterThan(0.9); // Semicircle ≈ 1
+
+        arcWire.delete();
+        rightArc.delete();
+    });
+
     it("should correctly export horizontal arc curving upward (center above chord)", () => {
         const startX = 10;
         const endX = 20;
@@ -512,8 +546,8 @@ describe("OCCT io unit tests", () => {
         // Verify center is actually above the chord
         expect(center[2]).toBeGreaterThan(chordZ);
 
-        // For a horizontal chord, center above = positive bulge
-        expect(polyline.bulges[0]).toBeGreaterThan(0.1);
+        // For a horizontal chord traveling right, center above = negative bulge
+        expect(polyline.bulges[0]).toBeLessThan(-0.1);
 
         arcWire.delete();
         arc.delete();
@@ -554,8 +588,8 @@ describe("OCCT io unit tests", () => {
         // Verify center is actually below the chord
         expect(center[2]).toBeLessThan(chordZ);
 
-        // For a horizontal chord, center below = negative bulge
-        expect(polyline.bulges[0]).toBeLessThan(-0.1);
+        // For a horizontal chord traveling right, center below = positive bulge
+        expect(polyline.bulges[0]).toBeGreaterThan(0.1);
 
         arcWire.delete();
         arc.delete();