computer graphics-hidden surface removal with python-demo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3af8162e",
   "metadata": {},
   "source": [
    "### Computer Graphics: Hidden Surface Removal\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": 1,
   "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": 9,
   "id": "06b37a77",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ddaef89b937b4c038c906d5bf3f1ed1d",
       "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": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# hidden surface removal 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",
    "#faces of cube\n",
    "face_list=np.array([[4,7,6,5],[7,3,2,6],\n",
    "                    [3,0,1,2],[4,5,1,0],\n",
    "                   [5,6,2,1],[4,0,3,7]])\n",
    "face_colors=['red','green','blue',\n",
    "             'orange','magenta','yellow']\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 normal vectors of faces\n",
    "def compute_normals(vec3s):\n",
    "    norms=[]\n",
    "    for face in face_list:\n",
    "        mx,my,mz=0.,0.,0.\n",
    "        N=len(face)\n",
    "        verts=np.zeros((N,3))\n",
    "        for i in range(N):\n",
    "            verts[i]=vec3s[face[i]].copy()\n",
    "        for i in range(N):\n",
    "            mx+=(verts[i,1]-verts[(i+1)%N,1])*\\\n",
    "                (verts[i,2]+verts[(i+1)%N,2])\n",
    "            my+=(verts[i,2]-verts[(i+1)%N,2])*\\\n",
    "                (verts[i,0]+verts[(i+1)%N,0])\n",
    "            mz+=(verts[i,0]-verts[(i+1)%N,0])*\\\n",
    "                (verts[i,1]+verts[(i+1)%N,1])\n",
    "        norms.append(np.array([mx,my,mz]))\n",
    "    return np.asarray(norms)\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",
    "    # position of eye\n",
    "    eye=np.array([0.,0.,0.])\n",
    "    #doing rotation with angles\n",
    "    xyz=rotateXYZ(tx,ty,tz)\n",
    "    normals=compute_normals(xyz)\n",
    "    xyz2=matrix_vector(matrix_pers,xyz)\n",
    "    #scaling into width and height \n",
    "    x_vp,y_vp=.5*width*(xyz2[:,0]+1),.5*height*(xyz2[:,1]+1) \n",
    "    #display non-hidden faces\n",
    "    for id,face in enumerate(face_list):\n",
    "        coords=[]\n",
    "        eye2look=xyz[face[0]]-eye\n",
    "        #if nonnegative, we see back of face\n",
    "        if np.dot(eye2look,normals[id])>=0: continue\n",
    "        for k in range(len(face)):\n",
    "            coords.append([x_vp[face[k]],y_vp[face[k]]])\n",
    "        p=plt.Polygon(coords,facecolor=face_colors[id])\n",
    "        plt.gca().add_patch(p)\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
}