Merge pull request #32 from aws-cqc/gp/fix-terminate

Fix initial termination starting point, behavior on curves

Author: gpeairs

Diff for: CHANGELOG.md

@@ -9,6 +9,8 @@ The format of this changelog is based on
 ### Fixed
 
   - `launch!` without rounding now has the correct gap behind the pad
+  - `terminate!` with `initial=true` appends the termination before the `Path` start as documented (previously incorrectly kept `p0(path)` constant, shifting the rest of the `Path` forward)
+  - `terminate!` with rounding on a curve is still drawn as straight but keeps the full underlying segment (previously consumed some turn angle to replace with straight segment including rounding length)
 
 ## 1.0.0 (2025-02-27)
 

Diff for: src/paths/paths.jl

@@ -1175,14 +1175,18 @@ If the preceding style is a CPW, this is a "short termination" if `iszero(gap)`
 
 Rounding of corners may be specified with radius given by `rounding`. Rounding keeps the
 trace length constant by removing some length from the preceding segment and adding a
-rounded section of equivalent maximum length. (This produces a small quirk if you terminate
-a curved segment with rounding—the termination is "straight" starting at `rounding`
-away from the end of the curve, meaning that the `α0(pa)`)
+rounded section of equivalent maximum length.
+
+Terminations can be applied on curves without changing the underlying curve. If you add a
+segment after a termination, it will start a straight distance `gap` away from where the original
+curve ended. However, rounded terminations are always drawn as though straight from the point where
+rounding starts, slightly before the end of the curve. This allows the rounded corners to be represented
+as exact circular arcs.
 
 If the preceding style is a trace, the termination only rounds the corners at the end of the
 segment or does nothing if `iszero(rounding)`.
 
-If `initial`, the termination is applied at the beginning of the `Path`.
+If `initial`, the termination is appended before the beginning of the `Path`.
 """
 function terminate!(
     pa::Path{T};
@@ -1192,6 +1196,7 @@ function terminate!(
 ) where {T}
     termlen = gap + rounding
     iszero(termlen) && return
+    termsty = Termination(pa, rounding; initial=initial, cpwopen=!iszero(gap))
     # Nonzero rounding: splice and delete to make room for rounded part
     if !iszero(rounding)
         orig_sty = initial ? undecorated(style0(pa)) : laststyle(pa)
@@ -1221,17 +1226,30 @@ function terminate!(
                 )
             )
         splice!(pa, split_idx, split(split_node, split_len))
-        deleteat!(pa, initial ? firstindex(pa) : lastindex(pa))
+        termsty = if initial
+            Termination(Path(pa[2:end]), rounding; initial=initial, cpwopen=!iszero(gap))
+        else
+            Termination(Path(pa[1:(end - 1)]), rounding; initial=initial, cpwopen=!iszero(gap))
+        end
     end
 
-    termsty = Termination(pa, rounding; initial=initial, cpwopen=!iszero(gap))
-
     if initial
         α = α0(pa)
-        p = p0(pa) - termlen * Point(cos(α), sin(α))
-        pushfirst!(pa, Straight{T}(termlen, p, α), termsty)
+        p = p0(pa) - gap * Point(cos(α), sin(α))
+        pa.p0 = p
+        pushfirst!(pa, Straight{T}(gap, p, α), termsty)
+        if !iszero(rounding)
+            # merge first two segments and apply termsty
+            simplify!(pa, 1:2)
+            setstyle!(pa[1], termsty)
+        end
     else
-        straight!(pa, termlen, termsty)
+        straight!(pa, gap, termsty)
+        if !iszero(rounding)
+            # merge last two segments and apply termsty
+            simplify!(pa, (length(pa) - 1):length(pa))
+            setstyle!(pa[end], termsty)
+        end
     end
 end
 

Diff for: src/render/termination.jl

@@ -80,7 +80,16 @@ function _poly(f::Paths.Straight{T}, s::Paths.CPWOpenTermination) where {T}
     end
 end
 
-function to_polygons(f::Paths.Straight{T}, s::Paths.CPWOpenTermination; kwargs...) where {T}
+function to_polygons(f::Paths.Segment{T}, s::Paths.CPWOpenTermination; kwargs...) where {T}
+    return to_polygons(_poly(f, s); kwargs...)
+end
+
+# Disambiguate from compound fallback
+function to_polygons(
+    f::Paths.CompoundSegment{T},
+    s::Paths.CPWOpenTermination;
+    kwargs...
+) where {T}
     return to_polygons(_poly(f, s); kwargs...)
 end
 
@@ -124,8 +133,13 @@ function _poly(f::Paths.Straight{T}, s::Paths.CPWShortTermination) where {T}
     return [round1(poly1), round2(poly2)]
 end
 
+function to_polygons(f::Paths.Segment{T}, s::Paths.CPWShortTermination; kwargs...) where {T}
+    return to_polygons.(_poly(f, s); kwargs...)
+end
+
+# Disambiguate from compound fallback
 function to_polygons(
-    f::Paths.Straight{T},
+    f::Paths.CompoundSegment{T},
     s::Paths.CPWShortTermination;
     kwargs...
 ) where {T}
@@ -144,6 +158,29 @@ function _poly(f::Paths.Straight{T}, s::Paths.TraceTermination) where {T}
     )
 end
 
-function to_polygons(f::Paths.Straight{T}, s::Paths.TraceTermination; kwargs...) where {T}
+function to_polygons(f::Paths.Segment{T}, s::Paths.TraceTermination; kwargs...) where {T}
+    return to_polygons(_poly(f, s); kwargs...)
+end
+
+# Disambiguate from compound fallback
+function to_polygons(
+    f::Paths.CompoundSegment{T},
+    s::Paths.TraceTermination;
+    kwargs...
+) where {T}
     return to_polygons(_poly(f, s); kwargs...)
 end
+
+## Generic segments—just draw as though straight
+function _poly(
+    f::Paths.Segment{T},
+    s::Union{Paths.TraceTermination, Paths.CPWOpenTermination, Paths.CPWShortTermination}
+) where {T}
+    straight = if s.initial
+        p = p1(f) - pathlength(f) * Point(cos(α1(f)), sin(α1(f)))
+        Paths.Straight{T}(pathlength(f), p, α1(f))
+    else
+        Paths.Straight{T}(pathlength(f), p0(f), α0(f))
+    end
+    return _poly(straight, s)
+end

Diff for: src/solidmodels/render.jl

@@ -327,8 +327,13 @@ end
 # Note: this is called during SolidModel rendering after flattening, so we don't worry about decorations
 # Similarly generic tapers have been resolved
 
-# Fallback: use to_polygons
-function to_primitives(::SolidModel, f::Paths.Segment, s::Paths.Style; kwargs...)
+# Fallback: use pathtopolys to get CurvilinearPolygons
+function to_primitives(
+    ::SolidModel,
+    f::Paths.Segment{T},
+    s::Paths.Style;
+    kwargs...
+) where {T}
     return pathtopolys(f, s; kwargs...)
 end
 
@@ -342,10 +347,10 @@ function to_primitives(
     return vcat(to_primitives.(sm, f.segments, s.styles; kwargs...)...)
 end
 
-# Terminations are only used with Straight and generate one or two [Rounded] Polygons
+# Terminations generate up to two [Rounded] Polygons
 function to_primitives(
     sm::SolidModel,
-    seg::Paths.Straight{T},
+    seg::Paths.Segment{T},
     sty::Union{Paths.TraceTermination, Paths.CPWOpenTermination, Paths.CPWShortTermination};
     kwargs...
 ) where {T}

Diff for: test/test_render.jl

@@ -694,12 +694,12 @@ end
 
             # Test Layout.jl#68
             els = initial ? reverse(elements(c)) : elements(c)
+            pts_approx(el) = [round.(pt, digits=9) for pt in ustrip.(nm, points(el))]
             # First and second element should be CPW polygons
-            straight_points = Set(reduce(vcat, points.(els[1:2])))
+            straight_points = Set(reduce(vcat, pts_approx.(els[1:2])))
 
             # Third element will be the terminating polygon
-            termination_points = Set(points(els[3]))
-
+            termination_points = Set(pts_approx(els[3]))
             # Test that there are four points in common with CPW polygons and terminating polygon
             @test length(intersect(straight_points, termination_points)) == 4
 
@@ -787,6 +787,43 @@ end
         terminate!(pa, gap=0μm, rounding=1μm)
         c = Cell("test", nm)
         render!(c, pa, GDSMeta())
+
+        # Termination with rounding on curve
+        # open
+        pa = Path(nm)
+        turn!(pa, 90°, 100μm, Paths.CPW(10μm, 6μm))
+        terminate!(pa, rounding=3μm)
+        terminate!(pa, rounding=3μm, initial=true)
+        @test iszero(α0(pa))
+        @test p0(pa) == Point(-6, 0)μm
+        @test α1(pa) ≈ 90°
+        @test p1(pa) ≈ Point(100, 106)μm
+        c = Cell("test", nm)
+        render!(c, pa, GDSMeta())
+        @test bounds(c).ll.y < -11μm # Drawn as though straight, extends at slight angle
+        # short
+        pa = Path(nm)
+        turn!(pa, pi / 2, 100μm, Paths.CPW(10μm, 6μm))
+        terminate!(pa, gap=0μm, rounding=3μm)
+        terminate!(pa, gap=0μm, rounding=3μm, initial=true)
+        @test iszero(α0(pa))
+        @test p0(pa) == Point(0, 0)μm
+        @test α1(pa) ≈ 90°
+        @test p1(pa) ≈ Point(100, 100)μm
+        c = Cell("test", nm)
+        render!(c, pa, GDSMeta())
+
+        # Same with trace
+        pa = Path(nm)
+        turn!(pa, pi / 2, 100μm, Paths.Trace(10μm))
+        terminate!(pa, rounding=5μm)
+        terminate!(pa, rounding=5μm, initial=true)
+        @test iszero(α0(pa))
+        @test p0(pa) == Point(0, 0)μm
+        @test α1(pa) ≈ 90°
+        @test p1(pa) ≈ Point(100, 100)μm
+        c = Cell("test", nm)
+        render!(c, pa, GDSMeta())
     end
 
     @testset "Overlays" begin

Diff for: test/test_solidmodel.jl

@@ -189,6 +189,16 @@ import DeviceLayout.SolidModels.STP_UNIT
         isapprox.([x0, y0, x1, y1], ustrip.(STP_UNIT, [x0d, y0d, x1d, y1d]), atol=1e-6)
     )
 
+    # Termination on curve is still drawn with circular arcs
+    cs = CoordinateSystem("test", nm)
+    pa = Path(0nm, 0nm)
+    turn!(pa, 90°, 10μm, Paths.SimpleCPW(5μm, 2μm))
+    terminate!(pa; rounding=2.5μm)
+    place!(cs, pa, SemanticMeta(:test))
+    sm = SolidModel("test"; overwrite=true)
+    render!(sm, cs)
+    @test length(SolidModels.gmsh.model.occ.getEntities(0)) < 20 # would be >100 points if discretized
+
     # Compound segment/style
     cs = CoordinateSystem("test", nm)
     pa = Path(0nm, 0nm)

Diff for: test/tests.jl

@@ -633,6 +633,7 @@ end
         @test Paths.gap(sty) === 6000.0nm
         @test Paths.trace(sty) === 10000.0nm
         @test pa[1].sty isa Paths.CPWOpenTermination
+        @test bounds(pa).ll ≈ -Point(pa[1].sty.gap, Paths.extent(pa[1].sty))
 
         pa = Path(μm)
         sty = launch!(pa, trace1=4.2μm, gap1=3801nm)