Merge pull request #177 from jgphilpott/copilot/fix-orphaned-twig-components

Fix orphaned twig segments and strengthen twig/branch joint in tree support generation

Author: jgphilpott

resources/gcode/support/tree/arch/sideways-everywhere.gcode

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5c2173be17318e515d2e639076c878399254fb1119185a0f206089f71aba510c
-size 749497
+oid sha256:622d8a7279c72c522ed06489ce5256be09f35baf45ad18e1ab8627a241ae9d2f
+size 930444

resources/gcode/support/tree/arch/upright.gcode

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:14ab35c8b1c1258ac00816a6436e644e298e200c0bac80a1e55ff6586cf3c3ae
-size 1056412
+oid sha256:0203ffb424f0563d6a488c14f40a2ae1030f507e5cbd255e6fc0658ae1a9adc5
+size 1408356

resources/gcode/support/tree/dome/sideways-everywhere.gcode

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3779e0ab50cb3e2fcfc30905af786d31dfe2eff0d8617e0fa92a42e15d25574c
-size 929963
+oid sha256:986560f336ffb9603158d5b64dc1007940e6c54971527a065d091462dc420650
+size 1054325

resources/gcode/support/tree/dome/upright.gcode

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b0b308cfbe67b23265c70981a7d13160f7517f4f9c54b22d3ac1c5fa38050904
-size 1159493
+oid sha256:09d860964fbee929f4ab37c4d6bf2fc7d214e3a7d0dffd3fa1113b0ca4438a04
+size 1419308

src/slicer/support/tree/tree.coffee

@@ -34,8 +34,15 @@ CIRCLE_SEGMENTS = 12
 # Chord length = 2 * radius * CIRCLE_CHORD_SIN_FACTOR.
 CIRCLE_CHORD_SIN_FACTOR = Math.sin(Math.PI / CIRCLE_SEGMENTS)
 
+# Number of layers by which each twig overlaps its parent branch.
+# Twigs start this many layers below the branch endpoint so that branch and twig
+# material are printed at the same Z level, physically bonding the joint.
+TWIG_OVERLAP_LAYERS = 1
+
 module.exports =
 
+    TWIG_OVERLAP_LAYERS: TWIG_OVERLAP_LAYERS
+
     # Return the interpolated face Z at (x, y) by searching all region faces.
     # Returns null if the point lies outside every face's 2D XY projection.
     getFaceZAtPoint: (x, y, faces) ->
@@ -146,18 +153,35 @@ module.exports =
 
             cx = 0
             cy = 0
-            maxZ = -Infinity
 
             for tip in clusterTips
 
                 cx += tip.x
                 cy += tip.y
-                maxZ = Math.max(maxZ, tip.z)
 
             cx /= clusterTips.length
             cy /= clusterTips.length
 
-            branchNodes.push({ x: cx, y: cy, z: maxZ, tips: clusterTips })
+            # Compute the branch node Z from the 45-degree constraint applied to each tip.
+            # nodeZ = min(tip.z - tdist) guarantees every twig rises at ≤ 45 degrees from
+            # the branch endpoint to its contact tip, eliminating orphaned twig segments.
+            nodeZ = Infinity
+
+            for tip in clusterTips
+
+                tdx = tip.x - cx
+                tdy = tip.y - cy
+                tdist = Math.sqrt(tdx * tdx + tdy * tdy)
+                nodeZ = Math.min(nodeZ, tip.z - tdist)
+
+            nodeZ = Math.max(nodeZ, buildPlateZ + layerHeight)
+
+            # Round to 0.1 µm to avoid floating-point edge cases in the twig-emission
+            # condition (node.z < tip.z - layerHeight) when large absolute coordinates
+            # accumulate tiny rounding errors that differ from small-coordinate equivalents.
+            nodeZ = Math.round(nodeZ * 10000) / 10000
+
+            branchNodes.push({ x: cx, y: cy, z: nodeZ, tips: clusterTips })
 
         # Compute branch root heights: where each branch diverges from the shared trunk.
         # The ideal root height is determined by the 45° angle constraint
@@ -195,6 +219,13 @@ module.exports =
             node = branchNodes[nodeIdx]
             branchRootZ = branchRootZs[nodeIdx]
 
+            # Guarantee the branch spans at least one printable layer.
+            # When nodeZ was clamped to buildPlateZ + layerHeight and branchRootZ was also
+            # clamped to the same value, the branch segment collapses to zero height and
+            # never intersects any layer Z plane.  Nudging node.z up by layerHeight ensures
+            # a non-zero segment without changing the already-computed branchRootZ.
+            node.z = Math.max(node.z, Math.round((branchRootZ + layerHeight) * 10000) / 10000)
+
             # Branch segment: angled from trunk toward the branch node.
             segments.push({
                 x1: trunkX, y1: trunkY, z1: branchRootZ
@@ -203,19 +234,18 @@ module.exports =
             })
 
             # Twig segments: fine sub-branches from cluster node to individual contact tips.
-            for tip in node.tips
+            # Twigs start TWIG_OVERLAP_LAYERS below the branch endpoint so that both the
+            # branch (nearing its end) and the twig (at its root) are printed at the same Z,
+            # creating a physical bond that strengthens the twig/branch joint.
+            # Floor is branchRootZ (not buildPlateZ) so twigs never start below the branch.
+            twigStartZ = Math.max(node.z - TWIG_OVERLAP_LAYERS * layerHeight, branchRootZ)
 
-                tdx = tip.x - node.x
-                tdy = tip.y - node.y
-                tdist = Math.sqrt(tdx * tdx + tdy * tdy)
-
-                twigRootZ = tip.z - tdist
-                twigRootZ = Math.max(twigRootZ, branchRootZ + layerHeight)
+            for tip in node.tips
 
-                if twigRootZ < tip.z - layerHeight
+                if twigStartZ < tip.z - layerHeight
 
                     segments.push({
-                        x1: node.x, y1: node.y, z1: twigRootZ
+                        x1: node.x, y1: node.y, z1: twigStartZ
                         x2: tip.x, y2: tip.y, z2: tip.z
                         type: 'twig'
                     })

src/slicer/support/tree/tree.test.coffee

@@ -359,10 +359,72 @@ describe 'Tree Support Module', ->
             segsOrigin = treeSupport.buildTreeStructure(regionAtOrigin, 0.4, 0, 0.2)
             segsOffset = treeSupport.buildTreeStructure(regionOffset, 0.4, 0, 0.2)
 
-            # The two structures should produce the same segment counts.
-            expect(segsOffset.length).toBe(segsOrigin.length)
+            # The number of branch nodes (and therefore branch segments) must be identical.
+            branchOrigin = segsOrigin.filter (s) -> s.type is 'branch'
+            branchOffset = segsOffset.filter (s) -> s.type is 'branch'
 
-    describe 'generateTreePattern', ->
+            expect(branchOffset.length).toBe(branchOrigin.length)
+
+        test 'should not produce orphaned twigs - each twig start must match a branch endpoint', ->
+
+            # A twig is orphaned when it has no structural connection to any branch.
+            # Each twig's XY root must coincide with a branch endpoint's XY, and the
+            # twig's Z root must be within TWIG_OVERLAP_LAYERS layers below the branch
+            # endpoint (the twig starts slightly lower to create a physical bond).
+            layerHeight = 0.2
+            overlapZ = treeSupport.TWIG_OVERLAP_LAYERS * layerHeight
+            region = makeRegion(-10, 10, -10, 10, 20)
+            segments = treeSupport.buildTreeStructure(region, 0.4, 0, layerHeight)
+
+            twigSegments = segments.filter (s) -> s.type is 'twig'
+            branchSegments = segments.filter (s) -> s.type is 'branch'
+
+            expect(twigSegments.length).toBeGreaterThan(0)
+
+            for twig in twigSegments
+
+                # Every twig must have a branch whose XY endpoint matches the twig XY root,
+                # with the twig starting at most TWIG_OVERLAP_LAYERS layers below the branch end.
+                matchingBranch = branchSegments.some (branch) ->
+                    Math.abs(branch.x2 - twig.x1) < 0.001 and
+                    Math.abs(branch.y2 - twig.y1) < 0.001 and
+                    twig.z1 <= branch.z2 + 0.001 and
+                    twig.z1 >= branch.z2 - overlapZ - 0.001
+
+                expect(matchingBranch).toBe(true)
+
+            return
+
+        test 'should produce valid branches and twigs for low overhang near the build plate', ->
+
+            # A wide region at low Z forces nodeZ onto its clamp (buildPlateZ + layerHeight),
+            # which previously caused branchRootZ == nodeZ (zero-height branch) and
+            # twigStartZ to fall below branchRootZ.  Both must now be handled correctly.
+            layerHeight = 0.2
+            overlapZ = treeSupport.TWIG_OVERLAP_LAYERS * layerHeight
+            region = makeRegion(-10, 10, -10, 10, 2)
+            segments = treeSupport.buildTreeStructure(region, 0.4, 0, layerHeight)
+
+            branchSegments = segments.filter (s) -> s.type is 'branch'
+            twigSegments = segments.filter (s) -> s.type is 'twig'
+
+            # Every branch must span at least one printable layer (non-zero height).
+            for branch in branchSegments
+
+                expect(branch.z2).toBeGreaterThan(branch.z1)
+
+            # Every twig must connect to a branch and start within branchRootZ..nodeZ.
+            for twig in twigSegments
+
+                matchingBranch = branchSegments.some (branch) ->
+                    Math.abs(branch.x2 - twig.x1) < 0.001 and
+                    Math.abs(branch.y2 - twig.y1) < 0.001 and
+                    twig.z1 >= branch.z1 - 0.001 and
+                    twig.z1 <= branch.z2 + 0.001
+
+                expect(matchingBranch).toBe(true)
+
+            return
 
         # Helper: create a minimal slicer-like object for testing.
         makeSlicer = ->