diff --git a/src/kicoil/geometry.py b/src/kicoil/geometry.py
index fedf483..c092f47 100644
--- a/src/kicoil/geometry.py
+++ b/src/kicoil/geometry.py
@@ -142,6 +142,8 @@ class CircleShape(Shape):
     def project_point(self, r, a, r_ref=None):
         return cos(a) * r, sin(a) * r
 
+    def map_angle(self, a):
+        return a
 
     def offset_exterior(self, margin):
         r = self.outer_radius + margin
@@ -180,6 +182,12 @@ class OffsetShape(Shape):
         return points, arm_length, angle_refs
 
 
+    def map_angle(self, a):
+        a_new = self.sk.map_angle(a / (2*pi), self.outer_radius, self.inner_radius)
+        print(f'NEW MAPPED {a:.3f} to {a_new:.3f}')
+        return a_new * 2 * pi
+
+
     def project_point(self, r, a, r_ref=None):
         # Skeletonator uses a t coordinate from 0 - 1 per revolution instead of a radian angle.
         return self.sk.project_point(a/(2*pi) % 1, r, r_ref=r_ref)
@@ -588,7 +596,7 @@ class PlanarInductor():
             points_layer0, refs_layer0 = arms_layers[0][i]
             points_layer1, refs_layer1 = arms_layers[1][(i - self.turns) % self.twists]
             
-            xv, yv = self.shape.project_point(r, start_angle, r_ref=refs_layer0[0])
+            xv, yv = self.shape.project_point(r, self.shape.map_angle(start_angle), r_ref=refs_layer0[0])
 
             footprint.lines.append(kicad.make_line(*points_layer0[0], xv, yv, self.trace_width, self.layer_pair[0]))
             footprint.lines.append(kicad.make_line(*points_layer1[-1], xv, yv, self.trace_width, self.layer_pair[1]))
diff --git a/src/kicoil/skeletonator.py b/src/kicoil/skeletonator.py
index 68fdb93..b4701da 100644
--- a/src/kicoil/skeletonator.py
+++ b/src/kicoil/skeletonator.py
@@ -245,6 +245,39 @@ class Skeletonator:
             arcs.append(arc)
             points.append(pt)
         return arcs, points
+
+    def map_angle(self, t, r1, r2):
+        r_ref = min(r1, r2)
+        _ic_arcs, inner_circumference = self.map_circumference(r_ref)
+        inner_circumference_sum = sum(math.dist(p1, p2) for p1, p2 in edge_cycle(inner_circumference))
+
+        angle = 0
+        point_angles = [0]
+        for p1, p2 in edge_cycle(inner_circumference):
+            edge_angle = math.dist(p1, p2) / inner_circumference_sum
+            angle += edge_angle
+            point_angles.append(angle)
+
+        _oc_arcs, outer_circumference = self.map_circumference(max(r1, r2))
+        outer_circumference_sum = sum(math.dist(p1, p2) for p1, p2 in edge_cycle(outer_circumference))
+
+        angle = 0
+        point_angles_outer = [0]
+        for p1, p2 in edge_cycle(outer_circumference):
+            edge_angle = math.dist(p1, p2) / outer_circumference_sum
+            angle += edge_angle
+            point_angles_outer.append(angle)
+
+        t_map_int = math.floor(t)
+        t %= 1.0
+           
+        for ia1, ia2, oa1, oa2 in zip(point_angles, point_angles[1:] + [1], point_angles_outer, point_angles_outer[1:] + [1]):
+           
+            if approx_in_range(t, oa1, oa2):
+                if oa1 == oa2:
+                    return t_map_int + ia2
+                else:
+                    return t_map_int + ia1 + (ia2 - ia1) * ((t - oa1) / (oa2 - oa1))
     
     def do_spiral(self, t1, t2, r1=None, r2=None):
         print(f'  {t1=:.5f} {t2=:.5f} {r1=:.2f} {r2=:.2f}')
@@ -270,36 +303,13 @@ class Skeletonator:
         point_angles = [0]
         for p1, p2 in edge_cycle(inner_circumference):
             edge_angle = math.dist(p1, p2) / inner_circumference_sum
+            angle += edge_angle
             point_angles.append(angle)
-            angle += edge_angle
 
-        _oc_arcs, outer_circumference = self.map_circumference(max(r1, r2))
-        outer_circumference_sum = sum(math.dist(p1, p2) for p1, p2 in edge_cycle(outer_circumference))
-
-        angle = 0
-        point_angles_outer = [0]
-        for p1, p2 in edge_cycle(outer_circumference):
-            edge_angle = math.dist(p1, p2) / outer_circumference_sum
-            point_angles_outer.append(angle)
-            angle += edge_angle
-
-        for ia1, ia2, oa1, oa2 in zip(point_angles, point_angles[1:] + [1], point_angles_outer, point_angles_outer[1:] + [1]):
-            t_map = t1 if r1 > r2 else t2
-            t_map_int = math.floor(t_map)
-            t_map %= 1.0
-            
-            if approx_in_range(t_map, oa1, oa2):
-                if oa1 == oa2:
-                    t_mapped = ia1
-                else:
-                    t_mapped = ia1 + (ia2 - ia1) * ((t_map - oa1) / (oa2 - oa1))
-            
-                #if r1 > r2:
-                    #t1 = t_mapped + t_map_int
-                #else:
-                    #t2 = t_mapped + t_map_int
-                print(f'mapped {t_map=:.3f} to {t_mapped=:.3f}')
-                break
+        if r1 > r2:
+            t1 = self.map_angle(t1, r1, r2)
+        else:
+            t2 = self.map_angle(t2, r1, r2)
 
         turn_angles = range(math.floor(t1), math.ceil(t2) + 1)
         for t_start, t_end in zip(turn_angles, turn_angles[1:]):