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

=== Assistant: Perfect 👍 ===
Perfect 👍
Here’s the complete fixed and UTF-8 safe version of your program, written entirely in plain ASCII (no fancy dashes, no smart quotes) and including the XYZ live coordinate display that stays inside the cube during the morph.

===== <syntaxhighlight lang="python"># -''- coding: utf-8 -''- =====
"""
Golden Ellipse Spiral Cube - Smooth Morph + Live XYZ Display (ASCII-safe)
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 vertices
        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]
        ]

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

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

        # XYZ display (must exist before setup_plot)
        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")
        )

        # Buttons and 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)
        points = []
        for angle in t:
            x = np.cos(angle)
            y = np.sin(angle)
            z = -1.0 + (angle / (2 '' np.pi)) '' 2.0
            points.append([x, y, z])
        return np.array(points)

    def create_sine_projection_inside_cube(self):
        t = np.linspace(0, 2 * np.pi, 200)
        x = np.cos(t)
        y = np.sin(t)
        z = np.sin(3 '' t) '' 0.5  # stays inside cube
        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()

        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)

        points = self.spiral_points if not self.morph_to_sine else self.sine_points
        self.spiral_line, = self.ax.plot3D(
            points[:, 0], points[:, 1], points[:, 2],
            color='black', linewidth=3, alpha=0.9
        )

        # Update coordinate box
        self.update_xyz_display(points[-1])

        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 with spiral/sine\n"
            "- Right: Info & explanation\n"
            "- Drag: rotate\n"
            "- Scroll: zoom\n"
            "- Toggle Sine Projection: morphs smoothly\n"
            "- XYZ display shows tip position\n\n"
            "FACTS:\n"
            f"Golden Ratio (phi) = {self.phi:.6f}\n"
            f"Great Pyramid Angle = {self.pyramid_angle} deg"
        )
        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}")
        plt.draw()

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

    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.fig.canvas.draw_idle()
        self.prev_mouse = (event.x, event.y)

    def on_scroll(self, event):
        if event.inaxes == self.ax:
            xlim = self.ax.get_xlim()
            ylim = self.ax.get_ylim()
            zlim = self.ax.get_zlim()
            zoom_factor = 1.1 if event.step > 0 else 0.9
            x_center = np.mean(xlim)
            y_center = np.mean(ylim)
            z_center = np.mean(zlim)
            x_range = (xlim[1] - xlim[0]) * zoom_factor
            y_range = (ylim[1] - ylim[0]) * zoom_factor
            z_range = (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>

===== 1. Save the above code as <code>GoldenEllipseSpiralCubeSLIDER_SINE_MORPH_SAFE_XYZ_ASCII.py</code> =====
# Make sure the first line (# -''- coding: utf-8 -''-) is present.
# Then run: ``<code>bash py GoldenEllipseSpiralCubeSLIDER_SINE_MORPH_SAFE_XYZ_ASCII.py </code>``

You’ll see:
* Left panel: interactive cube
* Right panel: info
* Bottom right: live XYZ coordinate readout
* “Toggle Sine Projection” button morphs the spiral smoothly into the sine curve (inside cube)
* XYZ values update dynamically during the morph

Would you like me to make the XYZ display follow the mouse pointer next (showing coordinates where you hover on the curve)?