# tk_Gradient_Radial_Scan_Visualizer.py

# tk_Gradient_Radial_Scan_Visualizer.py

import math
import tkinter as tk
from tkinter import Canvas
import time

ww = 640
hh = 640

root = tk.Tk()
root.title("Gradient Radial Scan Visualizer")
root.geometry(f"{ww}x{hh}+0+0")

cell_size = 40
font_size = 10
n = 10
grid_size = 20 * cell_size
squares = {}
cell_order = []
visited = set()

drag_start_x = 0
drag_start_y = 0

canvas = tk.Canvas(root, width=ww, height=hh, bg="white")
canvas.pack(fill=tk.BOTH, expand=True)

for x in range(-n, n):
    for y in range(-n, n):
        canvas_x = (x + n) * cell_size
        canvas_y = (-y + n - 1) * cell_size
        rect_id = canvas.create_rectangle(
            canvas_x,
            canvas_y,
            canvas_x + cell_size,
            canvas_y + cell_size,
            outline="black",
            fill="white",
            tag="cells",
        )
        squares[(x, y)] = rect_id
        text_x = canvas_x + cell_size // 2
        text_y = canvas_y + cell_size // 2
        canvas.create_text(
            text_x,
            text_y,
            text=f"{x},{y}",
            font=("Arial", font_size),
            fill="black",
        )

for angle_deg in range(90):
    angle_rad = math.radians(angle_deg)
    cos_val = math.cos(angle_rad)
    sin_val = math.sin(angle_rad)
    for r in range(n + 1):
        x = int(r * cos_val)
        y = int(r * sin_val)
        if (x, y) in visited:
            continue

        quadrants = [
            (x, y),
            (-y-1, x),
            (-x-1, -y-1),
            (y, -x-1)
        ]

        for qx, qy in quadrants:
            cell_order.append((qx, qy))
            visited.add((qx, qy))

grid_colors = {
    (0, 0): (255, 255, 255),
    (0, 1): (255, 255, 0),
    (0, 2): (0, 255, 0),
    (1, 0): (255, 165, 0),
    (1, 1): (128, 128, 128),
    (1, 2): (0, 0, 255),
    (2, 0): (255, 0, 0),
    (2, 1): (128, 0, 128),
    (2, 2): (0, 0, 0)
}

def interpolate_color(x, y):
    norm_x = (x + n) / (2 * n) * 2
    norm_y = (y + n) / (2 * n) * 2
    x0 = int(norm_x)
    x1 = min(x0 + 1, 2)
    y0 = int(norm_y)
    y1 = min(y0 + 1, 2)
    c00 = grid_colors.get((x0, y0), (255, 255, 255))
    c10 = grid_colors.get((x1, y0), (255, 255, 255))
    c01 = grid_colors.get((x0, y1), (255, 255, 255))
    c11 = grid_colors.get((x1, y1), (255, 255, 255))
    dx = norm_x - x0
    dy = norm_y - y0
    top = [c00[i] * (1 - dx) + c10[i] * dx for i in range(3)]
    bottom = [c01[i] * (1 - dx) + c11[i] * dx for i in range(3)]
    color = [top[i] * (1 - dy) + bottom[i] * dy for i in range(3)]
    return f'#{int(color[0]):02x}{int(color[1]):02x}{int(color[2]):02x}'

interpolated_colors = {}
for x in range(-n, n):
    for y in range(-n, n):
        interpolated_colors[(x, y)] = interpolate_color(x, y)

def detect_color(x, y):
    return None

def process_pixels():
    for x, y in cell_order:
        if (x, y) in squares:
            canvas.itemconfig(squares[(x, y)], fill=interpolated_colors[(x, y)])
            time.sleep(0.01)
            if detect_color(x, y):
                canvas.itemconfig(squares[(x, y)], fill="red")
            canvas.update()

def start_drag(event):
    global drag_start_x, drag_start_y
    drag_start_x = event.x
    drag_start_y = event.y
    canvas.config(cursor="fleur")

def drag_canvas(event):
    global drag_start_x, drag_start_y
    dx = event.x - drag_start_x
    dy = event.y - drag_start_y
    canvas.move("all", dx, dy)
    drag_start_x = event.x
    drag_start_y = event.y

def stop_drag(event):
    canvas.config(cursor="")

canvas.bind("<Button-1>", start_drag)
canvas.bind("<B1-Motion>", drag_canvas)
canvas.bind("<ButtonRelease-1>", stop_drag)

while True:
    process_pixels()
    canvas.itemconfig("cells", fill="white")

root.mainloop()