main.py

import tkinter as tk
from tkinter import ttk, messagebox, simpledialog, filedialog
import networkx as nx
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg


class GraphApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Grafteori-visualisering")
        self.root.geometry("1200x700")

        self.G = nx.Graph()
        self.highlight_edges = []

        # Positions dictionary for nodes (to be able to drag them)
        self.pos = {}

        # State for dragging nodes
        self._dragging_node = None

        # Mode: 'edit' or 'draw'
        self.mode = 'edit'

        self.setup_gui()

    def setup_gui(self):
        options = [
            "Eulers väg",
            "Hamiltoncykel",
            "Isomorfa grafer",
            "Träd",
            "Skog",
            "Cykel",
            "Uppspännande träd",
            "Minimalt uppspännande träd"
        ]

        self.combo = ttk.Combobox(self.root, values=options, state="readonly")
        self.combo.set("Välj grafteori-begrepp")
        self.combo.pack(pady=10)
        self.combo.bind("<<ComboboxSelected>>", self.on_option_selected)

        main_frame = tk.Frame(self.root)
        main_frame.pack(fill=tk.BOTH, expand=True)

        # Left frame for canvas
        self.canvas_frame = tk.Frame(main_frame, width=700)
        self.canvas_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

        # Right frame for controls + info
        right_frame = tk.Frame(main_frame)
        right_frame.pack(side=tk.RIGHT, fill=tk.Y)

        # Info text
        self.info_text = tk.Text(right_frame, width=40, height=25, wrap=tk.WORD)
        self.info_text.pack(padx=10, pady=10)
        self.info_text.config(state='disabled')

        # Controls frame
        control_frame = tk.Frame(right_frame)
        control_frame.pack(pady=5)

        # Node entry
        tk.Label(control_frame, text="Nod(er):").grid(row=0, column=0, sticky="e")
        self.node_entry = tk.Entry(control_frame, width=15)
        self.node_entry.grid(row=0, column=1)

        # Edge entry
        tk.Label(control_frame, text="Kant (u,v):").grid(row=1, column=0, sticky="e")
        self.edge_entry = tk.Entry(control_frame, width=15)
        self.edge_entry.grid(row=1, column=1)

        # Buttons for nodes and edges
        tk.Button(control_frame, text="➕ Lägg till nod", command=self.add_node).grid(row=2, column=0, pady=5)
        tk.Button(control_frame, text="➖ Ta bort nod", command=self.remove_node).grid(row=2, column=1, pady=5)
        tk.Button(control_frame, text="➕ Lägg till kant", command=self.add_edge).grid(row=3, column=0, pady=5)
        tk.Button(control_frame, text="➖ Ta bort kant", command=self.remove_edge).grid(row=3, column=1, pady=5)

        # Mode toggle button
        self.mode_button = tk.Button(control_frame, text="Byt till ritläge", command=self.toggle_mode)
        self.mode_button.grid(row=4, column=0, columnspan=2, pady=10)

        # Save and load buttons
        tk.Button(control_frame, text="💾 Spara graf", command=self.save_graph).grid(row=5, column=0, pady=5)
        tk.Button(control_frame, text="📂 Ladda graf", command=self.load_graph).grid(row=5, column=1, pady=5)

        # Matplotlib figure and canvas setup
        self.fig, self.ax = plt.subplots(figsize=(6, 4))
        self.canvas = FigureCanvasTkAgg(self.fig, master=self.canvas_frame)
        self.canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)

        # Connect matplotlib events
        self.canvas.mpl_connect('button_press_event', self.on_click)
        self.canvas.mpl_connect('motion_notify_event', self.on_motion)
        self.canvas.mpl_connect('button_release_event', self.on_release)

        # Initialize graph empty
        self.draw_graph()

    def on_option_selected(self, event):
        selected = self.combo.get()
        self.G, self.highlight_edges = self.create_graph(selected)
        self.pos = nx.spring_layout(self.G, seed=42)
        self.draw_graph()

    def create_graph(self, option):
        G = nx.Graph()
        highlight_edges = []

        if option == "Eulers väg":
            G.add_edges_from([(1, 2), (2, 3), (3, 4), (4, 2), (4, 1)])
            odd_deg_nodes = [v for v, d in G.degree() if d % 2 == 1]
            if len(odd_deg_nodes) in [0, 2]:
                try:
                    highlight_edges = list(nx.eulerian_path(G))
                except:
                    pass

        elif option == "Hamiltoncykel":
            G = nx.cycle_graph(5)
            highlight_edges = list(G.edges())

        elif option == "Isomorfa grafer":
            G1 = nx.Graph()
            G2 = nx.Graph()
            G1.add_edges_from([(1, 2), (2, 3), (3, 1), (3, 4)])
            G2.add_edges_from([(5, 6), (6, 7), (7, 5), (7, 8)])
            if nx.is_isomorphic(G1, G2):
                G = G1
            else:
                G = G2

        elif option == "Träd":
            G.add_edges_from([(1, 2), (1, 3), (3, 4), (3, 5)])

        elif option == "Skog":
            G.add_edges_from([(1, 2), (1, 3), (4, 5)])

        elif option == "Cykel":
            G = nx.cycle_graph(6)

        elif option == "Uppspännande träd":
            G = nx.cycle_graph(6)
            highlight_edges = list(nx.minimum_spanning_tree(G).edges())

        elif option == "Minimalt uppspännande träd":
            G = nx.Graph()
            G.add_weighted_edges_from([
                (1, 2, 3),
                (1, 3, 1),
                (2, 3, 7),
                (2, 4, 2),
                (3, 4, 2),
                (3, 5, 3),
                (4, 5, 1)
            ])
            highlight_edges = list(nx.minimum_spanning_tree(G).edges())

        return G, highlight_edges

    def draw_graph(self):
        self.ax.clear()
        if not self.pos or set(self.pos.keys()) != set(self.G.nodes()):
            old_pos = self.pos.copy()
            if old_pos:
                self.pos = nx.spring_layout(self.G, pos=old_pos, fixed=old_pos.keys(), seed=42)
            else:
                self.pos = nx.spring_layout(self.G, seed=42)

        edge_colors = ['red' if (u, v) in self.highlight_edges or (v, u) in self.highlight_edges else 'black'
                       for u, v in self.G.edges()]
        nx.draw(self.G, pos=self.pos, ax=self.ax, with_labels=True, node_color='lightblue',
                edge_color=edge_colors, node_size=600, font_size=10)

        # Draw edge weights if present
        edge_labels = nx.get_edge_attributes(self.G, 'weight')
        if edge_labels:
            nx.draw_networkx_edge_labels(self.G, pos=self.pos, edge_labels=edge_labels, ax=self.ax)

        self.canvas.draw()
        self.update_info()

    def update_info(self):
        info = f"Antal noder: {self.G.number_of_nodes()}\n"
        info += f"Antal kanter: {self.G.number_of_edges()}\n\n"

        # Grad per nod
        info += "Grad per nod:\n"
        for node, deg in sorted(self.G.degree(), key=lambda x: x[0]):
            info += f" - Nod {node}: grad {deg}\n"

        # Antal komponenter
        if self.G.number_of_nodes() > 0:
            if nx.is_connected(self.G):
                info += "\nGrafen är sammanhängande\n"
            else:
                comps = nx.number_connected_components(self.G)
                info += f"\nGrafen är INTE sammanhängande (antal komponenter: {comps})\n"
        else:
            info += "\nGrafen är tom, ingen sammanhängande information\n"

        # Euler och Hamilton
        if self.G.number_of_nodes() > 0:
            if nx.is_eulerian(self.G):
                info += "Grafen är en Euler-graf (alla noder har jämn grad)\n"
            elif nx.has_eulerian_path(self.G):
                info += "Grafen har en Eulerstig\n"
            else:
                info += "Grafen har ingen Eulerstig eller Euler-cykel\n"

            # Hamiltoncykel - enkelt test (finns inte direkt i networkx)
            if self.G.number_of_nodes() >= 3 and nx.cycle_graph(self.G.number_of_nodes()).edges() <= self.G.edges():
                info += "Grafen kan innehålla en Hamiltoncykel (enkelt antagande)\n"
            else:
                info += "Hamiltoncykel okänd eller ej uppfylld\n"

            # Träd och skog
            if nx.is_forest(self.G):
                if nx.is_tree(self.G):
                    info += "Grafen är ett träd (en sammanhängande skog)\n"
                else:
                    info += "Grafen är en skog (flera sammanhängande träd)\n"
            else:
                info += "Grafen är inte ett träd eller en skog\n"

        # Lista kanter med vikter
        info += "\nKanter och vikter:\n"
        for u, v, data in self.G.edges(data=True):
            weight = data.get('weight', 1)
            info += f" - ({u}, {v}): vikt {weight}\n"

        self.info_text.config(state='normal')
        self.info_text.delete(1.0, tk.END)
        self.info_text.insert(tk.END, info)
        self.info_text.config(state='disabled')

    # Editing functions
    def add_node(self):
        value = self.node_entry.get()
        try:
            node = int(value)
            if node in self.G:
                messagebox.showinfo("Info", f"Nod {node} finns redan.")
                return
            self.G.add_node(node)
            # Assign a random position
            self.pos[node] = (0.5, 0.5)
            self.draw_graph()
        except ValueError:
            messagebox.showerror("Fel", "Ange ett heltal för nod.")

    def remove_node(self):
        value = self.node_entry.get()
        try:
            node = int(value)
            if node not in self.G:
                messagebox.showinfo("Info", f"Nod {node} finns inte.")
                return
            self.G.remove_node(node)
            if node in self.pos:
                del self.pos[node]
            self.draw_graph()
        except Exception as e:
            messagebox.showerror("Fel", f"Kunde inte ta bort nod: {e}")

    def add_edge(self):
        value = self.edge_entry.get()
        try:
            u, v = map(int, value.split(','))
            if u not in self.G or v not in self.G:
                messagebox.showerror("Fel", "Båda noder måste finnas för att lägga till kant.")
                return
            if self.G.has_edge(u, v):
                messagebox.showinfo("Info", f"Kant ({u},{v}) finns redan.")
                return

            # Fråga om vikt (valfritt)
            weight = simpledialog.askfloat("Kantvikt", "Ange vikt för kanten (eller OK för vikt=1):", minvalue=0.0)
            if weight is None:
                weight = 1

            self.G.add_edge(u, v, weight=weight)
            self.draw_graph()
        except:
            messagebox.showerror("Fel", "Ange kant som: u,v (ex. 1,2)")

    def remove_edge(self):
        value = self.edge_entry.get()
        try:
            u, v = map(int, value.split(','))
            if not self.G.has_edge(u, v):
                messagebox.showinfo("Info", f"Kant ({u},{v}) finns inte.")
                return
            self.G.remove_edge(u, v)
            self.draw_graph()
        except:
            messagebox.showerror("Fel", "Kanten finns inte eller formaterad felaktigt")

    # --- Mode toggle ---
    def toggle_mode(self):
        if self.mode == 'edit':
            self.mode = 'draw'
            self.mode_button.config(text="Byt till redigeringsläge")
            self.node_entry.config(state='disabled')
            self.edge_entry.config(state='disabled')
        else:
            self.mode = 'edit'
            self.mode_button.config(text="Byt till ritläge")
            self.node_entry.config(state='normal')
            self.edge_entry.config(state='normal')

    # --- Matplotlib mouse events ---
    def get_node_at_pos(self, event):
        """Returnera nod nära musposition"""
        if event.xdata is None or event.ydata is None:
            return None
        threshold = 0.05
        for node, (x, y) in self.pos.items():
            if abs(event.xdata - x) < threshold and abs(event.ydata - y) < threshold:
                return node
        return None

    def on_click(self, event):
        if event.inaxes != self.ax:
            return

        if self.mode == 'edit':
            node = self.get_node_at_pos(event)
            if node is not None:
                self._dragging_node = node
        elif self.mode == 'draw':
            node = self.get_node_at_pos(event)
            if node is None:
                # Lägg till nod på klickad position
                new_node = max(self.G.nodes(), default=0) + 1
                self.G.add_node(new_node)
                self.pos[new_node] = (event.xdata, event.ydata)
                self.draw_graph()
                self._draw_edge_start = new_node
            else:
                # Starta kantdrag från befintlig nod
                self._draw_edge_start = node

    def on_motion(self, event):
        if event.inaxes != self.ax:
            return
        if self.mode == 'edit':
            if self._dragging_node is not None:
                # Uppdatera position
                self.pos[self._dragging_node] = (event.xdata, event.ydata)
                self.draw_graph()
                self.update_info()  # Uppdatera infobar live vid drag
        elif self.mode == 'draw':
            # Rita "kanterna" vid dragning (visuell hjälp)
            if hasattr(self, '_draw_edge_start') and self._draw_edge_start is not None:
                self.ax.clear()
                self.draw_graph()  # Rita alla noder/kanter
                x0, y0 = self.pos[self._draw_edge_start]
                x1, y1 = event.xdata, event.ydata
                if x1 is not None and y1 is not None:
                    self.ax.plot([x0, x1], [y0, y1], 'g--')
                    self.canvas.draw()

    def on_release(self, event):
        if event.inaxes != self.ax:
            return

        if self.mode == 'edit':
            self._dragging_node = None
        elif self.mode == 'draw':
            if hasattr(self, '_draw_edge_start') and self._draw_edge_start is not None:
                node_end = self.get_node_at_pos(event)
                if node_end is not None and node_end != self._draw_edge_start:
                    # Lägg till kant mellan start och slut
                    if not self.G.has_edge(self._draw_edge_start, node_end):
                        # Fråga om vikt (valfritt)
                        weight = simpledialog.askfloat("Kantvikt", "Ange vikt för kanten (eller OK för vikt=1):", minvalue=0.0)
                        if weight is None:
                            weight = 1
                        self.G.add_edge(self._draw_edge_start, node_end, weight=weight)
                    self.draw_graph()
                self._draw_edge_start = None

    # --- Save and load ---
    def save_graph(self):
        filename = filedialog.asksaveasfilename(defaultextension=".gml",
                                                filetypes=[("GML files", "*.gml"), ("All files", "*.*")])
        if filename:
            try:
                nx.write_gml(self.G, filename)
                messagebox.showinfo("Spara", f"Graf sparad till {filename}")
            except Exception as e:
                messagebox.showerror("Fel vid sparning", str(e))

    def load_graph(self):
        filename = filedialog.askopenfilename(filetypes=[("GML files", "*.gml"), ("All files", "*.*")])
        if filename:
            try:
                self.G = nx.read_gml(filename)
                # GML sparar noder som string, försök konvertera till int om möjligt
                try:
                    mapping = {n: int(n) for n in self.G.nodes()}
                    self.G = nx.relabel_nodes(self.G, mapping)
                except:
                    pass
                self.pos = nx.spring_layout(self.G, seed=42)
                self.draw_graph()
                messagebox.showinfo("Ladda", f"Graf laddad från {filename}")
            except Exception as e:
                messagebox.showerror("Fel vid inläsning", str(e))


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