fix: Account for splits in BSpline conversion and reflection (#87)

* fix: Account for splits in BSpline conversion and reflection

* Broadcast assignment instead of unsafe map in BSpline transforms

Author: gpeairs

CHANGELOG.md

@@ -4,6 +4,11 @@ The format of this changelog is based on
 [Keep a Changelog](https://keepachangelog.com/), and this project adheres to
 [Semantic Versioning](https://semver.org/).
 
+## Upcoming
+
+  - Fixed incorrect conversion and reflection of split BSplines
+  - Added FAQ entry about MeshSized/OptionalEntity styling on Paths
+
 ## 1.4.2 (2025-07-16)
 
   - Removed invalid keyword constructor without type parameters for `@compdef`-ed components with type parameters, so it can be overridden without warnings

src/paths/paths.jl

@@ -49,6 +49,7 @@ import DeviceLayout:
     Meta,
     PointHook,
     Polygons,
+    Reflection,
     Rotation,
     ScaledIsometry,
     StructureReference,

src/paths/segments/bspline.jl

@@ -87,7 +87,7 @@ Translate the interpolated segment so its initial point is `p`.
 function setp0!(b::BSpline, p::Point)
     # Adjust interpolation points
     translate = Translation(p - p0(b))
-    map!(translate, b.p, b.p)
+    b.p .= translate.(b.p)
 
     return _update_interpolation!(b)
 end
@@ -101,7 +101,7 @@ setα0!(b::BSpline, α0′) = begin
     # Adjust interpolation points
     rotate = Rotation(α0′ - α0(b))
     rotate_interp = Translation(p0(b)) ∘ rotate ∘ Translation(-p0(b))
-    map!(rotate_interp, b.p, b.p)
+    b.p .= rotate_interp.(b.p)
 
     # Adjust tangents
     b.t0 = rotate(b.t0)
@@ -121,19 +121,16 @@ Change the "handedness" of `b` by reflecting across the tangent at the start poi
 """
 function change_handedness!(b::BSpline)
     # Perform reflection of points across line
-    axis_dir = b.t0 / norm(b.t0)
-    dx = axis_dir.x
-    dy = axis_dir.y
-    reflection = LinearMap(StaticArrays.@SMatrix [(dx^2-dy^2) 2dx*dy; 2dx*dy (dy^2-dx^2)])
-    reflect_interp = Translation(p0(b)) ∘ reflection ∘ Translation(-p0(b))
-    map!(reflect_interp, b.p, b.p)
-
+    axis_dir = Point(cos(α0(b)), sin(α0(b)))
+    refl = Reflection(axis_dir)
     # Adjust tangents
-    t1_reflected = Rotation(-(α1(b) - α0(b)))(axis_dir) * norm(b.t1)
-    b.t1 = t1_reflected
+    b.t0 = refl(b.t0)
+    b.t1 = refl(b.t1)
+    b.p = Reflection(axis_dir; through_pt=p0(b)).(b.p)
 
     # Effective final angle at 0 and 1
-    b.α1 = α0(b) - (α1(b) - α0(b))
+    b.α0 = rotated_direction(b.α0, refl)
+    b.α1 = rotated_direction(b.α1, refl)
 
     return _update_interpolation!(b)
 end
@@ -163,8 +160,21 @@ function _update_interpolation!(b::BSpline)
 end
 
 convert(::Type{BSpline{T}}, x::BSpline{T}) where {T} = x
-convert(::Type{BSpline{T}}, x::BSpline{S}) where {T, S} =
-    BSpline(convert.(Point{T}, x.p), convert(Point{T}, x.t0), convert(Point{T}, x.t1))
+function convert(::Type{BSpline{T}}, b::BSpline{S}) where {T, S}
+    # Use true t range for interpolations defined by points that have been scaled out of [0,1]
+    tmin = b.r.ranges[1][1]
+    tmax = b.r.ranges[1][end]
+    p = convert.(Point{T}, b.p)
+    t0 = convert(Point{T}, b.t0)
+    t1 = convert(Point{T}, b.t1)
+    p0 = convert(Point{T}, b.p0)
+    p1 = convert(Point{T}, b.p1)
+    r = Interpolations.scale(
+        interpolate(p, Interpolations.BSpline(Cubic(NeumannBC(t0, t1)))),
+        range(tmin, stop=tmax, length=length(p))
+    )
+    return BSpline(p, t0, t1, r, p0, p1, b.α0, b.α1)
+end
 convert(::Type{Segment{T}}, x::BSpline) where {T} = convert(BSpline{T}, x)
 copy(b::BSpline) = BSpline(copy(b.p), b.t0, b.t1, b.r, b.p0, b.p1, b.α0, b.α1)
 

test/test_bspline.jl

@@ -76,6 +76,11 @@
     @test pathlength(a1) ≈ 500μm rtol = 1e-9
     @test pathlength(a2) ≈ pathlength(b) - 500μm rtol = 1e-9
 
+    # Convert after split
+    a2_conv = convert(Paths.BSpline{typeof(1.0mm)}, a2)
+    @test p0(a2_conv) ≈ p0(a2)
+    @test p1(a2_conv) ≈ p1(a2)
+
     # Splice
     b4 = Paths.BSpline(
         [Point(-100, -200), Point(200, 200), Point(100, -300), Point(500, 0)],
@@ -100,6 +105,33 @@
     # Check an arbitrary point to make sure we have just rotated and translated a curve segment
     @test (pa2[1].seg)(Paths.t_to_arclength(pa2[1].seg, 0.2)) ≈
           splice_transform(b4.r(tsplit2 + (1 - tsplit2) * 0.2)) atol = 1e-9
+
+    # Also check reflection after splitting
+    # And splitting with non-preferred unit
+    pa3 = Path(10.0μm, 12.0μm; metadata=GDSMeta())
+    turn!(pa3, 60°, 100μm, Paths.Trace(10μm))
+    bspline!(pa3, [Point(200μm, 200μm)], 30°; endpoints_speed=200μm)
+    splice!(pa3, 2, split(pa3[2], 100μm))
+    cs = CoordinateSystem("test")
+    addref!(cs, pa3, Point(-20, -20)μm, rot=45°, xrefl=true)
+    tr = transformation(refs(cs)[1])
+    csflat = flatten(cs)
+    # Endpoints
+    @test p0(elements(csflat)[2].seg) ≈ tr(p0(pa3[2].seg))
+    @test p1(elements(csflat)[2].seg) ≈ tr(p1(pa3[2].seg))
+    @test p0(elements(csflat)[3].seg) ≈ tr(p1(pa3[2].seg))
+    @test p1(elements(csflat)[3].seg) ≈ tr(p1(pa3[3].seg))
+    @test α0(elements(csflat)[2].seg) ≈ rotated_direction(α0(pa3[2].seg), tr)
+    @test α1(elements(csflat)[2].seg) ≈ rotated_direction(α1(pa3[2].seg), tr)
+    @test α0(elements(csflat)[3].seg) ≈ rotated_direction(α1(pa3[2].seg), tr)
+    @test α1(elements(csflat)[3].seg) ≈ rotated_direction(α1(pa3[3].seg), tr)
+    # Arbitrary points
+    @test elements(csflat)[2].seg(50μm) ≈ tr(pa3[2].seg(50μm))
+    @test elements(csflat)[3].seg(50μm) ≈ tr(pa3[3].seg(50μm))
+    @test direction(elements(csflat)[2].seg, 50μm) ≈
+          rotated_direction(direction(pa3[2].seg, 50μm), tr)
+    @test direction(elements(csflat)[3].seg, 50μm) ≈
+          rotated_direction(direction(pa3[3].seg, 50μm), tr)
 end
 
 @testset "BSpline approximation" begin