plot3d example: Making the projection with NumPy only

Signed-off-by: martinRenou <[email protected]>

Author: martinRenou

environment.yml

@@ -5,5 +5,3 @@ dependencies:
   - branca
   - ipycanvas=0.7.0
   - ipyevents
-  - numpy
-  - matplotlib

examples/plot3d.ipynb

@@ -6,12 +6,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import matplotlib.pyplot as plt\n",
-    "from mpl_toolkits.mplot3d import Axes3D, proj3d\n",
     "import numpy as np\n",
-    "from ipycanvas import Canvas, hold_canvas\n",
-    "from ipywidgets import FloatSlider, Output\n",
-    "from math import pi"
+    "from ipycanvas import Canvas, hold_canvas"
    ]
   },
   {
@@ -20,7 +16,23 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "out = Output(layout={'border': '1px solid black'})"
+    "from ipywidgets import FloatSlider"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This module is local to the Notebook"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from py3d_engine import get_orbit_projection, project_vector"
    ]
   },
   {
@@ -35,40 +47,42 @@
     "        \n",
     "        self.width = 500\n",
     "        self.height = 500\n",
-    "        \n",
-    "        plt.ioff()\n",
-    "        fig = plt.figure()\n",
-    "        self.ax = Axes3D(fig)\n",
     "\n",
     "        self.dragging = False\n",
     "        self.n = 200\n",
-    "        self.x = np.random.rand(self.n)\n",
-    "        self.y = np.random.rand(self.n)\n",
-    "        self.z = np.random.rand(self.n)\n",
-    "        \n",
-    "        self.zoom = 4\n",
+    "        self.x = np.random.rand(self.n) - 0.5\n",
+    "        self.y = np.random.rand(self.n) - 0.5\n",
+    "        self.z = np.random.rand(self.n) - 0.5\n",
+    "\n",
+    "        self.radius = 5\n",
     "        self.dx = 0\n",
     "        self.dy = 0\n",
-    "        self.ax.view_init(elev=self.dx, azim=self.dy)\n",
-    "        self.x2, self.y2, _ = proj3d.proj_transform(self.x, self.y, self.z, self.ax.get_proj())\n",
-    "        self.draw()\n",
-    "            \n",
+    "        self.update_matrix()\n",
+    "\n",
     "        self.on_mouse_down(self.mouse_down_handler)\n",
     "        self.on_mouse_move(self.mouse_move_handler)\n",
     "        self.on_mouse_up(self.mouse_up_handler)\n",
     "        self.on_mouse_out(self.mouse_out_handler)\n",
     "\n",
-    "    #@out.capture()\n",
+    "    def update_matrix(self, dx=None, dy=None, radius=None):\n",
+    "        dx = dx if dx is not None else self.dx\n",
+    "        dy = dy if dy is not None else self.dy\n",
+    "        self.radius = radius if radius is not None else self.radius\n",
+    "\n",
+    "        self.matrix = get_orbit_projection(\n",
+    "            dy, dx, self.radius, \n",
+    "            aspect=self.width / self.height\n",
+    "        )\n",
+    "        self.x2, self.y2, self.z2 = project_vector(self.x, self.y, self.z, self.matrix)\n",
+    "        self.draw()\n",
+    "\n",
     "    def draw(self):\n",
-    "        x = self.x2 * self.width * self.zoom + self.width / 2\n",
-    "        y = self.y2 * self.width * self.zoom + self.height / 2\n",
+    "        x = self.x2 * self.width + self.width / 2\n",
+    "        y = self.y2 * self.height + self.height / 2\n",
+    "        size = 10 * (1 - self.z2) + 1\n",
     "        with hold_canvas(self):\n",
     "            self.clear()\n",
-    "            self.save()\n",
-    "            for i in range(self.n):\n",
-    "                self.fill_arc(x[i], y[i], self.zoom, 0, 2*pi)\n",
-    "                self.stroke_arc(x[i], y[i], self.zoom, 0, 2*pi)\n",
-    "            self.restore()\n",
+    "            self.fill_circles(x, y, size)\n",
     "\n",
     "    def mouse_down_handler(self, pixel_x, pixel_y):\n",
     "        self.dragging = True\n",
@@ -79,9 +93,8 @@
     "        if self.dragging:\n",
     "            self.dx_new = self.dx + pixel_x - self.x_mouse\n",
     "            self.dy_new = self.dy + pixel_y - self.y_mouse\n",
-    "            self.ax.view_init(elev=self.dy_new, azim=self.dx_new)\n",
-    "            self.x2, self.y2, _ = proj3d.proj_transform(self.x, self.y, self.z, self.ax.get_proj())\n",
-    "            self.draw()\n",
+    "            \n",
+    "            self.update_matrix(- self.dx_new, self.dy_new)\n",
     "    \n",
     "    def mouse_up_handler(self, pixel_x, pixel_y):\n",
     "        if self.dragging:\n",
@@ -114,31 +127,18 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "slider = FloatSlider(description='Zoom:', value=p.zoom, min=1, max=10)\n",
+    "# Link Camera position to a slider widget\n",
+    "slider = FloatSlider(description='Radius:', min=1., max=7., value=p.radius)\n",
+    "\n",
+    "def on_slider_move(change):\n",
+    "    slider_value = change['new']\n",
     "\n",
-    "def on_slider_change(change):\n",
-    "    p.zoom = slider.value\n",
-    "    p.draw()\n",
+    "    p.update_matrix(radius=slider_value)\n",
+    "\n",
+    "slider.observe(on_slider_move, 'value')\n",
     "\n",
-    "slider.observe(on_slider_change, 'value')\n",
     "slider"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Drag the figure with the mouse to rotate, use the slider to zoom"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "out"
-   ]
   }
  ],
  "metadata": {
@@ -157,7 +157,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.5"
+   "version": "3.9.0"
   }
  },
  "nbformat": 4,

examples/py3d_engine/__init__.py

@@ -0,0 +1 @@
+from .py3d_engine import *

examples/py3d_engine/py3d_engine.py

@@ -0,0 +1,63 @@
+import numpy as np
+from math import pi, cos, sin, tan
+
+
+def pad_ones(x, y, z):
+    return np.array([x, y, z, np.ones_like(x)])
+
+
+def normalize(vec):
+    return vec / np.linalg.norm(vec)
+
+
+def project_vector(x, y, z, matrix):
+    vec = np.dot(matrix, pad_ones(x, y, z))
+
+    return vec[0]/vec[3], vec[1]/vec[3], vec[2]/vec[3]
+
+
+def get_look_at_matrix(eye, center, up):
+    n = normalize(eye - center)
+    u = normalize(np.cross(up, n))
+    v = np.cross(n, u)
+
+    matrix_r = [[u[0], u[1], u[2], 0],
+                [v[0], v[1], v[2], 0],
+                [n[0], n[1], n[2], 0],
+                [0,    0,    0,    1]]
+
+    matrix_t = [[1, 0, 0, -eye[0]],
+                [0, 1, 0, -eye[1]],
+                [0, 0, 1, -eye[2]],
+                [0, 0, 0, 1]]
+
+    return np.dot(matrix_r, matrix_t)
+
+
+def get_perspective_matrix(fovy, aspect, near, far):
+    f = 1. / tan(fovy * pi / 360.)
+
+    return np.array([
+        [f/aspect, 0,                           0,                           0],
+        [       0, f,                           0,                           0],
+        [       0, 0,   (near + far)/(near - far), 2 * near * far/(near - far)],
+        [       0, 0,                          -1,                           0]
+    ])
+
+
+def get_orbit_projection(elev, azim, radius, center=[0, 0, 0], aspect=1., near=0.5, far=5.):
+    relev, razim = np.pi * elev/180, np.pi * azim/180
+
+    xp = center[0] + cos(razim) * cos(relev) * radius
+    yp = center[1] + sin(razim) * cos(relev) * radius
+    zp = center[2] + sin(relev) * radius
+    eye = np.array((xp, yp, zp))
+
+    if abs(relev) > pi / 2.:
+        up = np.array((0, 0, -1))
+    else:
+        up = np.array((0, 0, 1))
+
+    view_matrix = get_look_at_matrix(eye, center, up)
+    projection_matrix = get_perspective_matrix(50, aspect, 0.5, 2 * radius)
+    return np.dot(projection_matrix, view_matrix)