computer graphics-perspective projection from scratch with python-demo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3af8162e",
   "metadata": {},
   "source": [
    "### Computer Graphics: Perspective transformation\n",
    "###### by Hamed Shah-hosseini\n",
    "Explanation at: https://www.pinterest.com/HamedShahHosseini/\n",
    "<br>https://github.com/ostad-ai/Computer-Graphics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c075fe7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "from math import sin,cos,pi,tan\n",
    "from ipywidgets import interact"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "06b37a77",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d8901f0826064a549169483be430b5fa",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.0, description='tx', max=3.14, min=-3.1), FloatSlider(value=0.0, des…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.run(tx, ty, tz)>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#perspective projection for github\n",
    "#parameters for the projection\n",
    "width,height=640,480\n",
    "aspect=width/height\n",
    "near,far=1.,100.\n",
    "fovy=30.\n",
    "#vertices of a cube\n",
    "vertex_list=np.array([[-1.,-1.,-1.],\n",
    "                     [-1.,1.,-1.],\n",
    "                      [1.,1.,-1.],\n",
    "                      [1.,-1.,-1.],\n",
    "                      [-1.,-1.,1.],\n",
    "                      [-1.,1.,1.],\n",
    "                      [1.,1.,1.],\n",
    "                      [1.,-1.,1.]\n",
    "                     ])\n",
    "vertex_list[:,2]+=-7 #decrease z values\n",
    "\n",
    "#edges of the cube\n",
    "edge_list=np.array([[0,1],[1,2],[2,3],[3,0],\n",
    "                    [0,4],[1,5],[2,6],[3,7],\n",
    "                    [4,5],[5,6],[6,7],[7,4]])\n",
    "\n",
    "def to_homogeneous(x,y,z):\n",
    "    return np.array([x,y,z,np.ones_like(x)])\n",
    "\n",
    "#fovY is in degrees\n",
    "def perspective(fovY,aspect,zNear,zFar):\n",
    "    epsilon=.01; fovY*=pi/360.\n",
    "    if fovY<epsilon: fovY=epsilon\n",
    "    f=1./tan(fovY)\n",
    "    return np.array([[f/aspect,0.,0.,0.],\n",
    "                     [0.,f,0.,0.],\n",
    "                     [0.,0.,(zNear+zFar)/(zNear-zFar),\n",
    "                      2.*zNear*zFar/(zNear-zFar)],\n",
    "                     [0.,0.,-1.,0.]\n",
    "                    ])\n",
    "\n",
    "# matrix for rotation around y\n",
    "def matrix_rotY(teta):\n",
    "    c=cos(teta); s=sin(teta)\n",
    "    return np.array([[c,0.,s,0.],\n",
    "                     [0,1.,0.,0.],\n",
    "                     [-s,0.,c,0.],\n",
    "                     [0.,0.,0.,1.]])        \n",
    "\n",
    "# matrix for rotation around x\n",
    "def matrix_rotX(teta):\n",
    "    c=cos(teta); s=sin(teta)\n",
    "    return np.array([[1.,0.,0.,0.],\n",
    "                     [0,c,-s,0.],\n",
    "                     [0.,s,c,0.],\n",
    "                     [0.,0.,0.,1.]])        \n",
    "\n",
    "# matrix for rotation around z\n",
    "def matrix_rotZ(teta):\n",
    "    c=cos(teta); s=sin(teta)\n",
    "    return np.array([[c,-s,0.,0.],\n",
    "                     [s,c,0.,0.],\n",
    "                     [0.,0.,1.,0.],\n",
    "                     [0.,0.,0.,1.]])        \n",
    "\n",
    "# rotation around axis x,y,z             \n",
    "def rotateXYZ(tx,ty,tz,center=True):\n",
    "    matXYZ=np.dot(matrix_rotX(tx),matrix_rotY(ty))\n",
    "    matXYZ=np.dot(matXYZ,matrix_rotZ(tz))\n",
    "    if center:\n",
    "        xyz_mean=vertex_list.mean(axis=0)\n",
    "        return xyz_mean+matrix_vector(matXYZ,\n",
    "                                vertex_list-xyz_mean)\n",
    "    else:\n",
    "        return matrix_vector(matXYZ,vertex_list)\n",
    "    \n",
    "# project 3D vector into new space with the matrix    \n",
    "def matrix_vector(matrix,vec3):\n",
    "    temp=np.dot(matrix,to_homogeneous(vec3[:,0],vec3[:,1],vec3[:,2]))\n",
    "    xs,ys,zs=temp[0]/temp[3],temp[1]/temp[3],temp[2]/temp[3]\n",
    "    return np.vstack([xs,ys,zs]).T   \n",
    "\n",
    "#compute perspective matrix\n",
    "matrix_pers=perspective(fovy,aspect,near,far)\n",
    "\n",
    "# tx,ty,tz are angles of rotation in radians\n",
    "def run(tx,ty,tz):\n",
    "    xyz=rotateXYZ(tx,ty,tz)\n",
    "    xyz=matrix_vector(matrix_pers,xyz)\n",
    "    #scaling into width and height \n",
    "    x_vp,y_vp=.5*width*(xyz[:,0]+1),.5*height*(xyz[:,1]+1)\n",
    "    #compute pseudo-brightness from depth\n",
    "    brightness=.5*(1+xyz[:,2])\n",
    "    plt.scatter(x_vp,y_vp,c=brightness,s=50,zorder=3)\n",
    "    for edge in edge_list:\n",
    "        col=.5*(brightness[edge[0]]+brightness[edge[1]])\n",
    "        plt.plot([x_vp[edge[0]],x_vp[edge[1]]],\n",
    "                  [y_vp[edge[0]],y_vp[edge[1]]],'-',\n",
    "                 color=[col,col**4,col**3])\n",
    "    plt.xlim([0,width]); plt.ylim([0,height])\n",
    "    plt.axis('off'); plt.show()\n",
    "interact(run,tx=(-3.1,3.14,.1),ty=(-3.1,3.14,.1),tz=(-3.1,3.14,.1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0850ba16",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}