Linearne parametrizacije.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Algoritmi linearnih parametrizacije 3D modela"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Koristimo python pakete libigl, numpy, scipy, te meshplot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import igl\n",
    "import scipy as sp\n",
    "import numpy as np\n",
    "from meshplot import plot, subplot, interact\n",
    "\n",
    "import scipy.spatial\n",
    "from scipy.linalg import block_diag\n",
    "from scipy.sparse import issparse\n",
    "import scipy.sparse.linalg as sla\n",
    "from scipy.sparse import csc_matrix\n",
    "\n",
    "\n",
    "import scipy.linalg as la\n",
    "\n",
    "import os\n",
    "root_folder = os.getcwd()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loadamo mrežu koju želimo parametrizirati:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "V, F  = igl.read_triangle_mesh(os.path.join(root_folder, \"camelhead.off\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pomočne funkcije:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "    def block_diag(*arrs):\n",
    "    \n",
    "        if arrs == ():\n",
    "            arrs = ([],)\n",
    "\n",
    "        arrs = [a.todense() for a in arrs]\n",
    "        arrs = [np.atleast_2d(a) for a in arrs]\n",
    "        bad_args = [k for k in range(len(arrs)) if arrs[k].ndim > 2]\n",
    "        if bad_args:\n",
    "            raise ValueError(\"arguments in the following positions have dimension \"\n",
    "                             \"greater than 2: %s\" % bad_args)\n",
    "        shapes = np.array([a.shape for a in arrs])\n",
    "        out_dtype = np.find_common_type([arr.dtype for arr in arrs], [])\n",
    "        out = np.zeros(np.sum(shapes, axis=0), dtype=out_dtype)\n",
    "\n",
    "        r, c = 0, 0\n",
    "        for i, (rr, cc) in enumerate(shapes):\n",
    "            out[r:r + rr, c:c + cc] = arrs[i]\n",
    "            r += rr\n",
    "            c += cc\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vector_area_matrix(F):\n",
    "    n = F.max()+1\n",
    "    E = igl.boundary_facets(F)\n",
    "    \n",
    "    triplets = np.zeros((4*E.shape[0],3))\n",
    "    \n",
    "    for k in range (E.shape[0]):\n",
    "        i= E[k,0]\n",
    "        j= E[k,1]\n",
    "        triplets[4*k]=[i+n, j, -0.25]\n",
    "        triplets[4*k+1]=[j, i+n, -0.25]\n",
    "        triplets[4*k+2]=[i, j+n, 0.25]\n",
    "        triplets[4*k+3]=[j+n, i, 0.25]\n",
    "        \n",
    "    \n",
    "    A = np.zeros((n*2,n*2))\n",
    "    \n",
    "    for row in triplets:\n",
    "        A[int(row[0]),int(row[1])] += row[2]\n",
    "    return A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Harmonijsko preslikavanje"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = igl.boundary_loop(F)\n",
    "\n",
    "bc = igl.map_vertices_to_circle(V,b)\n",
    "\n",
    "L = igl.cotmatrix(V,F)\n",
    "\n",
    "Q = -L\n",
    "\n",
    "B=np.zeros((V.shape[0],2))\n",
    "Aeq = sp.sparse.csc_matrix(np.zeros((1,V.shape[0])))\n",
    "Beq = np.zeros((1,2))\n",
    "\n",
    "_, Harmonic_uv=igl.min_quad_with_fixed(Q, B, b, bc, Aeq, Beq, False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Baricentrično konveksno preslikavanje"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find boundary vertices\n",
    "b = igl.boundary_loop(F)\n",
    "# Map them to circle\n",
    "bc = igl.map_vertices_to_circle(V,b)\n",
    "\n",
    "# List interior & boundary vertices\n",
    "e = igl.boundary_facets(F)\n",
    "v_b = np.unique(e)\n",
    "v_all = np.arange(V.shape[0])\n",
    "\n",
    "# List of interior indices\n",
    "v_in = np.setdiff1d(v_all, b)\n",
    "\n",
    "# Adjacency matrix for given mesh\n",
    "a = igl.adjacency_matrix(F)\n",
    "# Sum each row to get diagonal\n",
    "a_sum = np.sum(a, axis=1)\n",
    "a_sumsum = np.array(a_sum).ravel()\n",
    "# Convert row sums into diagonal of sparse matrix\n",
    "a_diag = np.diag(a_sumsum)\n",
    "# Build uniform laplacian of graph\n",
    "u = a - a_diag\n",
    "\n",
    "# Prepare system matrix\n",
    "l_ii = u[v_in, :]\n",
    "l_ii = l_ii[:, v_in]\n",
    "l_ib = u[v_in, :]\n",
    "l_ib = l_ib[:, b]\n",
    "\n",
    "## Solve PDE\n",
    "xs = sla.spsolve(-l_ii, np.transpose(l_ib.dot(bc[:,0])))\n",
    "ys = sla.spsolve(-l_ii, np.transpose(l_ib.dot(bc[:,1])))\n",
    "uv= np.column_stack((xs,ys))\n",
    "\n",
    "# Write vertices in correct order\n",
    "Barycentric_uv= np.zeros((V.shape[0],2))\n",
    "Barycentric_uv[v_in, :] = uv\n",
    "Barycentric_uv[b, :] = bc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Konveksno preslikavanje srednje vrijednosti"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find boundary vertices\n",
    "b = igl.boundary_loop(F)\n",
    "# Map them to circle\n",
    "bc = igl.map_vertices_to_circle(V,b)\n",
    "\n",
    "# List interior & boundary vertices\n",
    "e = igl.boundary_facets(F)\n",
    "v_b = np.unique(e)\n",
    "v_all = np.arange(V.shape[0])\n",
    "\n",
    "# List of interior indices\n",
    "v_in = np.setdiff1d(v_all, b)\n",
    "\n",
    "# Find distance between all points in the mesh\n",
    "distances = igl.all_pairs_distances(V,V, False)\n",
    "# Find angle values for each triangle in a mesh\n",
    "angles = igl.internal_angles(V,F)\n",
    "\n",
    "# Prob not needed\n",
    "tt, tti = igl.triangle_triangle_adjacency(F)\n",
    "neighbours = igl.adjacency_matrix(F)\n",
    "\n",
    "# Create edge topology, edges-vertices, faces-edges, edges-faces:\n",
    "ev, fe, ef = igl.edge_topology(V,F)\n",
    "\n",
    "# Initialize system matrix\n",
    "weights = np.zeros((V.shape[0],V.shape[0]))\n",
    "\n",
    "# For given list of triangles and a vertex, find edges opposite vertex v\n",
    "def find_edges(triangles, vertex, ev):\n",
    "    target_edges = []\n",
    "    for triangle in triangles:\n",
    "        for edge in triangle:\n",
    "            if vertex not in ev[edge]:\n",
    "                target_edges = np.append(target_edges, edge)\n",
    "    return target_edges\n",
    "\n",
    "# Start building system matrix\n",
    "for i in range(ev.shape[0]):\n",
    "    v_i, v_j = ev[i][0], ev[i][1]\n",
    "    if ((v_i not in b) or (v_j not in b)):\n",
    "        distance = distances[v_i,v_j]\n",
    "        # Triangles that belong to i-th edge: ef[i,:]\n",
    "        # All edges in those triangles:\n",
    "        all_edges = fe[ef[i,:],:]\n",
    "        # Angles inside those triangles\n",
    "        relevant_angles = angles[ef[i,:],]\n",
    "        # Of those edges, find the one that v_i doesn't belong to\n",
    "        #(the one opposite v_i)\n",
    "        relevant_edges_i = find_edges(all_edges, v_i, ev)\n",
    "        # Find the angles\n",
    "        alphas_i=relevant_angles[np.isin(all_edges,relevant_edges_i)]\n",
    "        # Add to system matrix\n",
    "        weights[v_i,v_j] = (np.tan(0.5*alphas_i[0])+np.tan(0.5*alphas_i[1]))/distance\n",
    "        # Do the same for edge in opposite direction\n",
    "        relevant_edges_j = find_edges(all_edges, v_j, ev)\n",
    "        alphas_j=relevant_angles[np.isin(all_edges,relevant_edges_j)]\n",
    "        weights[v_j,v_i] = (np.tan(0.5*alphas_j[0])+np.tan(0.5*alphas_j[1]))/distance\n",
    "\n",
    "# Add diagonal to system matrix\n",
    "w_sum = np.sum(weights, axis=1)\n",
    "w_sumsum = np.array(w_sum).ravel()\n",
    "w_diag = np.diag(w_sumsum)\n",
    "u = weights - w_diag\n",
    "\n",
    "# Prepare system matrix for efficient solve\n",
    "l_ii = u[v_in, :]\n",
    "l_ii = l_ii[:, v_in]\n",
    "l_ib = u[v_in, :]\n",
    "l_ib = l_ib[:, b]\n",
    "\n",
    "## Solve PDE\n",
    "xs = sla.spsolve(-l_ii, np.transpose(l_ib.dot(bc[:,0])))\n",
    "ys = sla.spsolve(-l_ii, np.transpose(l_ib.dot(bc[:,1])))\n",
    "uv= np.column_stack((xs,ys))\n",
    "\n",
    "# Write vertices in correct order\n",
    "Convex_uv= np.zeros((V.shape[0],2))\n",
    "Convex_uv[v_in, :] = uv\n",
    "Convex_uv[b, :] = bc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Konformalno preslikavanje najmanjih kvadrata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.array([2, 1])\n",
    "bnd = igl.boundary_loop(F)\n",
    "points = np.take(V, bnd, axis=0)\n",
    "\n",
    "# Max distance between points\n",
    "D = sp.spatial.distance.pdist(points)\n",
    "D = sp.spatial.distance.squareform(D);\n",
    "N, [I_row, I_col] = np.nanmax(D), np.unravel_index( np.argmax(D), D.shape )\n",
    "\n",
    "# Random points\n",
    "#b[0] = bnd[0]\n",
    "#b[1] = bnd[int(bnd.size / 2 )]\n",
    "\n",
    "#maxdistance\n",
    "b[0] = bnd[I_row]\n",
    "b[1] = bnd[I_col]\n",
    "\n",
    "bc = np.array([[0.0, 0.0], [1.0, 0.0]])\n",
    "\n",
    "## Assemble the area matrix (note that A is #Vx2 by #Vx2)\n",
    "A = vector_area_matrix(F)\n",
    "\n",
    "L = igl.cotmatrix(V,F)\n",
    "\n",
    "L_flat = block_diag(L,L)\n",
    "\n",
    "b_flat = np.zeros((b.size*bc.shape[1],1))\n",
    "bc_flat =  np.zeros((bc.size,1))\n",
    "\n",
    "for column in range(np.shape(bc)[1]):\n",
    "    b_flat[column*b.size : column*b.size+ b.shape[0]] = column*V.shape[0] + b.reshape(b.size,1)\n",
    "    bc_flat[column*bc.shape[0]:(column+1)*bc.shape[0]] = bc[:,column].reshape(2,1)\n",
    "\n",
    "## Minimize the LSCM energy\n",
    "L_diag_sparse = csc_matrix(L_flat)\n",
    "\n",
    "Q = csc_matrix(2*A) - csc_matrix(L_diag_sparse)\n",
    "\n",
    "B_flat = np.zeros((V.shape[0]*2,1))\n",
    "    \n",
    "B=np.zeros((V.shape[0],2))\n",
    "Aeq = sp.sparse.csc_matrix(np.zeros((1,V.shape[0]*2)))\n",
    "Beq = np.zeros((1,1))\n",
    "    \n",
    "_, W_flat=igl.min_quad_with_fixed(Q, B_flat, b_flat.astype(int), bc_flat, Aeq, Beq, True)\n",
    "    \n",
    "LSCM_uv=np.zeros((V.shape[0],2))\n",
    "\n",
    "for column in  range(LSCM_uv.shape[1]):\n",
    "        LSCM_uv[:,LSCM_uv.shape[1]-column-1] = W_flat[LSCM_uv.shape[0]*column : LSCM_uv.shape[0]*(column+1)]\n",
    "\n",
    "# LSCM parametrization\n",
    "#_, LSCM_uv = igl.lscm(V, F, b, bc)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Spektralno konformalno preslikavanje"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = vector_area_matrix(F)\n",
    "L = igl.cotmatrix(V, F)\n",
    "L_diag = block_diag(L,L)\n",
    "L_diag_sparse = csc_matrix(L_diag)\n",
    "\n",
    "\n",
    "Q = csc_matrix(L_diag_sparse) - csc_matrix(2 * A)\n",
    "\n",
    "M=igl.massmatrix(V, F, igl.MASSMATRIX_TYPE_VORONOI)\n",
    "\n",
    "B = block_diag(M,M)\n",
    "\n",
    "lamb, v = sla.eigs(Q, 3, csc_matrix(B), which='LM', sigma = 0 )\n",
    "\n",
    "Spec_uv = np.zeros((V.shape[0],2))\n",
    "Spec_uv[:,0] = v[:V.shape[0],2]\n",
    "Spec_uv[:,1] = v[V.shape[0]:,2]\n",
    "\n",
    "\n",
    "u_1, s_1, v_1 = np.linalg.svd(np.dot( np.transpose(Spec_uv), Spec_uv), full_matrices=False)\n",
    "\n",
    "\n",
    "Spec_uv = np.dot(Spec_uv,u_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vizualizacija rezultata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = plot(V, F, return_plot=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Harmonijsko"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p0 = plot(V, F, return_plot=True)\n",
    "\n",
    "@interact(mode=['3D (originalan model)','2D (parametrizacija)', '2D (uv-izolinije)', '3D (s uv-izolinijama)'])\n",
    "def switch(mode):\n",
    "    if mode == \"3D (originalan model)\":\n",
    "        plot(V, F, shading={\"wireframe\": True, \"flat\": False}, plot=p0)\n",
    "    if mode == \"2D (parametrizacija)\":\n",
    "        plot(Harmonic_uv, F, shading={\"wireframe\": True}, plot=p0)\n",
    "    if mode == \"2D (uv-izolinije)\":\n",
    "        plot(Harmonic_uv, F, uv=Harmonic_uv, shading={\"wireframe\": False}, plot=p0)\n",
    "    if mode == \"3D (s uv-izolinijama)\":\n",
    "        plot(V, F, uv=Harmonic_uv, shading={\"wireframe\": False, \"flat\": False}, plot=p0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Baricentrične koodrinate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1 = plot(V, F, return_plot=True)\n",
    "\n",
    "@interact(mode=['3D (originalan model)','2D (parametrizacija)', '2D (uv-izolinije)', '3D (s uv-izolinijama)'])\n",
    "def switch(mode):\n",
    "    if mode == \"3D (originalan model)\":\n",
    "        plot(V, F, shading={\"wireframe\": True, \"flat\": False}, plot=p1)\n",
    "    if mode == \"2D (parametrizacija)\":\n",
    "        plot(Barycentric_uv, F, shading={\"wireframe\": True}, plot=p1)\n",
    "    if mode == \"2D (uv-izolinije)\":\n",
    "        plot(Barycentric_uv, F, uv=Barycentric_uv, shading={\"wireframe\": False}, plot=p1)\n",
    "    if mode == \"3D (s uv-izolinijama)\":\n",
    "        plot(V, F, uv=Barycentric_uv, shading={\"wireframe\": False, \"flat\": False}, plot=p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Konveksno preslikavanje srednje vrijednosti"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p2 = plot(V, F, return_plot=True)\n",
    "\n",
    "@interact(mode=['3D (originalan model)','2D (parametrizacija)', '2D (uv-izolinije)', '3D (s uv-izolinijama)'])\n",
    "def switch(mode):\n",
    "    if mode == \"3D (originalan model)\":\n",
    "        plot(V, F, shading={\"wireframe\": True, \"flat\": False}, plot=p2)\n",
    "    if mode == \"2D (parametrizacija)\":\n",
    "        plot(Convex_uv, F, shading={\"wireframe\": True}, plot=p2)\n",
    "    if mode == \"2D (uv-izolinije)\":\n",
    "        plot(Convex_uv, F, uv=Convex_uv, shading={\"wireframe\": False}, plot=p2)\n",
    "    if mode == \"3D (s uv-izolinijama)\":\n",
    "        plot(V, F, uv=Convex_uv, shading={\"wireframe\": False, \"flat\": False}, plot=p2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Konformalno preslikavanje najmanjih kvadrata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p3 = plot(V, F, return_plot=True)\n",
    "\n",
    "@interact(mode=['3D (originalan model)','2D (parametrizacija)', '2D (uv-izolinije)', '3D (s uv-izolinijama)'])\n",
    "def switch(mode):\n",
    "    if mode == \"3D (originalan model)\":\n",
    "        plot(V, F, shading={\"wireframe\": True, \"flat\": False}, plot=p3)\n",
    "    if mode == \"2D (parametrizacija)\":\n",
    "        plot(LSCM_uv, F, shading={\"wireframe\": True}, plot=p3)\n",
    "        p3.add_points( LSCM_uv[b[0]], shading={\"point_color\": \"red\", \"point_size\": .1})\n",
    "        p3.add_points( LSCM_uv[b[1]], shading={\"point_color\": \"red\", \"point_size\": .1})\n",
    "    if mode == \"2D (uv-izolinije)\":\n",
    "        plot(LSCM_uv, F, uv=LSCM_uv, shading={\"wireframe\": False}, plot=p3)\n",
    "        p3.add_points( LSCM_uv[b[0]], shading={\"point_color\": \"red\", \"point_size\": .1})\n",
    "        p3.add_points( LSCM_uv[b[1]], shading={\"point_color\": \"red\", \"point_size\": .1})\n",
    "    if mode == \"3D (s uv-izolinijama)\":\n",
    "        plot(V, F, uv=LSCM_uv, shading={\"wireframe\": False, \"flat\": False}, plot=p3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Spektralno konformalno preslikavanje"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p4 = plot(V, F, return_plot=True)\n",
    "\n",
    "@interact(mode=['3D (originalan model)','2D (parametrizacija)', '2D (uv-izolinije)', '3D (s uv-izolinijama)'])\n",
    "def switch(mode):\n",
    "    if mode == \"3D (originalan model)\":\n",
    "        plot(V, F, shading={\"wireframe\": True, \"flat\": False}, plot=p4)\n",
    "    if mode == \"2D (parametrizacija)\":\n",
    "        plot(Spec_uv, F, shading={\"wireframe\": True}, plot=p4)\n",
    "    if mode == \"2D (uv-izolinije)\":\n",
    "        plot(Spec_uv, F, uv=Spec_uv, shading={\"wireframe\": False}, plot=p4)\n",
    "    if mode == \"3D (s uv-izolinijama)\":\n",
    "        plot(V, F, uv=Spec_uv, shading={\"wireframe\": False, \"flat\": False}, plot=p4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mjere"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Flipped triangles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "igl.flipped_triangles(Harmonic_uv,F).size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " $\\rightarrow$ nema okrenutih trokuta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "igl.flipped_triangles(Barycentric_uv,F).size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "igl.flipped_triangles(Convex_uv,F).size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "igl.flipped_triangles(LSCM_uv,F).size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "igl.flipped_triangles(Spec_uv,F).size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Kvaliteta trokuta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quality_fun(angles):\n",
    "    return 4*(np.sin(angles[0])*np.sin(angles[1])*np.sin(angles[2]))/(np.sin(angles[0]) + np.sin(angles[1]) + np.sin(angles[2]))\n",
    "\n",
    "def min_mean(angle_list):\n",
    "    results = []\n",
    "    for angles in angle_list:\n",
    "        results = np.append(results, quality_fun(angles))\n",
    "    return np.min(results), np.mean(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Harmonic_angles = igl.internal_angles(Harmonic_uv,F)\n",
    "\n",
    "print(min_mean(Harmonic_angles))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Barycentric_angles = igl.internal_angles(Barycentric_uv,F)\n",
    "\n",
    "print(min_mean(Barycentric_angles))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Convex_angles = igl.internal_angles(Convex_uv,F)\n",
    "\n",
    "print(min_mean(Convex_angles))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "LSCM_angles = igl.internal_angles(LSCM_uv,F)\n",
    "\n",
    "print(min_mean(LSCM_angles))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Spec_angles = igl.internal_angles(Spec_uv,F)\n",
    "\n",
    "print(min_mean(Spec_angles))"
   ]
  }
 ],
 "metadata": {
  "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}