Untitled1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "4d18e6a8-ea56-4162-9426-d2f48f5a7de3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "33046d40cfa0473a8d2c4cf0e2d27488",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.0, description='Qx', max=1.0, min=-1.0), FloatSlider(value=0.0, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from ipywidgets import interact, FloatSlider, IntSlider\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "# Define the catenary function in 3D\n",
    "def catenary_3d(x, a):\n",
    "    return a * np.cosh(x / a)\n",
    "\n",
    "# Function to generate vertices for different polygons\n",
    "def polygon_vertices(sides, radius=1):\n",
    "    angle = 2 * np.pi / sides\n",
    "    return [(radius * np.cos(i * angle), radius * np.sin(i * angle), 0) for i in range(sides)]\n",
    "\n",
    "# Quaternion multiplication\n",
    "def quaternion_multiply(q1, q2):\n",
    "    w1, x1, y1, z1 = q1\n",
    "    w2, x2, y2, z2 = q2\n",
    "    return (w1*w2 - x1*x2 - y1*y2 - z1*z2,\n",
    "            w1*x2 + x1*w2 + y1*z2 - z1*y2,\n",
    "            w1*y2 - x1*z2 + y1*w2 + z1*x2,\n",
    "            w1*z2 + x1*y2 - y1*x2 + z1*w2)\n",
    "\n",
    "# Rotate a point by a quaternion\n",
    "def rotate_point_by_quaternion(point, quaternion):\n",
    "    q_point = (0, point[0], point[1], point[2])\n",
    "    q_conjugate = (quaternion[0], -quaternion[1], -quaternion[2], -quaternion[3])\n",
    "    rotated_point = quaternion_multiply(quaternion_multiply(quaternion, q_point), q_conjugate)\n",
    "    return rotated_point[1:]\n",
    "\n",
    "# Apply quaternion rotation to a set of vertices\n",
    "def apply_quaternion_rotation(vertices, quaternion):\n",
    "    return [rotate_point_by_quaternion(vertex, quaternion) for vertex in vertices]\n",
    "\n",
    "# Function to plot a rotated polygon with catenary curves in 3D\n",
    "def plot_rotated_polygon(ax, x_offset, y_offset, z_offset, quaternion, sides, a=1, num_points=100):\n",
    "    vertices = polygon_vertices(sides)\n",
    "    rotated_vertices = apply_quaternion_rotation(vertices, quaternion)\n",
    "    x_range = np.linspace(-1.5, 1.5, num_points)\n",
    "    y_catenary = catenary_3d(x_range, a)\n",
    "    \n",
    "    for i in range(len(rotated_vertices)):\n",
    "        next_i = (i + 1) % len(rotated_vertices)\n",
    "        direction = np.array(rotated_vertices[next_i]) - np.array(rotated_vertices[i])\n",
    "        angle = np.arctan2(direction[1], direction[0])\n",
    "        x_shifted = (x_range * np.cos(angle) - y_catenary * np.sin(angle)) + x_offset\n",
    "        y_shifted = (x_range * np.sin(angle) + y_catenary * np.cos(angle)) + y_offset\n",
    "        z_shifted = np.full_like(x_shifted, z_offset)\n",
    "        ax.plot(x_shifted, y_shifted, z_shifted, 'b')\n",
    "        ax.plot(x_shifted, y_shifted, z_shifted + 1, 'b')\n",
    "\n",
    "# Function to plot a grid of rotated polygons in 3D\n",
    "def plot_grid_of_rotated_polygons(qx=0, qy=0, qz=0, qw=1, spacing=2.0, grid_size=2, sides=6):\n",
    "    quaternion = (qw, qx, qy, qz)\n",
    "    fig = plt.figure(figsize=(12, 12))\n",
    "    ax = fig.add_subplot(111, projection='3d')\n",
    "    for i in range(-grid_size, grid_size + 1):\n",
    "        for j in range(-grid_size, grid_size + 1):\n",
    "            x_offset = i * spacing\n",
    "            y_offset = j * spacing\n",
    "            z_offset = j * spacing  # Adjust z_offset if you want to add more layers\n",
    "            w_offset = j * spacing\n",
    "            plot_rotated_polygon(ax, x_offset, y_offset, z_offset, quaternion, sides)\n",
    "    ax.set_title(f\"Quaternion: {quaternion}, Spacing: {spacing:.2f}, Sides: {sides}\")\n",
    "    ax.set_box_aspect([1, 1, 1])\n",
    "    plt.show()\n",
    "\n",
    "# Interactive plot\n",
    "interact(plot_grid_of_rotated_polygons,\n",
    "         qx=FloatSlider(min=-1, max=1, step=0.1, value=0, description='Qx'),\n",
    "         qy=FloatSlider(min=-1, max=1, step=0.1, value=0, description='Qy'),\n",
    "         qz=FloatSlider(min=-1, max=1, step=0.1, value=0, description='Qz'),\n",
    "         qw=FloatSlider(min=-1, max=1, step=0.1, value=1, description='Qw'),\n",
    "         spacing=FloatSlider(min=0.25, max=5, step=0.1, value=2.0, description='Spacing'),\n",
    "         grid_size=IntSlider(min=1, max=5, step=1, value=2, description='Grid Size'),\n",
    "         sides=IntSlider(min=3, max=10, step=1, value=6, description='Sides'));\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c8b3a57-711e-4909-bd5e-818f76f373d4",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}