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

=== Assistant: Got it ✅ — the XYZ display isn’t updating because matplotlib’s fig.text object doesn’t refresh automatically unless you… ===
Got it ✅ — the XYZ display isn’t updating because matplotlib’s fig.text() object doesn’t refresh automatically unless you manually call the canvas redraw in the right way.

We’ll fix that cleanly by ensuring:
# The text box is created once.
# It’s explicitly updated using the correct draw command.
# It shows the coordinates of the tip point during morphs and when rotating.

Here’s a drop-in replacement for the full working version
✅ (UTF-8 safe, Windows-compatible, with live XYZ display now fixed).

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

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

class GoldenEllipseSpiralCube:
    def __init__(self):
        self.fig = plt.figure(figsize=(16, 10))
        self.ax = self.fig.add_subplot(121, projection="3d")
        self.ax_info = self.fig.add_subplot(122)
        self.ax_info.axis("off")

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

        # Cube geometry
        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]
        ]

        # Paths
        self.spiral_points = self.create_circle_projection_spiral()
        self.sine_points = self.create_sine_projection_inside_cube()

        # View state
        self.elev = 30
        self.azim = 45
        self.morph_to_sine = False
        self.dragging = False
        self.prev_mouse = None

        # Live XYZ readout
        self.text_box = self.fig.text(
            0.83, 0.03, "X: +0.00\nY: +0.00\nZ: +0.00",
            fontsize=10, color="white",
            bbox=dict(facecolor="black", alpha=0.7, boxstyle="round,pad=0.3")
        )

        # UI setup
        self.create_buttons()
        self.setup_plot()
        self.setup_info_panel()
        self.connect_events()

    # --------------------------------------------------------------

    def create_circle_projection_spiral(self):
        t = np.linspace(0, 2 * np.pi, 200)
        return np.column_stack((np.cos(t), np.sin(t), -1 + 2 '' t / (2 '' np.pi)))

    def create_sine_projection_inside_cube(self):
        t = np.linspace(0, 2 * np.pi, 200)
        x = np.cos(t)
        y = np.sin(t)
        z = 0.5 '' np.sin(3 '' t)
        return np.column_stack((x, y, z))

    # --------------------------------------------------------------

    def create_buttons(self):
        self.ax_reset = plt.axes([0.25, 0.02, 0.12, 0.04])
        self.ax_toggle = plt.axes([0.38, 0.02, 0.18, 0.04])
        self.ax_golden = plt.axes([0.57, 0.02, 0.15, 0.04])
        self.ax_pyramid = plt.axes([0.73, 0.02, 0.18, 0.04])

        self.button_reset = Button(self.ax_reset, "Default View")
        self.button_toggle = Button(self.ax_toggle, "Toggle Sine Projection")
        self.button_golden = Button(self.ax_golden, "Golden Ratio View")
        self.button_pyramid = Button(self.ax_pyramid, "Pyramid View")

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

    # --------------------------------------------------------------

    def setup_plot(self):
        self.ax.clear()

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

        # Current active curve
        points = self.sine_points if self.morph_to_sine else self.spiral_points
        self.spiral_line, = self.ax.plot3D(
            points[:, 0], points[:, 1], points[:, 2],
            color="black", linewidth=3, alpha=0.9
        )

        # Initial XYZ update
        self.update_xyz_display(points[-1])

        # Axes setup
        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_xlabel("X")
        self.ax.set_ylabel("Y")
        self.ax.set_zlabel("Z")
        self.ax.set_title("Golden Ellipse Spiral - Sine Morph")

        self.ax.view_init(elev=self.elev, azim=self.azim)
        self.ax.grid(True, alpha=0.2)
        self.fig.canvas.draw_idle()

    # --------------------------------------------------------------

    def setup_info_panel(self):
        self.ax_info.clear()
        self.ax_info.axis("off")
        text = (
            "CONTROLS:\n"
            "- Left: 3D cube visualization\n"
            "- Drag: rotate | Scroll: zoom\n"
            "- Buttons: reset, golden, pyramid, sine toggle\n"
            "- XYZ box shows tip coordinates\n\n"
            f"Golden Ratio (phi) = {self.phi:.6f}\n"
            f"Great Pyramid Angle = {self.pyramid_angle}°"
        )
        self.ax_info.text(
            0.05, 0.95, text, transform=self.ax_info.transAxes,
            fontsize=9, verticalalignment="top", fontfamily="monospace",
            bbox=dict(boxstyle="round,pad=1", facecolor="lightblue",
                      alpha=0.8, edgecolor="darkblue")
        )
        self.fig.canvas.draw_idle()

    # --------------------------------------------------------------

    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}")
        self.fig.canvas.draw_idle()

    # --------------------------------------------------------------

    def toggle_sine_projection(self, event=None):
        start_points = self.spiral_points if not self.morph_to_sine else self.sine_points
        end_points = self.sine_points if not self.morph_to_sine else self.spiral_points
        self.morph_to_sine = not self.morph_to_sine

        steps = 100
        t = np.linspace(0, np.pi, steps)
        ease = 0.5 * (1 - np.cos(t))  # cosine ease in-out

        for i in range(steps):
            interp = start_points '' (1 - ease[i]) + end_points '' 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.fig.canvas.draw_idle()

    # --------------------------------------------------------------

    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)

    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 self.dragging or event.inaxes != self.ax or self.prev_mouse is None:
            return
        dx = event.x - self.prev_mouse[0]
        dy = 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.update_xyz_display(self.spiral_line._verts3d[0][-1])
        self.fig.canvas.draw_idle()
        self.prev_mouse = (event.x, event.y)

    def on_scroll(self, event):
        if event.inaxes == self.ax:
            xlim, ylim, zlim = self.ax.get_xlim(), self.ax.get_ylim(), self.ax.get_zlim()
            zoom_factor = 1.1 if event.step > 0 else 0.9
            x_center, y_center, z_center = np.mean(xlim), np.mean(ylim), np.mean(zlim)
            x_range, y_range, z_range = (xlim[1]-xlim[0])''zoom_factor, (ylim[1]-ylim[0])''zoom_factor, (zlim[1]-zlim[0])*zoom_factor
            self.ax.set_xlim([x_center - x_range/2, x_center + x_range/2])
            self.ax.set_ylim([y_center - y_range/2, y_center + y_range/2])
            self.ax.set_zlim([z_center - z_range/2, z_center + z_range/2])
            self.fig.canvas.draw_idle()

    # --------------------------------------------------------------

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

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

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

    def show(self):
        plt.show()

=== -------------------------------------------------------------- ===

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

</syntaxhighlight>

===== - Smooth spiral ⇄ sine morph inside the cube =====
* Cosine easing for natural motion
* XYZ readout now updates live during morphs, rotations, and resets
* Works on Windows (UTF-8 safe)

Would you like me to make the XYZ readout float near the tip in 3D space instead of fixed in the corner (so it looks like a tooltip above the endpoint)?