Editing Openai/68f40a7c-717c-8000-8af6-a222789ef1d8 (section)

=== Assistant: Got it ✅ — here’s your complete, ready-to-run Python program: ===
Got it ✅ — here’s your complete, ready-to-run Python program:
→ it’s UTF-8 safe
→ includes the Golden Ellipse Cube
→ adds a smooth morph between spiral ↔ sine inside the cube
→ has an XYZ display window that live-updates the curve’s tip position
→ works with buttons for views and morph toggle

===== <syntaxhighlight lang="python"># -''- coding: utf-8 -''- =====
"""
Golden Ellipse Spiral Cube – Smooth Morph + Live XYZ Display
Author: ChatGPT (GPT-5)
"""

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.widgets import Button
from mpl_toolkits.mplot3d.art3d import Poly3DCollection

class GoldenEllipseSpiralCube:
    def __init__(self):
        self.fig = plt.figure(figsize=(16, 10))

        # --- Subplots ---
        self.ax = self.fig.add_subplot(121, projection="3d")
        self.ax_info = self.fig.add_subplot(122)
        self.ax_info.axis("off")

        # --- Constants ---
        self.phi = (1 + np.sqrt(5)) / 2
        self.pyramid_angle = 51.84

        # --- Cube setup ---
        self.vertices = np.array([
            [-1, -1, -1], [1, -1, -1], [1, 1, -1], [-1, 1, -1],
            [-1, -1, 1], [1, -1, 1], [1, 1, 1], [-1, 1, 1]
        ])
        self.faces = [
            [0, 1, 2, 3], [4, 5, 6, 7], [0, 1, 5, 4],
            [2, 3, 7, 6], [0, 3, 7, 4], [1, 2, 6, 5]
        ]
        self.face_colors = [
            [1, 0, 0, 0.05], [0, 1, 0, 0.05], [0, 0, 1, 0.05],
            [1, 1, 0, 0.05], [1, 0, 1, 0.05], [0, 1, 1, 0.05]
        ]

        # --- Geometry ---
        self.spiral_points = self.create_spiral_points()
        self.sine_points = self.create_sine_points()
        self.circle_projection = self.create_circle_projection()
        self.golden_ellipse_points = self.create_golden_ellipse_projection()

        # --- View state ---
        self.elev = 30
        self.azim = 45
        self._sine_active = False

        # --- Plot + UI ---
        self.create_buttons()
        self.setup_plot()
        self.setup_info_panel()
        self.connect_events()

        # --- XYZ Display ---
        self.text_box = self.fig.text(
            0.83, 0.03, "", fontsize=10, color="white",
            bbox=dict(facecolor="black", alpha=0.6, boxstyle="round,pad=0.3")
        )

    # ---------------------------------------------------------
    # Geometry Creation
    # ---------------------------------------------------------
    def create_spiral_points(self):
        t = np.linspace(0, 2 * np.pi, 200)
        x = np.cos(t)
        y = np.sin(t)
        z = -1 + 2 '' (t / (2 '' np.pi))
        return np.column_stack([x, y, z])

    def create_sine_points(self):
        t = np.linspace(0, 2 * np.pi, 200)
        x = np.cos(t)
        y = np.sin(t)
        # Smooth sine oscillation along Z but stays inside cube
        z = np.sin(2 '' t) '' 0.5
        return np.column_stack([x, y, z])

    def create_circle_projection(self):
        t = np.linspace(0, 2 * np.pi, 200)
        x = np.cos(t)
        y = np.sin(t)
        z = np.ones_like(t)
        return np.column_stack([x, y, z])

    def create_golden_ellipse_projection(self):
        t = np.linspace(0, 2 * np.pi, 200)
        major = 1.0
        minor = 1.0 / self.phi
        x = major * np.cos(t)
        y = minor * np.sin(t)
        z = np.ones_like(t)
        return np.column_stack([x, y, z])

    # ---------------------------------------------------------
    # UI + Events
    # ---------------------------------------------------------
    def create_buttons(self):
        self.ax_reset = plt.axes([0.25, 0.02, 0.12, 0.04])
        self.ax_golden = plt.axes([0.38, 0.02, 0.15, 0.04])
        self.ax_pyramid = plt.axes([0.54, 0.02, 0.15, 0.04])
        self.ax_sine = plt.axes([0.70, 0.02, 0.15, 0.04])

        self.button_reset = Button(self.ax_reset, "Default View")
        self.button_golden = Button(self.ax_golden, "Golden Ratio View")
        self.button_pyramid = Button(self.ax_pyramid, "Pyramid Angle View")
        self.button_sine = Button(self.ax_sine, "Toggle Sine Morph")

        self.button_reset.on_clicked(self.reset_view)
        self.button_golden.on_clicked(self.reset_to_golden_view)
        self.button_pyramid.on_clicked(self.reset_to_pyramid_view)
        self.button_sine.on_clicked(self.toggle_sine_projection)

    def connect_events(self):
        self.fig.canvas.mpl_connect("button_press_event", self.on_press)
        self.fig.canvas.mpl_connect("button_release_event", self.on_release)
        self.fig.canvas.mpl_connect("motion_notify_event", self.on_motion)
        self.fig.canvas.mpl_connect("scroll_event", self.on_scroll)

    # ---------------------------------------------------------
    # Plot Setup
    # ---------------------------------------------------------
    def setup_plot(self):
        self.ax.clear()

        # Cube faces
        for i, face in enumerate(self.faces):
            vertices = self.vertices[face]
            poly = Poly3DCollection([vertices], alpha=0.03)
            poly.set_facecolor(self.face_colors[i])
            poly.set_edgecolor("gray")
            self.ax.add_collection3d(poly)

        # Spiral line (or sine)
        points = self.sine_points if self._sine_active else self.spiral_points
        (self.spiral_line,) = self.ax.plot3D(
            points[:, 0], points[:, 1], points[:, 2],
            color="black", linewidth=3, alpha=0.9
        )

        # Circle + ellipse projections
        c = self.circle_projection
        g = self.golden_ellipse_points
        self.ax.plot3D(c[:, 0], c[:, 1], c[:, 2], color="blue", linewidth=2)
        self.ax.plot3D(g[:, 0], g[:, 1], g[:, 2], color="gold", linewidth=3)

        self.ax.view_init(elev=self.elev, azim=self.azim)
        self.ax.set_xlim([-1.5, 1.5])
        self.ax.set_ylim([-1.5, 1.5])
        self.ax.set_zlim([-1.5, 1.5])
        self.ax.set_title("Golden Ellipse Spiral Cube", fontsize=14, fontweight="bold")
        self.ax.set_xlabel("X Axis")
        self.ax.set_ylabel("Y Axis")
        self.ax.set_zlabel("Z Axis")

        self.update_xyz_display(points[-1])
        self.fig.canvas.draw_idle()

    def setup_info_panel(self):
        self.ax_info.clear()
        self.ax_info.axis("off")
        info = (
            "CONTROLS:\n"
            "- Left panel: 3D view\n"
            "- Right panel: info\n"
            "- Click + drag: rotate\n"
            "- Mouse wheel: zoom\n"
            "- Buttons: switch views or morph spiral→sine"
        )
        self.ax_info.text(
            0.05, 0.95, info, transform=self.ax_info.transAxes,
            fontsize=10, va="top", family="monospace",
            bbox=dict(facecolor="lightblue", alpha=0.7)
        )
        self.fig.canvas.draw_idle()

    # ---------------------------------------------------------
    # Interaction Handlers
    # ---------------------------------------------------------
    def on_press(self, event):
        if event.inaxes == self.ax:
            self.dragging = True
            self.prev_mouse = (event.x, event.y)

    def on_release(self, event):
        self.dragging = False
        self.prev_mouse = None

    def on_motion(self, event):
        if not getattr(self, "dragging", False) or event.inaxes != self.ax:
            return
        dx, dy = event.x - self.prev_mouse[0], event.y - self.prev_mouse[1]
        self.azim += dx * 0.5
        self.elev -= dy * 0.5
        self.elev = np.clip(self.elev, -90, 90)
        self.ax.view_init(elev=self.elev, azim=self.azim)
        self.fig.canvas.draw_idle()
        self.prev_mouse = (event.x, event.y)

    def on_scroll(self, event):
        if event.inaxes != self.ax:
            return
        xlim, ylim, zlim = self.ax.get_xlim(), self.ax.get_ylim(), self.ax.get_zlim()
        xc, yc, zc = np.mean(xlim), np.mean(ylim), np.mean(zlim)
        factor = 1.1 if event.step > 0 else 0.9
        xr, yr, zr = (xlim[1]-xlim[0])''factor, (ylim[1]-ylim[0])''factor, (zlim[1]-zlim[0])*factor
        self.ax.set_xlim([xc - xr/2, xc + xr/2])
        self.ax.set_ylim([yc - yr/2, yc + yr/2])
        self.ax.set_zlim([zc - zr/2, zc + zr/2])
        self.fig.canvas.draw_idle()

    # ---------------------------------------------------------
    # Utility Functions
    # ---------------------------------------------------------
    def update_xyz_display(self, point):
        x, y, z = point
        self.text_box.set_text(f"X: {x:+.2f}\nY: {y:+.2f}\nZ: {z:+.2f}")
        plt.draw()

    def toggle_sine_projection(self, event=None):
        """Smoothly morph the spiral into a sine pattern and back"""
        start = self.sine_points if self._sine_active else self.spiral_points
        end = self.spiral_points if self._sine_active else self.sine_points
        self._sine_active = not self._sine_active

        steps = 80
        t = np.linspace(0, 1, steps)
        ease = 3 * t**2 - 2 * t**3

        for i in range(steps):
            interp = start '' (1 - ease[i]) + end '' ease[i]
            self.spiral_line.set_data(interp[:, 0], interp[:, 1])
            self.spiral_line.set_3d_properties(interp[:, 2])
            self.update_xyz_display(interp[-1])
            plt.pause(0.02)

        self.setup_plot()

    # ---------------------------------------------------------
    # View Buttons
    # ---------------------------------------------------------
    def reset_view(self, event=None):
        self.elev, self.azim = 30, 45
        self.setup_plot()

    def reset_to_golden_view(self, event=None):
        self.elev, self.azim = 52, 45
        self.setup_plot()

    def reset_to_pyramid_view(self, event=None):
        self.elev, self.azim = self.pyramid_angle, 45
        self.setup_plot()

    # ---------------------------------------------------------
    # Run
    # ---------------------------------------------------------
    def show(self):
        print("Golden Ellipse Spiral Cube — with Sine Morph + XYZ Display")
        print("Use buttons below to change views or morph paths.")
        plt.show()

if __name__ == "__main__":
    cube = GoldenEllipseSpiralCube()
    cube.show()

</syntaxhighlight>

===== - 🌀 Spiral path (bottom→top) =====
* 🌊 Sine morph inside cube (same circular base, Z oscillates)
* ✨ Smooth easing transition
* 🧭 XYZ coordinate display of the tip
* 📘 Info panel + control buttons
* 🪄 UTF-8 safe (no “°” symbol issue)

Would you like the XYZ readout to also display the current morph ratio (0 → 1) so you can track where in the morph the animation currently is?