Update app.py

app.py

@@ -459,7 +459,13 @@ def make_figure(d: int,
 
     switch_vertices = set()
     if switch_active and sw_s is not None and sw_e is not None and path:
-        switch_vertices = set(path[sw_s:sw_e + 1])
+        is_closed = (len(path) >= 2 and path[0] == path[-1])
+        cycle = path[:-1] if is_closed else path[:]
+        n = len(cycle)
+        if n > 0:
+            dist = (sw_e - sw_s) % n
+            switch_vertices = {cycle[(sw_s + i) % n] for i in range(dist + 1)}
+
 
     
     # ---------- neighbors of path vertices ----------
@@ -586,22 +592,29 @@ def make_figure(d: int,
             )
 
     # ---------- highlight switch-dims selection edges ----------
-    if switch_active and sw_s is not None and sw_e is not None and sw_e > sw_s:
-        for i in range(sw_s, sw_e):
-            a, b = path[i], path[i + 1]
-            x1, y1 = pos[a]
-            x2, y2 = pos[b]
-            edge_traces.append(
-                go.Scatter(
-                    x=[x1, x2],
-                    y=[y1, y2],
-                    mode="lines",
-                    line=dict(width=max(2, edge_w * 3), color="#DC2626"),
-                    opacity=1.0,
-                    hoverinfo="skip",
-                    name="switch dims selection",
+    if switch_active and sw_s is not None and sw_e is not None and path:
+        is_closed = (len(path) >= 2 and path[0] == path[-1])
+        cycle = path[:-1] if is_closed else path[:]
+        n = len(cycle)
+        if n > 0:
+            dist = (sw_e - sw_s) % n
+            for k in range(dist):
+                a = cycle[(sw_s + k) % n]
+                b = cycle[(sw_s + k + 1) % n]
+                x1, y1 = pos[a]
+                x2, y2 = pos[b]
+                edge_traces.append(
+                    go.Scatter(
+                        x=[x1, x2],
+                        y=[y1, y2],
+                        mode="lines",
+                        line=dict(width=max(2, edge_w * 3), color="#DC2626"),
+                        opacity=1.0,
+                        hoverinfo="skip",
+                        name="switch dims selection",
+                    )
                 )
-            )
+
 
     
     # ---------- nodes ----------
@@ -1057,57 +1070,82 @@ def update_path(clickData,
         # If we're in switch-dims mode, vertex clicks define exactly 3 consecutive vertices
         if switchsel.get("active") and isinstance(cd, (int, float)):
             vid = int(cd)
-            idx = index_in_path(path, vid)
-            if idx is None:
+
+            # Work on a cycle if path is explicitly closed
+            is_closed = (len(path) >= 2 and path[0] == path[-1])
+            cycle = path[:-1] if is_closed else path[:]
+            n = len(cycle)
+
+            if n < 3:
+                return path, subsel, {"active": False, "start_idx": None, "end_idx": None}
+
+            # In a proper cycle representation, vertices are unique
+            try:
+                idx = cycle.index(vid)
+            except ValueError:
                 return path, subsel, switchsel
-        
+
             s = switchsel.get("start_idx")
             e = switchsel.get("end_idx")
-        
+
             # first vertex
             if s is None:
                 return path, subsel, {"active": True, "start_idx": idx, "end_idx": idx}
-        
+
             if e is None:
                 e = s
-        
-            # must extend consecutively forward: idx == e+1
-            if idx == e + 1 and (idx - s) <= 2:
-                new_sel = {"active": True, "start_idx": s, "end_idx": idx}
-        
+
+            # distance forward on the cycle (0,1,2,...)
+            dist = (e - s) % n
+
+            # must extend consecutively forward (with wrap)
+            expected = (e + 1) % n
+            if idx == expected and dist < 2:
+                new_e = idx
+                new_dist = (new_e - s) % n
+
                 # if we have 3 vertices selected: apply switch
-                if idx == s + 2:
-                    x = path[s]
-                    y = path[s + 1]
-                    z = path[s + 2]
-        
+                if new_dist == 2:
+                    x = cycle[s]
+                    y = cycle[(s + 1) % n]
+                    z = cycle[(s + 2) % n]
+
                     a = edge_dimension(x, y)
                     b = edge_dimension(y, z)
                     if a is None or b is None:
-                        # not a valid 2-edge segment, exit mode
                         return path, subsel, {"active": False, "start_idx": None, "end_idx": None}
-        
+
                     # new middle vertex to traverse b then a
                     y2 = x ^ (1 << b)
-        
-                    # optional safety: don't create duplicates elsewhere in the path
-                    if y2 in set(path) and y2 not in {x, y, z}:
+
+                    # verify it actually reaches z by traversing a next
+                    if edge_dimension(y2, z) != a:
                         return path, subsel, {"active": False, "start_idx": None, "end_idx": None}
-        
-                    new_path = path[:]
-                    new_path[s + 1] = y2
+
+                    # avoid creating duplicates in the cycle (allow x,z)
+                    if y2 in set(cycle) and y2 not in {x, z}:
+                        return path, subsel, {"active": False, "start_idx": None, "end_idx": None}
+
+                    cycle2 = cycle[:]
+                    cycle2[(s + 1) % n] = y2
+
+                    new_path = cycle2 + [cycle2[0]] if is_closed else cycle2
                     return new_path, subsel, {"active": False, "start_idx": None, "end_idx": None}
-        
-                return path, subsel, new_sel
-        
+
+                return path, subsel, {"active": True, "start_idx": s, "end_idx": new_e}
+
             # allow shrinking by clicking current end
             if idx == e:
-                new_e = e - 1 if e > s else s
+                if e != s:
+                    new_e = (e - 1) % n
+                else:
+                    new_e = s
                 return path, subsel, {"active": True, "start_idx": s, "end_idx": new_e}
-        
+
             # otherwise ignore
             return path, subsel, switchsel
 
+
         # If we're in subpath selection mode, vertex clicks define (start_idx, end_idx)
         if subsel.get("active") and isinstance(cd, (int, float)):
             vid = int(cd)