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

=== Assistant: Perfect — here’s the full, ready-to-run version of your script, combining: ===
Perfect — here’s the full, ready-to-run version of your script, combining:
✅ Clean UTF-8-safe code (no encoding errors)
✅ Interactive slider for elevation
✅ Preset buttons (Default / Golden / Pyramid)
✅ New Toggle Sine Projection button — shows a smooth orange sine wave projected on the cube’s front face

Save this as:
📄 GoldenEllipseSpiralCubeSLIDER_SINE.py
and run with:

<syntaxhighlight lang="bash">py GoldenEllipseSpiralCubeSLIDER_SINE.py

</syntaxhighlight>

<syntaxhighlight lang="python"># -''- coding: utf-8 -''-
"""
Golden Ellipse Spiral Cube Visualization (with Sine Projection)
Clean, interactive version (no encoding errors)
"""

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.widgets import Button, Slider
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")

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

        # Cube vertices and faces
        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_circle_projection_spiral()
        self.circle_projection = self.create_circle_projection()
        self.golden_ellipse_points = self.create_golden_ellipse_projection()

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

        # New sine projection state
        self.sine_visible = False
        self.sine_line = None
        self.sine_points = self.create_sine_projection()

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

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

    def create_circle_projection(self):
        s = self.create_circle_projection_spiral()
        return np.column_stack((s[:, 0], s[:, 1], np.ones_like(s[:, 2])))

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

    def calculate_perspective_ellipse(self, view_angle):
        t = np.linspace(0, 2 * np.pi, 100)
        minor = np.cos(np.radians(view_angle))
        x = np.cos(t)
        y = minor * np.sin(t)
        z = np.ones_like(x)
        return np.column_stack((x, y, z))

    def create_sine_projection(self):
        """Sine wave projected on front face (z = 1)."""
        x = np.linspace(-1, 1, 300)
        y = 0.5 '' np.sin(3 '' np.pi * x)
        z = np.ones_like(x)
        return np.column_stack((x, y, z))

    # UI --------------------------------------------------------
    def create_buttons(self):
        self.ax_reset = plt.axes([0.18, 0.02, 0.12, 0.04])
        self.ax_golden = plt.axes([0.31, 0.02, 0.15, 0.04])
        self.ax_pyramid = plt.axes([0.47, 0.02, 0.15, 0.04])
        self.ax_sine = plt.axes([0.63, 0.02, 0.20, 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 Projection")

        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 create_slider(self):
        ax_slider = plt.axes([0.3, 0.08, 0.45, 0.03])
        self.slider_elev = Slider(ax_slider, "Elevation (deg)", 0, 90,
                                  valinit=self.elev, valstep=0.5)
        self.slider_elev.on_changed(self.update_elevation)

    def update_elevation(self, val):
        self.elev = self.slider_elev.val
        self.ax.view_init(elev=self.elev, azim=self.azim)
        for line in self.ax.lines[:]:
            if line.get_linestyle() == "--":
                line.remove()
        p = self.calculate_perspective_ellipse(self.elev)
        self.ax.plot3D(p[:, 0], p[:, 1], p[:, 2],
                       color="red", lw=2, ls="--", alpha=0.8)
        self.fig.canvas.draw_idle()

    # Plot setup ------------------------------------------------
    def setup_plot(self):
        self.ax.clear()
        self.sine_line = None
        self.sine_visible = False

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

        s = self.spiral_points
        c = self.circle_projection
        g = self.golden_ellipse_points
        p = self.calculate_perspective_ellipse(self.elev)

        self.ax.plot3D(s[:, 0], s[:, 1], s[:, 2], color="black", lw=3)
        self.ax.plot3D(c[:, 0], c[:, 1], c[:, 2], color="blue", lw=3)
        self.ax.plot3D(g[:, 0], g[:, 1], g[:, 2], color="gold", lw=4)
        self.ax.plot3D(p[:, 0], p[:, 1], p[:, 2],
                       color="red", lw=2, ls="--", alpha=0.7)

        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 Axis")
        self.ax.set_ylabel("Y Axis")
        self.ax.set_zlabel("Z Axis")
        self.ax.set_title("Golden Ellipse Phenomenon", fontsize=14, fontweight="bold")
        self.ax.view_init(elev=self.elev, azim=self.azim)
        self.fig.canvas.draw_idle()

    def setup_info_panel(self):
        self.ax_info.clear()
        self.ax_info.axis("off")
        minor_axis = 1 / self.phi
        pyramid_minor = np.cos(np.radians(self.pyramid_angle))
        pyramid_ratio = 1 / pyramid_minor

        info = (
            "VISUAL ELEMENTS:\n\n"
            "Black: Spiral inside cube\n"
            "Blue: Circle (front projection)\n"
            "Gold: Golden Ellipse (phi=1.618)\n"
            "Red dashed: Perspective ellipse\n"
            "Orange: Sine projection (toggle)\n\n"
            f"Golden Ratio φ = {self.phi:.6f}\n"
            f"Pyramid Angle = {self.pyramid_angle}°\n"
            f"Pyramid ratio = {pyramid_ratio:.6f}\n\n"
            "Controls:\n"
            "• Drag to rotate\n"
            "• Scroll to zoom\n"
            "• Buttons for preset views\n"
            "• Slider for elevation"
        )

        self.ax_info.text(0.05, 0.95, info, transform=self.ax_info.transAxes,
                          fontsize=9, va="top", fontfamily="monospace",
                          bbox=dict(boxstyle="round,pad=1",
                                    facecolor="lightblue", alpha=0.8,
                                    edgecolor="darkblue"))
        self.fig.canvas.draw_idle()

    # Interaction -----------------------------------------------
    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:
            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)
        zoom = 1.1 if event.step > 0 else 0.9
        xr, yr, zr = (xlim[1] - xlim[0]) '' zoom, (ylim[1] - ylim[0]) '' zoom, (zlim[1] - zlim[0]) * zoom
        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()

    # Toggle sine projection ------------------------------------
    def toggle_sine_projection(self, event=None):
        if self.sine_visible:
            if self.sine_line:
                self.sine_line.remove()
                self.sine_line = None
            self.sine_visible = False
        else:
            s = self.sine_points
            self.sine_line, = self.ax.plot3D(
                s[:, 0], s[:, 1], s[:, 2],
                color="orange", linewidth=2.5, alpha=0.9
            )
            self.sine_visible = True
        self.fig.canvas.draw_idle()

    # View presets ----------------------------------------------
    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()

    def show(self):
        print("Golden Ellipse Spiral Cube (with Sine Projection)")
        print("Controls: rotate, zoom, slider for elevation, buttons for preset views.")
        plt.show()

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

</syntaxhighlight>

✅ Run it:

<syntaxhighlight lang="bash">py GoldenEllipseSpiralCubeSLIDER_SINE.py

</syntaxhighlight>

🎨 You’ll see:
* Orange sine projection toggle on the cube face
* Smooth interactive control with buttons + slider
* Info panel clearly listing all shapes and ratios

Would you like me to make the sine wave wrap through the cube (3D wave path) instead of being flat on the front face?
That would look like a flowing “energy wave” crossing the cube’s volume.