cloth.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pythreejs import *\n",
    "import ipywidgets\n",
    "from IPython.display import display\n",
    "from pathlib import Path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.set_printoptions(precision=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# simulation params\n",
    "\n",
    "#time step \n",
    "dt = 1.0\n",
    "#no. of rows\n",
    "rows = 5\n",
    "#no. of cols\n",
    "cols = 5\n",
    "#stretch constant\n",
    "ks = 5e5 #5e10\n",
    "#shear constant\n",
    "ksh = 100.0 #100.0\n",
    "#damping constant\n",
    "kd = 10\n",
    "#no. of particles \n",
    "N = rows*cols\n",
    "#cloth desity\n",
    "density = 10.0\n",
    "#gravity\n",
    "g = 0.981\n",
    "\n",
    "# max stretch in u and v direction\n",
    "bu = 1.0\n",
    "bv = 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# instantiate particle positions, velocities and forces\n",
    "# positions\n",
    "points = []\n",
    "for r in range(rows+1):\n",
    "    for c in range(cols+1):\n",
    "        points.append(r)\n",
    "        points.append(c)\n",
    "        points.append(0.0)\n",
    "\n",
    "# 3D world positions of the particles\n",
    "world_pos = np.transpose(np.array([points]))  \n",
    "# positions in the UV space\n",
    "uv_pos = np.transpose(np.array([points]))\n",
    "\n",
    "# velocity\n",
    "vel = np.array([[0.0] for i in range(3*(rows+1)*(cols+1))])\n",
    "\n",
    "# force\n",
    "force = np.array([[0.0] for i in range(3*(rows+1)*(cols+1))])\n",
    "# external force - add gravity in the z direction\n",
    "for i in range(2, force.shape[0], 3):\n",
    "    force[i,0] = -g      \n",
    "\n",
    "\n",
    "# force jacobian matrix\n",
    "A = np.zeros((3,3))\n",
    "J = np.block([[A for i in range((rows+1)*(cols+1))] for j in range((rows+1)*(cols+1))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# instantiate inverse mass matrix\n",
    "invM = np.array([[0.0 for i in range(3*(rows+1)*(cols+1))] for i in range(3*(rows+1)*(cols+1))])\n",
    "\n",
    "# mass matrix\n",
    "for i in range(0, world_pos.shape[0], 3):\n",
    "    x = world_pos[i,0]\n",
    "    y = world_pos[i+1,0]\n",
    "    z = world_pos[i+2,0]\n",
    "    \n",
    "    u = uv_pos[i,0]\n",
    "    v = uv_pos[i+1,0]\n",
    "    t = uv_pos[i+2,0]\n",
    "    \n",
    "    area_of_tri = 0.5\n",
    "    \n",
    "    # case 1 : point is inside the grid and has 6 neighbours(belongs to 6 triangles)\n",
    "    if ((1 <= u <= rows-1) and (1 <= v <= cols-1)):\n",
    "        tri_mass = density * area_of_tri #(area of triangle is 0.5)\n",
    "        invM[i,i] = 1.0/((1/3)*6*tri_mass)\n",
    "        invM[i+1, i+1] = 1.0/((1/3)*6*tri_mass)\n",
    "        invM[i+2, i+2] = 1.0/((1/3)*6*tri_mass)\n",
    "#         if ((4 <= u <= 6) and (4 <= v <= 6)):\n",
    "#         invM[i,i] = 0.0\n",
    "#         invM[i+1, i+1] = 0.0\n",
    "#         invM[i+2, i+2] = 0.0\n",
    "    # case 2 : point is in the corner of the grid and has 1 neighbour \n",
    "    elif ((u==0 and v==0) or (u==0 and v==rows) or (u==cols and v==0) or(u==cols and v==rows)):\n",
    "        tri_mass = density * area_of_tri #(area of triangle is 0.5)\n",
    "#         invM[i,i] = 1.0/((1/3)*tri_mass)\n",
    "#         invM[i+1, i+1] = 1.0/((1/3)*tri_mass)\n",
    "#         invM[i+2, i+2] = 1.0/((1/3)*tri_mass)\n",
    "#         if ( v==rows) :\n",
    "#             print(u,v)\n",
    "        invM[i,i] = 0.0\n",
    "        invM[i+1, i+1] = 0.0\n",
    "        invM[i+2, i+2] = 0.0\n",
    "    # case 3 : point is on the edge of the grid and has 3 neighbours\n",
    "    else :\n",
    "        tri_mass = density * area_of_tri #(area of triangle is 0.5)\n",
    "#         invM[i,i] = 1.0/((1/3)*3*tri_mass)\n",
    "#         invM[i+1, i+1] = 1.0/((1/3)*3*tri_mass)\n",
    "#         invM[i+2, i+2] = 1.0/((1/3)*3*tri_mass)\n",
    "#         if (v == rows):\n",
    "#             print(u,v)\n",
    "        invM[i,i] = 0.0\n",
    "        invM[i+1, i+1] = 0.0\n",
    "        invM[i+2, i+2] = 0.0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# stretch force\n",
    "# k - stretch coeff\n",
    "# alpha - area of the triangle in uv space\n",
    "def stretch_force_on_all_particles_in_a_triangle(uv_pos, world_pos, idx1, idx2, idx3, k, bu, bv, alpha):\n",
    "    uv_i = uv_pos[idx1]\n",
    "    uv_j = uv_pos[idx2] \n",
    "    uv_k = uv_pos[idx3] \n",
    "    \n",
    "    p_i = world_pos[idx1] \n",
    "    p_j = world_pos[idx2] \n",
    "    p_k = world_pos[idx3]\n",
    "    \n",
    "    u_i = uv_i[0] #xz\n",
    "    v_i = uv_i[1]\n",
    "    \n",
    "    u_j = uv_j[0] #xz\n",
    "    v_j = uv_j[1]\n",
    "    \n",
    "    u_k = uv_k[0] #xz\n",
    "    v_k = uv_k[1]\n",
    "    \n",
    "    dv1 = v_j - v_i\n",
    "    dv2 = v_k - v_i\n",
    "    du1 = u_j - u_i\n",
    "    du2 = u_k - u_i\n",
    "    \n",
    "    x_i = p_i[0]\n",
    "    y_i = p_i[1]\n",
    "    z_i = p_i[2]\n",
    "    X_i = np.array([[p_i[0]], [p_i[1]], [p_i[2]]])\n",
    "    \n",
    "    x_j = p_j[0]\n",
    "    y_j = p_j[1]\n",
    "    z_j = p_j[2]\n",
    "    X_j = np.array([[p_j[0]], [p_j[1]], [p_j[2]]])\n",
    "    \n",
    "    x_k = p_k[0]\n",
    "    y_k = p_k[1]\n",
    "    z_k = p_k[2]\n",
    "    X_k = np.array([[p_k[0]], [p_k[1]], [p_k[2]]])\n",
    "    \n",
    "    # calculate wu, wv\n",
    "    Wu = ((X_j - X_i)*dv2 - (X_k - X_i)* dv1) / (du1*dv2 - du2*dv1)\n",
    "    Wu = Wu / np.linalg.norm(Wu)\n",
    "    \n",
    "    Wv = (-(X_j - X_i)*du2 + (X_k - X_i)* du1) / (du1*dv2 - du2*dv1)\n",
    "    Wv = Wv / np.linalg.norm(Wv)\n",
    "    \n",
    "    # condition function\n",
    "    Cu = np.linalg.norm(Wu) - bu\n",
    "    Cv = np.linalg.norm(Wv) - bv\n",
    "    \n",
    "    C = np.array([[Cu], [Cv]])\n",
    "    C_T = np.transpose(C)\n",
    "    \n",
    "    # calculate dwu/dx, dwu/dx \n",
    "    # for Xi\n",
    "    dWu_dXi = (dv1 - dv2) / (du1*dv2 - du2*dv1)\n",
    "    dWv_dXi = (du2 - du1) / (du1*dv2 - du2*dv1)\n",
    "    \n",
    "    # for Xj\n",
    "    dWu_dXj = dv2 / (du1*dv2 - du2*dv1)\n",
    "    dWv_dXj = -du2 / (du1*dv2 - du2*dv1)\n",
    "    \n",
    "    # for Xk\n",
    "    dWu_dXk = -dv1 / (du1*dv2 - du2*dv1)\n",
    "    dWv_dXk = du1 / (du1*dv2 - du2*dv1)\n",
    "    \n",
    "    # force on Xi\n",
    "    f_i_u = (-k * alpha * dWu_dXi * np.identity(3, dtype = float).dot(Wu)) * Cu\n",
    "    f_i_v = (-k * alpha * dWv_dXi * np.identity(3, dtype = float).dot(Wv)) * Cv\n",
    "    f_i = f_i_u + f_i_v\n",
    "    \n",
    "    # force on Xj\n",
    "    f_j_u = (-k * alpha * dWu_dXj * np.identity(3, dtype = float).dot(Wu)) * Cu\n",
    "    f_j_v = (-k * alpha * dWv_dXj * np.identity(3, dtype = float).dot(Wv)) * Cv\n",
    "    f_j = f_j_u + f_j_v\n",
    "    \n",
    "    # force on Xk\n",
    "    f_k_u = (-k * alpha * dWu_dXk * np.identity(3, dtype = float).dot(Wu)) * Cu\n",
    "    f_k_v = (-k * alpha * dWv_dXk * np.identity(3, dtype = float).dot(Wv)) * Cv\n",
    "    f_k = f_k_u + f_k_v\n",
    "    \n",
    "    # calculate jacobian matrix\n",
    "    # u direction\n",
    "    temp_mat_1 = (dWu_dXi * np.identity(3, dtype = float)).dot(dWu_dXj * np.identity(3, dtype = float))\n",
    "\n",
    "    temp_mat_2 = np.identity(3, dtype=float) - Wu.dot(np.transpose(Wu))\n",
    "                                                                        \n",
    "    Kij_u = -k * (alpha * dWu_dXi * np.identity(3, dtype = float).dot(Wu) * \\\n",
    "                alpha * np.transpose(dWu_dXj * (np.identity(3, dtype = float).dot(Wu))) + \\\n",
    "                (alpha / np.linalg.norm(Wu)) * temp_mat_1.dot(temp_mat_2) * Cu)\n",
    "                                                                \n",
    "    temp_mat_3 = (dWu_dXj * np.identity(3, dtype = float)).dot(dWu_dXk * np.identity(3, dtype = float))\n",
    "                                                                        \n",
    "    Kjk_u = -k * (alpha * dWu_dXj * np.identity(3, dtype = float).dot(Wu) * \\\n",
    "                alpha * np.transpose(dWu_dXk * (np.identity(3, dtype = float).dot(Wu))) + \\\n",
    "                (alpha / np.linalg.norm(Wu)) * temp_mat_3.dot(temp_mat_2) * Cu)\n",
    "                                                                \n",
    "    temp_mat_4 = (dWu_dXk * np.identity(3, dtype = float)).dot(dWu_dXi * np.identity(3, dtype = float))\n",
    "                                                                        \n",
    "    Kki_u = -k * (alpha * dWu_dXk * np.identity(3, dtype = float).dot(Wu) * \\\n",
    "                alpha * np.transpose(dWu_dXi * (np.identity(3, dtype = float).dot(Wu))) + \\\n",
    "                (alpha / np.linalg.norm(Wu)) * temp_mat_4.dot(temp_mat_2) * Cu)\n",
    "              \n",
    "    # v direction                                                            \n",
    "    temp_mat_1 = (dWv_dXi * np.identity(3, dtype = float)).dot(dWv_dXj * np.identity(3, dtype = float))\n",
    "    temp_mat_2 = np.identity(3, dtype=float) - Wv.dot(np.transpose(Wv))\n",
    "                                                                        \n",
    "    Kij_v = -k * (alpha * dWv_dXi * np.identity(3, dtype = float).dot(Wv) * \\\n",
    "                alpha * np.transpose(dWv_dXj * (np.identity(3, dtype = float).dot(Wv))) + \\\n",
    "                (alpha / np.linalg.norm(Wv)) * temp_mat_1.dot(temp_mat_2) * Cv)\n",
    "                                                                \n",
    "    temp_mat_3 = (dWv_dXj * np.identity(3, dtype = float)).dot(dWv_dXk * np.identity(3, dtype = float))\n",
    "                                                                        \n",
    "    Kjk_v = -k * (alpha * dWv_dXj * np.identity(3, dtype = float).dot(Wv) * \\\n",
    "                alpha * np.transpose(dWv_dXk * (np.identity(3, dtype = float).dot(Wv))) + \\\n",
    "                (alpha / np.linalg.norm(Wv)) * temp_mat_3.dot(temp_mat_2) * Cv)\n",
    "                                                                \n",
    "    temp_mat_4 = (dWv_dXk * np.identity(3, dtype = float)).dot(dWv_dXi * np.identity(3, dtype = float))\n",
    "                                                                         \n",
    "    Kki_v = -k * (alpha * dWv_dXk * np.identity(3, dtype = float).dot(Wv) * \\\n",
    "                alpha * np.transpose(dWv_dXi * (np.identity(3, dtype = float).dot(Wv))) + \\\n",
    "                (alpha / np.linalg.norm(Wv)) * temp_mat_4.dot(temp_mat_2) * Cv)\n",
    "   \n",
    "    Kij = Kij_u + Kij_v\n",
    "    Kjk = Kjk_u + Kjk_v\n",
    "    Kki = Kki_u + Kki_v\n",
    "                                                                \n",
    "    return f_i, f_j, f_k, Kij, Kjk, Kki"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# shear force\n",
    "# k - shear coeff\n",
    "# alpha - area of the triangle in uv space\n",
    "def shear_force_on_all_particles_in_a_triangle(uv_pos, world_pos, idx1, idx2, idx3, k, bu, bv, alpha):\n",
    "    uv_i = uv_pos[idx1]\n",
    "    uv_j = uv_pos[idx2] \n",
    "    uv_k = uv_pos[idx3] \n",
    "    \n",
    "    p_i = world_pos[idx1] \n",
    "    p_j = world_pos[idx2] \n",
    "    p_k = world_pos[idx3]\n",
    "    \n",
    "    u_i = uv_i[0] #xz\n",
    "    v_i = uv_i[1]\n",
    "    \n",
    "    u_j = uv_j[0] #xz\n",
    "    v_j = uv_j[1]\n",
    "    \n",
    "    u_k = uv_k[0] #xz\n",
    "    v_k = uv_k[1]\n",
    "    \n",
    "    dv1 = v_j - v_i\n",
    "    dv2 = v_k - v_i\n",
    "    du1 = u_j - u_i\n",
    "    du2 = u_k - u_i\n",
    "    # print(\"the deltas : \",dv1, dv2, du1, du2)\n",
    "\n",
    "    x_i = p_i[0]\n",
    "    y_i = p_i[1]\n",
    "    z_i = p_i[2]\n",
    "    X_i = np.array([[p_i[0]], [p_i[1]], [p_i[2]]])\n",
    "    \n",
    "    x_j = p_j[0]\n",
    "    y_j = p_j[1]\n",
    "    z_j = p_j[2]\n",
    "    X_j = np.array([[p_j[0]], [p_j[1]], [p_j[2]]])\n",
    "    \n",
    "    x_k = p_k[0]\n",
    "    y_k = p_k[1]\n",
    "    z_k = p_k[2]\n",
    "    X_k = np.array([[p_k[0]], [p_k[1]], [p_k[2]]])\n",
    "    \n",
    "    # calculate wu, wv\n",
    "    Wu = ((X_j - X_i)*dv2 - (X_k - X_i)* dv1) / (du1*dv2 - du2*dv1)\n",
    "    Wu = Wu / np.linalg.norm(Wu)\n",
    "    \n",
    "    Wv = (-(X_j - X_i)*du2 + (X_k - X_i)* du1) / (du1*dv2 - du2*dv1)\n",
    "    Wv = Wv / np.linalg.norm(Wv)\n",
    "    \n",
    "    # condition function\n",
    "    C = alpha * (np.transpose(Wu)).dot(Wv)\n",
    "    \n",
    "    # calculate dwu/dx, dwu/dx \n",
    "    # for Xi\n",
    "    dWu_dXi = (dv1 - dv2) / (du1*dv2 - du2*dv1)\n",
    "    dWv_dXi = (du2 - du1) / (du1*dv2 - du2*dv1)\n",
    "    \n",
    "    # for Xj\n",
    "    dWu_dXj = dv2 / (du1*dv2 - du2*dv1)\n",
    "    dWv_dXj = -du2 / (du1*dv2 - du2*dv1)\n",
    "    \n",
    "    # for Xk\n",
    "    dWu_dXk = -dv1 / (du1*dv2 - du2*dv1)\n",
    "    dWv_dXk = du1 / (du1*dv2 - du2*dv1)\n",
    "    \n",
    "    dC_dXi = alpha * (dWu_dXi * np.identity(3, dtype = float).dot(Wv) + dWv_dXi * np.identity(3, dtype = float).dot(Wu)) \n",
    "    dC_dXj = alpha * (dWu_dXj * np.identity(3, dtype = float).dot(Wv) + dWv_dXj * np.identity(3, dtype = float).dot(Wu)) \n",
    "    dC_dXk = alpha * (dWu_dXk * np.identity(3, dtype = float).dot(Wv) + dWv_dXk * np.identity(3, dtype = float).dot(Wu)) \n",
    "    \n",
    "    f_i = -k * dC_dXi * C\n",
    "    f_j = -k * dC_dXj * C\n",
    "    f_k = -k * dC_dXk * C\n",
    "    \n",
    "    # calculate the jacobian matrix\n",
    "    K_ij = -k* (dC_dXi.dot(np.transpose(dC_dXj)) + alpha*(dWu_dXi*dWv_dXj+dWu_dXj*dWv_dXi)*np.identity(3, dtype=float)*C )\n",
    "    \n",
    "    K_jk = -k* (dC_dXj.dot(np.transpose(dC_dXk)) + alpha*(dWu_dXj*dWv_dXk+dWu_dXk*dWv_dXj)*np.identity(3, dtype=float)*C ) \n",
    "    \n",
    "    K_ki = -k* (dC_dXk.dot(np.transpose(dC_dXi)) + alpha*(dWu_dXk*dWv_dXi+dWu_dXi*dWv_dXk)*np.identity(3, dtype=float)*C  )\n",
    "    \n",
    "    return f_i, f_j, f_k, K_ij, K_jk, K_ki"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Given an index, return list of indices coming from the neighbouring traingles. \n",
    "def get_neighbouring_triangles(index, u, v, gridX, gridY):\n",
    "    triangle_indices = []\n",
    "    rows = gridX - 1\n",
    "    cols = gridY - 1\n",
    "    \n",
    "    # case 1 : point is inside the grid and has 6 neighbours(belongs to 6 triangles)\n",
    "    if ((1 <= u <= rows-1) and (1 <= v <= cols-1)):\n",
    "        # particle indices\n",
    "            tri_1 = [index, index+1, index+1+gridX ]\n",
    "            tri_2 = [index, index+1+gridX, index+gridX ]\n",
    "            tri_3 = [index, index+gridX, index-1 ]\n",
    "            tri_4 = [index, index-1, index-1-gridX ]\n",
    "            tri_5 = [index-1-gridX, index-gridX, index ]\n",
    "            tri_6 = [index, index-gridX, index+1 ]\n",
    "            triangle_indices = [tri_1, tri_2, tri_3, tri_4, tri_5, tri_6]\n",
    "    # case 2 : point is in the corner of the grid and has 1 neighbour \n",
    "    elif ((u==0 and v==0) or (u==0 and v==rows) or (u==cols and v==0) or(u==cols and v==rows)):\n",
    "        if (u==0 and v==0):\n",
    "            triangle_indices = [[index, index+1, index+gridX+1], \n",
    "                                [index, index+1+gridX, index+gridX]]\n",
    "        if (u==0 and v==cols):\n",
    "            triangle_indices = [[index, index-1, index+gridX]]\n",
    "        if (u==cols and v==rows):\n",
    "            triangle_indices = [[index, index-1, index-gridX-1], \n",
    "                                [index, index-gridX-1, index-gridX]]\n",
    "        if (u==rows and v==0):\n",
    "            triangle_indices = [[index, index+1, index-gridX]]\n",
    "    # case 3 : point is on the edge of the grid and has 3 neighbours\n",
    "    else :\n",
    "        if (v == 0) :\n",
    "            triangle_indices = [[index, index-gridX, index+1], \n",
    "                                [index, index+1, index+1+gridX], \n",
    "                                [index, index+1+gridX, index+gridX]]\n",
    "        if (v == cols):\n",
    "            triangle_indices = [[index, index+gridX, index-1], \n",
    "                                [index, index-1, index-1-gridX], \n",
    "                                [index, index-1-gridX, index-gridX]]\n",
    "        if (u == rows):\n",
    "            triangle_indices = [[index, index+1, index-gridX], \n",
    "                                [index, index - gridX, index-1-gridX], \n",
    "                                [index, index-1-gridX, index-1]]\n",
    "        if (u == 0):\n",
    "            triangle_indices = [[index, index-1, index+gridX], \n",
    "                                [index, index + gridX, index+1+gridX], \n",
    "                                [index, index+1+gridX, index+1]]\n",
    "    \n",
    "    \n",
    "    return triangle_indices\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# input dimensions\n",
    "# world_pos - 300X1\n",
    "# uv_pos - 300X1\n",
    "# f - 300X1\n",
    "# df_dx - 300X300\n",
    "def update_force_and_jacobian(world_pos, rows, cols, uv_pos, ks, bu, bv, f, J):\n",
    "    gridX = cols + 1\n",
    "    gridY = rows + 1\n",
    "    world_pos_reshaped = world_pos.reshape(gridX*gridY, 3)\n",
    "    uv_pos_reshaped = uv_pos.reshape(gridX*gridY, 3)\n",
    "    f_reshaped = f.reshape(gridX*gridY, 3)\n",
    "    \n",
    "    for index in range(world_pos_reshaped.shape[0]):\n",
    "        x = world_pos_reshaped[index][0]\n",
    "        y = world_pos_reshaped[index][1]\n",
    "        z = world_pos_reshaped[index][2]\n",
    "        \n",
    "        u = uv_pos_reshaped[index][0]\n",
    "        v = uv_pos_reshaped[index][1]\n",
    "        t = uv_pos_reshaped[index][2]\n",
    "        alpha = 0.5\n",
    "        \n",
    "        triangle_indices = get_neighbouring_triangles(index, u, v, gridX, gridY)\n",
    "        \n",
    "\n",
    "        for triangle in triangle_indices:\n",
    "            f_p_1_st, f_p_2_st, f_p_3_st, Kij_st, Kjk_st, Kki_st = stretch_force_on_all_particles_in_a_triangle(\n",
    "                                                                    uv_pos_reshaped, world_pos_reshaped, \n",
    "                                                                    triangle[0], triangle[1], triangle[2],\n",
    "                                                                    ks, bu, bv, alpha)\n",
    "                \n",
    "            f_p_1_sh, f_p_2_sh, f_p_3_sh, Kij_sh, Kjk_sh, Kki_sh = shear_force_on_all_particles_in_a_triangle(\n",
    "                                                                    uv_pos_reshaped, world_pos_reshaped, \n",
    "                                                                    triangle[0], triangle[1], triangle[2],\n",
    "                                                                    ksh, bu, bv, alpha)\n",
    "                \n",
    "                \n",
    "            f_p_1 = f_p_1_st + f_p_1_sh\n",
    "            f_p_2 = f_p_2_st + f_p_2_sh\n",
    "            f_p_3 = f_p_3_st + f_p_3_sh\n",
    "                \n",
    "            # print(\"shear force - \", f_p_1_sh, f_p_2_sh, f_p_3_sh)\n",
    "            # print(\"stretch force - \", f_p_1_st, f_p_2_st, f_p_3_st)\n",
    "                \n",
    "            Kij = Kij_st + Kij_sh \n",
    "            Kjk = Kjk_st + Kjk_sh\n",
    "            Kki = Kki_st + Kki_sh\n",
    "                \n",
    "\n",
    "                \n",
    "            f_reshaped[triangle[0]] += f_p_1.reshape(1,3)[0]\n",
    "            f_reshaped[triangle[1]] += f_p_2.reshape(1,3)[0]\n",
    "            f_reshaped[triangle[2]] += f_p_3.reshape(1,3)[0]\n",
    "\n",
    "            #Kij\n",
    "            J[3*triangle[0]:3*triangle[0]+3, 3*triangle[1]:3*triangle[1]+3] += Kij\n",
    "            #Kji\n",
    "            J[3*triangle[1]:3*triangle[1]+3, 3*triangle[0]:3*triangle[0]+3] += Kij\n",
    "            #Kjk\n",
    "            J[3*triangle[1]:3*triangle[1]+3, 3*triangle[2]:3*triangle[2]+3] += Kjk\n",
    "            #Kkj\n",
    "            J[3*triangle[2]:3*triangle[2]+3, 3*triangle[1]:3*triangle[1]+3] += Kjk\n",
    "            #Kki\n",
    "            J[3*triangle[2]:3*triangle[2]+3, 3*triangle[0]:3*triangle[0]+3] += Kki\n",
    "            #Kik\n",
    "            J[3*triangle[0]:3*triangle[0]+3, 3*triangle[2]:3*triangle[2]+3] += Kki\n",
    "\n",
    "    new_f = f_reshaped.reshape(gridX*gridY*3, 1) \n",
    "    return new_f, J\n",
    "           "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# be - backward euler\n",
    "# dimensions\n",
    "# pos - 300X1\n",
    "# vel - 300X1\n",
    "# force - 300X1\n",
    "# invM - 300X300\n",
    "def be(world_pos, uv_pos, rows, cols, vel, force, jacobian, ks, bu, bv, invM, dt):\n",
    "    \n",
    "#     for every pos :\n",
    "#         calculate net force\n",
    "#         calculate force jacobian\n",
    "#         calculate     \n",
    "#             Adv = b\n",
    "#             A = I - dt^2*Minv*df_dx\n",
    "#             b = dt*Minv*(f_prev + dt*df_dx*v_prev)\n",
    "#             dv = A\\b\n",
    "#             apply boundary conditions (If applicable)\n",
    "#             x_new - x_old = dt*(v_prev + dv)\n",
    "#             update positions\n",
    "    J = jacobian\n",
    "    f, df_dx = update_force_and_jacobian(world_pos, rows, cols, uv_pos, ks, bu, bv, force, J)\n",
    "    \n",
    "    I = np.identity(3*(rows+1)*(cols+1), dtype=float)\n",
    "    \n",
    "    A = I - dt*dt*(invM.dot(df_dx))\n",
    "    \n",
    "    b = dt*invM.dot(f + dt*df_dx.dot(vel) )\n",
    "    \n",
    "    dv = np.linalg.solve(A, b)\n",
    "\n",
    "    xnew = world_pos + dt*(vel + dv)\n",
    "    vnew = vel + dv\n",
    "\n",
    "    # update positions, velocities, (force and jacobians?)\n",
    "\n",
    "    return xnew, vnew, f, df_dx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "keyframes = {}\n",
    "\n",
    "# time stepping\n",
    "t = 0\n",
    "for i in range(15):\n",
    "    xnew, vnew, f, df_dx = be(world_pos, uv_pos, rows, cols, vel, force, J, ks, bu, bv, invM, dt)\n",
    "    world_pos = xnew\n",
    "    t = t + dt\n",
    "    keyframes[t] = world_pos.reshape((rows+1)*(cols+1), 3)\n",
    "#     force = f\n",
    "#     K = df_dx\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# render the animation\n",
    "# input\n",
    "# bufferGeo -pythreejs bufferGeometry\n",
    "# keyframes - A dictionary with time and vertex positions at the time\n",
    "# { \"t1\" : [v1, v2, v3....],\n",
    "#   \"t2\" : [v1, v2, v3....]...\n",
    "# }\n",
    "# dimensions of the vertex positions array should be --> no. of vertices X 3\n",
    "\n",
    "def draw(bufferGeo, keyframes):\n",
    "    \n",
    "    position_morph_attrs = []\n",
    "    time_steps = []\n",
    "    frame_indices = []\n",
    "    frame_index = 0\n",
    "    for key, value in keyframes.items():\n",
    "        time_steps.append(key)\n",
    "        position_morph_attrs.append(BufferAttribute(np.array(value, dtype=np.float32), normalized=False))\n",
    "        frame_indices.append(frame_index)\n",
    "        frame_index += 1\n",
    "    \n",
    "    bufferGeo.morphAttributes = {'position': position_morph_attrs}\n",
    "    mesh = Mesh(bufferGeo, MeshStandardMaterial(side='DoubleSide', color='red', wireframe=True, morphTargets=True))\n",
    "    \n",
    "    # create key frames\n",
    "    position_track = NumberKeyframeTrack(\n",
    "            name='.morphTargetInfluences[0]', times=time_steps, values=frame_indices)\n",
    "    # create animation clip from the morph targets\n",
    "    position_clip = AnimationClip(tracks=[position_track])\n",
    "    # create animation action\n",
    "    position_action = AnimationAction(AnimationMixer(mesh), position_clip, mesh)\n",
    "\n",
    "    # setup scene\n",
    "    camera = PerspectiveCamera( position=[5, 3, 5], aspect=600/400)\n",
    "    scene = Scene(children=[mesh, camera,\n",
    "                             DirectionalLight(position=[3, 5, 1], intensity=0.6),\n",
    "                             AmbientLight(intensity=0.5)])\n",
    "    renderer = Renderer(camera=camera, scene=scene,\n",
    "                         controls=[OrbitControls(controlling=camera)],\n",
    "                         width=600, height=400)\n",
    "\n",
    "    display(renderer, position_action)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "drawing\n",
      "end drawing\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "13d4d3b482f147eea8993dbcb286c935",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Renderer(camera=PerspectiveCamera(aspect=1.5, position=(5.0, 3.0, 5.0), projectionMatrix=(1.0, 0.0, 0.0, 0.0, …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bc27737899204a7b920316cbc59fad13",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "AnimationAction(clip=AnimationClip(tracks=(NumberKeyframeTrack(name='.morphTargetInfluences[0]', times=array([…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# form faces from the vertices, make bufferGeometry with faces and vertices \n",
    "def get_triangles(index, uvpos, gridX, gridY):\n",
    "    tri1 = []\n",
    "    tri2 = []\n",
    "    u = uvpos[0]\n",
    "    v = uvpos[1]\n",
    "    \n",
    "    if (u < gridX - 1 and v < gridX - 1): \n",
    "        quad = [index, index+1, index+ 1 + gridY, index + gridY]\n",
    "        tri1 = [index, index+1, index+ 1 + gridY]\n",
    "        tri2 = [index, index+ 1 + gridY, index + gridY]\n",
    "    \n",
    "    return tri1, tri2\n",
    "\n",
    "# calculate faces to feed into the index array in bufferGeo\n",
    "uv_pos_reshaped = uv_pos.reshape((rows+1)*(cols+1), 3)\n",
    "world_pos_reshaped = world_pos.reshape((rows+1)*(cols+1), 3)\n",
    "faces = []\n",
    "for index in range(uv_pos_reshaped.shape[0]):\n",
    "    uvpos = uv_pos_reshaped[index]\n",
    "    tri1, tri2 = get_triangles(index, uvpos, rows+1, cols+1)\n",
    "    if (tri1 != [] and tri2 != []):\n",
    "        faces.append(tri1)\n",
    "        faces.append(tri2)\n",
    "faces = np.array(faces,  dtype=np.uint16).ravel()\n",
    "\n",
    "bufferGeo = BufferGeometry(\n",
    "        attributes={\n",
    "            'position': BufferAttribute(np.array(world_pos_reshaped, dtype=np.float32), normalized=False),\n",
    "            'index': BufferAttribute(faces),\n",
    "        }\n",
    "    )\n",
    "\n",
    "# call the draw function \n",
    "draw(bufferGeo, keyframes)"
   ]
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.9"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}