Fix makeContour adaptive radius for medium-length edges

Co-authored-by: philstopford <1983851+philstopford@users.noreply.github.com>

Author: Copilot

Common/shapeEngine/contourGen.cs

@@ -88,7 +88,7 @@ public static PathD makeContour(PathD original_path, double concaveRadius, doubl
                 radius = concaveRadius;
 
             PathD current_corner = ProcessCorner(startLine, endLine, radius, angularResolution, edgeResolution,
-                SamplingMode.ByMaxSegmentLength);
+                shortEdgeLength, SamplingMode.ByMaxSegmentLength);
             processed.Add(current_corner);
         }
 
@@ -164,7 +164,7 @@ static int[] CategorizeCorners(PathD path_, double short_edge_length)
     }
 
     static PathD ProcessCorner(PathD startLine, PathD endLine, double radius, double angular_resolution,
-        double edge_resolution, SamplingMode mode = SamplingMode.ByMaxAngle)
+        double edge_resolution, double shortEdgeThreshold, SamplingMode mode = SamplingMode.ByMaxAngle)
     {
         PointD startLineStart = startLine[0];
         PointD startLineEnd = startLine[1];
@@ -176,14 +176,19 @@ static PathD ProcessCorner(PathD startLine, PathD endLine, double radius, double
         PointD endLength = Helper.Minus(endLineEnd, endLineStart);
         PointD endDir = Helper.Normalized(endLength);
 
-        double start_radius = radius;
-        double half_edge_length = Math.Abs(Math.Sqrt(startLength.x * startLength.x + startLength.y * startLength.y));
-        if (start_radius > half_edge_length) start_radius = half_edge_length;
+        // Compute actual edge lengths (distance from corner to edge midpoint)
+        double startEdgeLength = Math.Abs(Math.Sqrt(startLength.x * startLength.x + startLength.y * startLength.y));
+        double endEdgeLength = Math.Abs(Math.Sqrt(endLength.x * endLength.x + endLength.y * endLength.y));
+        
+        // Apply adaptive radius limiting based on edge classification
+        double adaptiveRadius = ComputeAdaptiveRadius(startEdgeLength, endEdgeLength, radius, shortEdgeThreshold);
+        
+        double start_radius = adaptiveRadius;
+        if (start_radius > startEdgeLength) start_radius = startEdgeLength;
         PointD curveStartPoint = Helper.Add(startLineStart, Helper.Mult(startDir, start_radius));
 
-        double end_radius = radius;
-        half_edge_length = Math.Abs(Math.Sqrt(endLength.x * endLength.x + endLength.y * endLength.y));
-        if (end_radius > half_edge_length) end_radius = half_edge_length;
+        double end_radius = adaptiveRadius;
+        if (end_radius > endEdgeLength) end_radius = endEdgeLength;
         PointD curveEndPoint = Helper.Add(endLineStart, Helper.Mult(endDir, end_radius));
 
         double dx = curveEndPoint.x - curveStartPoint.x;
@@ -217,6 +222,33 @@ static PathD ProcessCorner(PathD startLine, PathD endLine, double radius, double
         return samples;
     }
 
+    /// <summary>
+    /// Computes an adaptive radius that respects edge length constraints.
+    /// For short edges, applies more restrictive limiting. For normal edges,
+    /// allows larger radii while still preventing geometric issues.
+    /// </summary>
+    static double ComputeAdaptiveRadius(double startEdgeLength, double endEdgeLength, 
+        double desiredRadius, double shortEdgeThreshold)
+    {
+        // Check if either edge qualifies as "short"
+        bool hasShortEdge = (startEdgeLength <= shortEdgeThreshold) || (endEdgeLength <= shortEdgeThreshold);
+        
+        if (hasShortEdge)
+        {
+            // For short edges, limit radius to a fraction of the shortest edge
+            double minEdgeLength = Math.Min(startEdgeLength, endEdgeLength);
+            double maxAllowableRadius = minEdgeLength * 0.4;  // Use 40% of edge length
+            return Math.Min(desiredRadius, maxAllowableRadius);
+        }
+        
+        // For normal edges, use desired radius with standard half-edge limiting
+        double halfStartEdge = startEdgeLength * 0.5;
+        double halfEndEdge = endEdgeLength * 0.5;
+        double maxStandardRadius = Math.Min(halfStartEdge, halfEndEdge);
+        
+        return Math.Min(desiredRadius, maxStandardRadius);
+    }
+
     static PathD AssembleWithEasing(
         PathsD processedCorners,
         int[] corner_types,

UnitTests/PrototypingTests.cs

@@ -751,5 +751,90 @@ public void TestPointNormalization()
         }
 
         #endregion
+
+        #region Contour Generation Tests
+
+        [Test]
+        public void TestMakeContour_10UnitEdge_VerifyAdaptiveRadiusFix()
+        {
+            // Arrange: Create the exact polygon from the problem statement
+            var original_path = new Clipper2Lib.PathD()
+            {
+                new Clipper2Lib.PointD(0, 0),
+                new Clipper2Lib.PointD(0, 60),
+                new Clipper2Lib.PointD(20, 60),
+                new Clipper2Lib.PointD(20, 10),
+                new Clipper2Lib.PointD(60, 10),
+                new Clipper2Lib.PointD(60, 0),
+                new Clipper2Lib.PointD(0, 0)  // Close the path
+            };
+
+            double concaveRadius = 30;
+            double convexRadius = 30;
+            double edgeResolution = 1;
+            double angularResolution = 1;
+            double shortEdgeLength = 0.01;
+            double maxShortEdgeLength = 0.01;
+
+            // Act
+            var result = shapeEngine.contourGen.makeContour(original_path, concaveRadius, convexRadius, 
+                edgeResolution, angularResolution, shortEdgeLength, maxShortEdgeLength);
+
+            // Assert: The result should have smooth curves applied
+            Assert.That(result.Count, Is.GreaterThan(7), "Result should have more points than input due to curve sampling");
+            
+            // The fix ensures that normal 10-unit edges get appropriate treatment
+            // The edge from (60,10) to (60,0) is 10 units, much longer than shortEdgeLength=0.01
+            // With the adaptive radius fix, this should receive proper Bezier curve treatment
+            
+            // Verify the result has a reasonable number of points (not too few, not too many)
+            Console.WriteLine($"Result points: {result.Count}");
+            Assert.That(result.Count, Is.InRange(30, 150), 
+                "Result should have a reasonable number of curve points indicating proper radius application");
+        }
+
+        [Test]
+        public void TestMakeContour_18UnitEdge_ShouldWorkCorrectly()
+        {
+            // Arrange: Create a polygon where the problematic edge is 18 units (reported to work)
+            var original_path = new Clipper2Lib.PathD()
+            {
+                new Clipper2Lib.PointD(0, 0),
+                new Clipper2Lib.PointD(0, 60),
+                new Clipper2Lib.PointD(20, 60),
+                new Clipper2Lib.PointD(20, 18),  // Changed from 10 to 18
+                new Clipper2Lib.PointD(60, 18),  // Changed from 10 to 18  
+                new Clipper2Lib.PointD(60, 0),
+                new Clipper2Lib.PointD(0, 0)
+            };
+
+            double concaveRadius = 30;
+            double convexRadius = 30;
+            double edgeResolution = 1;
+            double angularResolution = 1;
+            double shortEdgeLength = 0.01;
+            double maxShortEdgeLength = 0.01;
+
+            // Act
+            var result = shapeEngine.contourGen.makeContour(original_path, concaveRadius, convexRadius, 
+                edgeResolution, angularResolution, shortEdgeLength, maxShortEdgeLength);
+
+            // Assert: This should work correctly according to the problem statement
+            Assert.That(result.Count, Is.GreaterThan(7), "Result should have curved points");
+            
+            // The 18-unit edge should get proper rounding
+            var pointsNearCorner = new List<Clipper2Lib.PointD>();
+            foreach (var point in result)
+            {
+                if (Math.Abs(point.x - 60) < 35 && Math.Abs(point.y - 0) < 35)
+                {
+                    pointsNearCorner.Add(point);
+                }
+            }
+            
+            Assert.That(pointsNearCorner.Count, Is.GreaterThan(0), "Should have points near the corner");
+        }
+
+        #endregion
     }
 }