gui.py

import tkinter as tk
from tkinter import ttk
from artGalleryProblem import Vertex, HalfEdge, Face, DCEL, generate_random_vertices, build_polygon, build_polygon_with_holes, trapezoidalize, monotone_partitioning, triangulate_polygon, construct_dual_graph, three_color_triangulation, get_minimum_guard_set, visualize_polygon

class PolygonGUI:
    def __init__(self, root, width=1500, height=730):
        self.root = root
        self.root.title("Polygon GUI")

        # Create notebook (tabs)
        self.notebook = ttk.Notebook(root)
        self.notebook.pack(fill='both', expand=True)

        # Tab 1: Polygon drawing
        self.tab_draw = ttk.Frame(self.notebook)
        self.notebook.add(self.tab_draw, text="Draw/Edit Polygon")

        # Canvas inside tab 1
        self.canvas = tk.Canvas(self.tab_draw, width=width, height=height, bg="white")
        self.canvas.pack()

        # Polygon data
        self.polygon = DCEL()
        self.trapezoidalized_polygon = None
        self.monotone_polygons = None
        self.triangulated_polygon = None
        self.selected_vertex = None
        self.highlighted_vertices = []
        # Add new data structures for holes
        self.outer_boundary = DCEL()  # DCEL for outer boundary
        self.holes = []  # list of DCELs, each representing a hole
        self.current_hole = None  # stores DCEL of current hole being drawn
        self.drawing_hole = False  # flag to indicate if currently drawing a hole
        self.guard_positions = []  # stores positions of guards after three-coloring

        self.outer_boundary_vertices_copy = []  # stores vertices of outer polygon
        self.holes_vertices_copy = []  # list of lists, each inner list stores vertices of one hole
        self.dummy_vertices = {}
        self.visibility_regions = []  # list of lists, each inner list stores visibility polygon for one guard

        # Buttons frame inside tab 1
        button_frame = tk.Frame(self.tab_draw)
        button_frame.pack()

        tk.Label(button_frame, text="N:").pack(side="left")
        self.n_entry = tk.Entry(button_frame, width=5)
        self.n_entry.pack(side="left")
        tk.Button(button_frame, text="Generate Random Polygon", command=self.generate_random_polygon).pack(side="left")
        tk.Button(button_frame, text="Clear", command=self.clear).pack(side="left")
        tk.Button(button_frame, text="Run Trapezoidalization", command=self.run_trapezoidalization).pack(side="left")
        tk.Button(button_frame, text="Run Monotone Partitioning", command=self.run_monotone_partitioning).pack(side="left")
        tk.Button(button_frame, text="Run Triangulation", command=self.run_triangulation).pack(side="left")
        tk.Button(button_frame, text="Run Dual Graph Construction", command=self.run_dual_graph_construction).pack(side="left")
        tk.Button(button_frame, text="Show guards", command=self.run_three_coloring).pack(side="left")
        # tk.Button(button_frame, text="Print DCEL", command=self.print_dcel).pack(side="left")
        tk.Button(button_frame, text="Start New Hole", command=self.start_new_hole).pack(side="left")
        tk.Button(button_frame, text="Finish Hole", command=self.finish_hole).pack(side="left")
        tk.Button(button_frame, text="Save Polygon", command=self.close_polygon).pack(side="left")
        tk.Button(button_frame, text="Show Visibility Region", command=self.show_visibility_regions).pack(side="left")

        # Add this new Text widget for displaying DCEL info
        self.text_frame = tk.Frame(self.tab_draw)
        self.text_frame.pack(fill='both', expand=True)
        
        self.text_widget = tk.Text(self.text_frame, height=10)
        self.text_widget.pack(side="left", fill='both', expand=True)
        
        # Add scrollbar
        scrollbar = tk.Scrollbar(self.text_frame)
        scrollbar.pack(side="right", fill='y')
        
        # Configure the scrollbar
        self.text_widget.config(yscrollcommand=scrollbar.set)
        scrollbar.config(command=self.text_widget.yview)

        # Mouse bindings for drawing
        self.canvas.bind("<Button-1>", self.handle_left_click)  # left-click: vertex/edge
        # self.canvas.bind("<Button-3>", self.close_polygon)      # right-click: close polygon

        # Edges and Vertices that should not be animated
        self.non_animated_edges = set()
        self.non_animated_vertices = set()

    def print_dcel(self):
        """Print the current DCEL structure"""
        if self.polygon:
            self.text_widget.delete(1.0, tk.END)  # Clear previous text
            self.text_widget.insert(tk.END, self.polygon.print_structure())
        else:
            self.text_widget.delete(1.0, tk.END)
            self.text_widget.insert(tk.END, "No polygon exists yet!")

    # def make_polygon_in_GUI(self):
    #     self.canvas.delete("all")
        
    #     for v in self.polygon.vertices:
    #         self.draw_vertex(v, "red")
        
    #     for he in self.polygon.half_edges:
    #         self.draw_temp_edge(he.origin, he.twin.origin, "black")

    # def save_polygon_with_holes(self):
    #     """Save the polygon with holes and construct DCEL"""
    #     if len(self.outer_boundary) >= 3:
    #         # Draw closing edge for outer boundary if not already done
    #         self.draw_temp_edge(self.outer_boundary[-1], self.outer_boundary[0], "black")
            
    #         # Print statistics
    #         print(f"Outer boundary: {len(self.outer_boundary)} vertices")
    #         print(f"Number of holes: {len(self.holes)}")
    #         for i, hole in enumerate(self.holes):
    #             print(f"Hole {i+1}: {len(hole)} vertices")

    #         # Construct DCEL with holes
    #             self.polygon, self.dummy_vertices = build_polygon_with_holes(self.outer_boundary, self.holes)
    #             self.make_polygon_in_GUI()
                
    #         # try:
    #         #     # Construct DCEL with holes
    #         #     self.polygon = build_polygon_with_holes(self.outer_boundary, self.holes)
    #         #     self.make_polygon_in_GUI()
                
    #         # except Exception as e:
    #         #     self.text_widget.delete(1.0, tk.END)
    #         #     self.text_widget.insert(tk.END, f"Error creating polygon with holes: {str(e)}")
    #     else:
    #         self.text_widget.delete(1.0, tk.END)
    #         self.text_widget.insert(tk.END, "Outer boundary must have at least 3 vertices!")


    # def save_polygon_with_holes(self):
    #     """Save the polygon with holes and construct DCEL"""
    #     if len(self.outer_boundary) >= 3:
    #         # Draw closing edge for outer boundary if not already done
    #         self.draw_temp_edge(self.outer_boundary[-1], self.outer_boundary[0], "black")
            
    #         # Print statistics
    #         print(f"Outer boundary: {len(self.outer_boundary)} vertices")
    #         print(f"Number of holes: {len(self.holes)}")
    #         for i, hole in enumerate(self.holes):
    #             print(f"Hole {i+1}: {len(hole)} vertices")
                
    #         try:
    #             # Construct DCEL with holes
    #             self.polygon = build_polygon_with_holes(self.outer_boundary, self.holes)
                
    #         except Exception as e:
    #             self.text_widget.delete(1.0, tk.END)
    #             self.text_widget.insert(tk.END, f"Error creating polygon with holes: {str(e)}")
    #     else:
    #         self.text_widget.delete(1.0, tk.END)
    #         self.text_widget.insert(tk.END, "Outer boundary must have at least 3 vertices!")

    def generate_random_polygon(self):
        """Generate a random convex polygon with user-specified N."""
        self.clear()
        try:
            n = int(self.n_entry.get())
        except ValueError:
            return

        self.vertices = generate_random_vertices(n)
        self.polygon = build_polygon(self.vertices, order_vertices=True)

        self.draw_polygon(self.polygon, is_polygon_construction=True)

    def add_edge(self, v1, v2, is_hole=False):
        """Add an edge between two vertices in the DCEL."""
        new_edge = HalfEdge()
        new_edge_twin = HalfEdge()

        v1.incident_edge = new_edge

        new_edge.origin = v1
        new_edge_twin.origin = v2

        new_edge.twin = new_edge_twin
        new_edge_twin.twin = new_edge

        if is_hole:
            self.draw_edge(new_edge, "blue")
            self.current_hole.half_edges.extend([new_edge, new_edge_twin])
        else:
            self.draw_edge(new_edge, "black")
            self.outer_boundary.half_edges.extend([new_edge, new_edge_twin])

    def handle_left_click(self, event):
        """Modified to handle holes and prevent duplicate nearby vertices"""
        x, y = event.x, -event.y
        RADIUS = 10  # Distance threshold for considering vertices as "same"
        clicked_vertex = None
        
        # Check vertices in current polygon only
        vertices_to_check = self.outer_boundary.vertices if not self.drawing_hole else self.current_hole.vertices
        
        # Check for nearby existing vertices
        for v in vertices_to_check:
            if (v.x - x)**2 + (v.y - y)**2 <= RADIUS**2:
                clicked_vertex = v
                if not self.drawing_hole:
                    self.add_edge(self.outer_boundary.vertices[-1], clicked_vertex)
                else: 
                    self.add_edge(clicked_vertex, self.current_hole.vertices[-1], is_hole=True)
                break
        
        # If no nearby vertex found, create new one
        if clicked_vertex is None:
            clicked_vertex = Vertex(x, y)
            
            if not self.drawing_hole:
                # Adding vertex to outer boundary
                self.outer_boundary.vertices.append(clicked_vertex)
                self.draw_vertex(clicked_vertex)
                if len(self.outer_boundary.vertices) > 1:
                    self.add_edge(self.outer_boundary.vertices[-2], clicked_vertex)
            else:
                # Adding vertex to current hole
                self.current_hole.vertices.append(clicked_vertex)
                self.draw_vertex(clicked_vertex, "blue")
                if len(self.current_hole.vertices) > 1:
                    self.add_edge(clicked_vertex, self.current_hole.vertices[-2], is_hole=True)

    def start_new_hole(self):
        """Start drawing a new hole"""
        self.drawing_hole = True
        self.current_hole = DCEL()
        
    def finish_hole(self):
        """Finish current hole and add to holes list"""
        if self.current_hole and len(self.current_hole.vertices) >= 3:
            # Draw closing edge
            # self.add_edge(self.current_hole.vertices[-1], self.current_hole.vertices[0], is_hole=True)
            self.holes.append(self.current_hole)
            self.current_hole = None
            self.drawing_hole = False
    
    # def draw_temp_edge(self, v1, v2, color):
    #     """Draw temporary edge between vertices"""
    #     self.canvas.create_line(v1.x, -v1.y, v2.x, -v2.y, fill=color, width=2)

    # def save_polygon_with_holes(self):
    #     """Save the polygon with holes and construct DCEL"""
    #     if len(self.outer_boundary) >= 3:
    #         # Draw closing edge for outer boundary
    #         self.draw_temp_edge(self.outer_boundary[-1], self.outer_boundary[0], "black")
            
    #         try:
    #             # Construct DCEL with holes
    #             self.polygon = build_polygon_with_holes(self.outer_boundary, self.holes)
                
    #             if self.polygon:
    #                 # Update text widget with DCEL information
    #                 self.text_widget.delete(1.0, tk.END)
    #                 self.text_widget.insert(tk.END, "Polygon with holes constructed:\n")
    #                 self.text_widget.insert(tk.END, f"Outer boundary: {len(self.outer_boundary)} vertices\n")
    #                 self.text_widget.insert(tk.END, f"Number of holes: {len(self.holes)}\n")
    #                 for i, hole in enumerate(self.holes):
    #                     self.text_widget.insert(tk.END, f"Hole {i+1}: {len(hole)} vertices\n")
    #                 self.text_widget.insert(tk.END, "\nDCEL Structure:\n")
    #                 self.text_widget.insert(tk.END, self.polygon.print_structure())
    #             else:
    #                 self.text_widget.delete(1.0, tk.END)
    #                 self.text_widget.insert(tk.END, "Failed to construct DCEL!")
                    
    #         except Exception as e:
    #             self.text_widget.delete(1.0, tk.END)
    #             self.text_widget.insert(tk.END, f"Error creating polygon with holes: {str(e)}")
    #     else:
    #         self.text_widget.delete(1.0, tk.END)
    #         self.text_widget.insert(tk.END, "Outer boundary must have at least 3 vertices!")

    def close_polygon(self):
        """Close the polygon and add faces (if user right-clicks)."""
        #Initualize copies for visualization
        self.outer_boundary_vertices_copy = self.outer_boundary.vertices.copy()
        self.holes_vertices_copy = [hole.vertices.copy() for hole in self.holes]

        # Outer Boundary
        # Construct Faces
        interior_face = Face()
        exterior_face = Face()
        self.outer_boundary.faces = [exterior_face, interior_face]

        interior_face.outer_component = self.outer_boundary.half_edges[0] if len(self.outer_boundary.half_edges) > 0 else None
        exterior_face.outer_component = self.outer_boundary.half_edges[0].twin if len(self.outer_boundary.half_edges) > 0 else None

        # Connect Boundary Edges properly in CCW Order
        for i in range(len(self.outer_boundary.half_edges)//2): # alternate edges are accessed
            edge = self.outer_boundary.half_edges[2*i]
            next_edge = self.outer_boundary.half_edges[2*((i+1) % (len(self.outer_boundary.half_edges)//2))]

            edge.next = next_edge
            edge.next.prev = edge
            edge.twin.prev = edge.next.twin
            edge.twin.prev.next = edge.twin

            edge.face = interior_face
            edge.twin.face = exterior_face

        # Connect Hole Edges Properly in CW Order
        for hole in self.holes:
            for i in range(len(hole.half_edges)//2): # alternate edges are accessed
                edge = hole.half_edges[2*i]
                prev_edge = hole.half_edges[2*((i+1) % (len(hole.half_edges)//2))]

                edge.prev = prev_edge
                edge.prev.next = edge
                edge.twin.next = edge.prev.twin
                edge.twin.next.prev = edge.twin

        if len(self.holes) == 0:
            self.polygon = self.outer_boundary
        else:
            # print("Outer Boundary:")
            # print(self.outer_boundary)
            # print(self.outer_boundary.print_structure())
            # for i in range(len(self.holes)):
            #     print(f"Hole {i}:")
            #     print(self.holes[i])
            #     print(self.holes[i].print_structure())
            self.polygon, self.dummy_vertices = build_polygon_with_holes(self.outer_boundary, self.holes)
            self.canvas.delete("all")
            self.draw_polygon(self.polygon, is_polygon_construction=True)

    def run_trapezoidalization(self):
        # self.canvas.delete("all")
        self.trapezoidalized_polygon, self.trapezoid_vertices, self.trapezoid_edges, self.left_helpers, self.right_helpers = trapezoidalize(self.polygon)
        self.draw_polygon(self.trapezoidalized_polygon, is_trapezoidalization=True)

    def run_monotone_partitioning(self):
        self.canvas.delete("all")
        if self.trapezoidalized_polygon is None:
            self.trapezoidalized_polygon, self.trapezoid_vertices, self.trapezoid_edges, self.left_helpers, self.right_helpers = trapezoidalize(self.polygon)
        self.monotone_polygons = monotone_partitioning(self.trapezoidalized_polygon, self.trapezoid_vertices, self.trapezoid_edges, self.left_helpers, self.right_helpers)
        self.draw_polygon(self.monotone_polygons)

    def run_triangulation(self):
        self.canvas.delete("all")
        if self.monotone_polygons is None:
            if self.trapezoidalized_polygon is None:
                self.trapezoidalized_polygon, self.trapezoid_vertices, self.trapezoid_edges, self.left_helpers, self.right_helpers = trapezoidalize(self.polygon)
            self.monotone_polygons = monotone_partitioning(self.trapezoidalized_polygon, self.trapezoid_vertices, self.trapezoid_edges, self.left_helpers, self.right_helpers)
        self.triangulated_polygon = triangulate_polygon(self.monotone_polygons)
        self.draw_polygon(self.triangulated_polygon)

    def run_dual_graph_construction(self):
        # self.canvas.delete("all")
        if self.triangulated_polygon is None:
            if self.monotone_polygons is None:
                if self.trapezoidalized_polygon is None:
                    self.trapezoidalized_polygon, self.trapezoid_vertices, self.trapezoid_edges, self.left_helpers, self.right_helpers = trapezoidalize(self.polygon)
                self.monotone_polygons = monotone_partitioning(self.trapezoidalized_polygon, self.trapezoid_vertices, self.trapezoid_edges, self.left_helpers, self.right_helpers)
            self.triangulated_polygon = triangulate_polygon(self.monotone_polygons)
        self.dual_graph = construct_dual_graph(self.triangulated_polygon, self.dummy_vertices)
        self.draw_dual_graph()

    def draw_vertex(self, v, color="red"):
        if v in self.dummy_vertices:
            return  # Skip drawing dummy vertices
        self.canvas.create_oval(v.x-4, -v.y-4, v.x+4, -v.y+4, fill=color)

        # # Add coordinate text slightly offset from the vertex
        # coord_text = f"({v.x}, {-v.y})"  # Note: we use -v.y since canvas y-coord is inverted
        # self.canvas.create_text(
        #     v.x + 15,  # Offset x by 15 pixels
        #     -v.y - 15, # Offset y by -15 pixels
        #     text=coord_text,
        #     fill="black",
        #     font=("Arial", 8)
        # )

    def toggle_highlight_vertex(self, v):
        if (len(self.highlighted_vertices) > 0 and (self.highlighted_vertices[0][0] == v)):
            self.canvas.delete(self.highlighted_vertices[0][1])
            self.highlighted_vertices.pop(0)
            return
        elif len(self.highlighted_vertices) > 0 and self.highlighted_vertices[-1][0] == v:
            self.canvas.delete(self.highlighted_vertices[-1][1])
            self.highlighted_vertices.pop()
        else:
            highlight_id = self.canvas.create_oval(v.x-6, -v.y-6, v.x+6, -v.y+6, outline="blue", width=2)
            self.highlighted_vertices.append((v, highlight_id))

    def draw_edge(self, e, color="black"):
        v1 = e.origin
        v2 = e.twin.origin
        self.canvas.create_line(v1.x, -v1.y, v2.x, -v2.y, fill=color, width=2)

    def draw_polygon(self, polygon, is_polygon_construction=False, is_trapezoidalization=False):
        if is_polygon_construction:
            self.animate_vertices(polygon.vertices, callback=lambda: self.animate_edges(polygon.half_edges))
        elif is_trapezoidalization:
            for v in self.non_animated_vertices:
                self.draw_vertex(v)
            self.animate_edges(polygon.half_edges, animate_end_vertices=False)
        else:
            for v in polygon.vertices:
                self.draw_vertex(v)
            self.animate_edges(polygon.half_edges)

    def animate_vertices(self, vertices, i=0, callback=None):
        if i < len(vertices):
            v = vertices[i]
            self.draw_vertex(v)
            self.non_animated_vertices.add(v)  # Mark this vertex as non-animated
            # Schedule next vertex after 500 ms
            self.root.after(500, lambda: self.animate_vertices(vertices, i+1, callback=callback))
        else:
            # All vertices done → trigger the next animation
            if callback:
                callback()
        
    def animate_edges(self, edges, i=0, animate_end_vertices=False):
        if i < len(edges) - 1:
            e = edges[i]
            if animate_end_vertices:
                self.draw_vertex(e.twin.origin)

            self.draw_edge(e)
            self.non_animated_edges.add(e)  # Mark this edge as non-animated
            # schedule next edge after 500 ms
            if i < len(edges) - 2:
                next_e = edges[i+1]
                if next_e not in self.non_animated_edges:
                    if animate_end_vertices and e.twin.origin == next_e.origin:
                        self.root.after(0, lambda: self.animate_edges(edges, i+1))
                    else:   
                        self.root.after(500, lambda: self.animate_edges(edges, i+1))
                else:
                    self.root.after(0, lambda: self.animate_edges(edges, i+1))

    def draw_dual_graph(self):
        face_coords = {}
        for f in self.dual_graph.keys():
            f_x = 0
            f_y = 0
            edge = f.outer_component
            while True:
                f_x += edge.origin.x
                f_y += edge.origin.y
                edge = edge.next
                if edge == f.outer_component:
                    break
            f_x /= 3
            f_y /= 3
            face_coords[f] = (f_x, f_y)
        # --- Phase 2: Draw all nodes first ---
        for v in self.dual_graph.keys():
            x, y = face_coords[v]
            self.canvas.create_oval(
                x - 4, -y - 4, x + 4, -y + 4,
                fill="black", tags="dual_node"
            )

        # --- Phase 3: Animate edges one by one ---
        edges = []
        for v, neighbours in self.dual_graph.items():
            for n in neighbours:
                if (n, v) not in edges:  # avoid duplicate undirected edges
                    edges.append((v, n))

        def draw_edge(i):
            if i >= len(edges):
                return
            v, n = edges[i]
            x1, y1 = face_coords[v]
            x2, y2 = face_coords[n]
            self.canvas.create_line(
                x1, -y1, x2, -y2,
                fill="green", width=2, tags="dual_edge"
            )
            # Schedule next edge after 300ms
            self.canvas.after(300, lambda: draw_edge(i + 1))

        # Start animation
        draw_edge(0)
    
    def remove_dual_graph(self):
        """Removes all dual graph elements from the canvas."""
        self.canvas.delete("dual_node")
        self.canvas.delete("dual_edge")

    def run_three_coloring(self):
        self.remove_dual_graph()
        if not self.triangulated_polygon:
            self.text_widget.delete(1.0, tk.END)
            self.text_widget.insert(tk.END, "Please triangulate the polygon first!")
            return

        # Step 1: Get 3-coloring and guards
        vertex_colors = three_color_triangulation(self.triangulated_polygon, self.dummy_vertices)
        self.guard_positions = get_minimum_guard_set(vertex_colors)

        # Map colors to actual display colors
        color_map = {
            0: "red",
            1: "blue",
            2: "yellow"
        }

        # Step 2: Draw all vertices with their assigned color
        for v, color in vertex_colors.items():
            self.canvas.create_oval(
                v.x - 10, -v.y - 10, v.x + 10, -v.y + 10,
                fill=color_map[color],
                outline="",
                tags=f"vertex_{id(v)}"
            )

        # Step 3: After 2 seconds, remove color from non-guards & highlight guards
        def keep_only_guards():
            for v in vertex_colors.keys():
                tag = f"vertex_{id(v)}"
                if v not in self.guard_positions:
                    # Clear fill for non-guards (only keep outline)
                    self.canvas.itemconfig(tag, fill="")
                else:
                    # Highlight guard vertices
                    self.canvas.itemconfig(tag, outline="green", width=2)

        self.canvas.after(5000, keep_only_guards)


    def show_visibility_regions(self):
        """Show visibility regions while preserving existing drawings"""
        if not self.guard_positions:
            self.text_widget.delete(1.0, tk.END)
            self.text_widget.insert(tk.END, "Please run three-coloring first to identify guards!")
            return
            
        # Get visibility regions for all guards
        self.visibility_regions = visualize_polygon(
            self.outer_boundary_vertices_copy,
            self.holes_vertices_copy,
            self.guard_positions
        )
        
        print(self.visibility_regions)
        # Draw visibility regions with semi-transparent colors
        # 10 distinct colors
        colors = [
            "#FF0000", "#00FF00", "#0000FF", "#FFFF00", "#FF00FF",
            "#00FFFF", "#FFA500", "#800080", "#008000", "#000080"
        ]

        # stipple patterns to simulate transparency
        stipple_patterns = ["gray25", "gray50", "gray75", "gray12"]

        def draw_region(i):
            if i >= len(self.visibility_regions):
                # All individual regions shown, now draw all together
                for idx, (guard, visible_points) in enumerate(self.visibility_regions.items()):
                    if len(visible_points) >= 3:
                        coords = []
                        for v in visible_points:
                            if hasattr(v, "x") and hasattr(v, "y"):
                                coords.extend([v.x, -v.y])

                        self.canvas.create_polygon(
                            coords,
                            fill=colors[idx % len(colors)],
                            outline="",
                            stipple=stipple_patterns[idx % len(stipple_patterns)],
                            tags="visibility"
                        )
                return

            # Draw current region only
            guard, visible_points = list(self.visibility_regions.items())[i]
            if len(visible_points) >= 3:
                coords = []
                for v in visible_points:
                    if hasattr(v, "x") and hasattr(v, "y"):
                        coords.extend([v.x, -v.y])

                self.canvas.create_polygon(
                    coords,
                    fill=colors[i % len(colors)],
                    outline="",
                    stipple=stipple_patterns[i % len(stipple_patterns)],
                    tags="visibility"
                )

            # Schedule next region after 1 second
            self.canvas.after(3000, lambda: draw_region(i + 1))

        # Start drawing from the first region
        draw_region(0)
        
        # # Update text widget with statistics
        # self.text_widget.delete(1.0, tk.END)
        # self.text_widget.insert(tk.END, f"Number of guards: {len(self.guard_positions)}\n")
        # for i, guard in enumerate(self.guard_positions):
        #     visible_points = self.visibility_regions.get(guard, [])
        #     self.text_widget.insert(tk.END, 
        #         f"Guard {i+1} at ({guard.x:.1f}, {-guard.y:.1f}) sees {len(visible_points)} points\n")


    def clear(self):
        self.canvas.delete("all")
        self.text_widget.delete(1.0, tk.END)
        self.polygon = DCEL()
        self.trapezoidalized_polygon = None
        self.monotone_polygons = None
        self.triangulated_polygon = None
        self.selected_vertex = None
        self.outer_boundary = DCEL()
        self.holes = []
        self.current_hole = None
        self.drawing_hole = False

if __name__ == "__main__":
    root = tk.Tk()
    app = PolygonGUI(root)
    root.mainloop()