Clustering.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reverse engineering of CAD models via clustering and approximate implicitization\n",
    "### Andrea Raffo, Oliver Barrowclough and Georg Muntingh\n",
    "\n",
    "This Jupyter notebook contains a Python implementation of the algorithm presented in [1], for extracting primitive geometry underlying point clouds, for instance originating from CAD models, parametric Bézier or spline curves, by combining clustering analysis and approximate implicitization.\n",
    "\n",
    "The proposed method can recover algebraic hypersurfaces of any degree and is automatic, in the sense that all the required parameters, such as the implicit degree of the patches and the number\n",
    "of clusters of the model, are inferred. The efficiency of the algorithm is determined from numerical experiments.\n",
    "\n",
    "[1] A. Raffo, O.J.D. Barrowclough, G. Muntingh, _Reverse engineering of CAD models via clustering and approximate implicitization_, available at https://arxiv.org/abs/1810.07451.\n",
    "\n",
    "## The algorithm\n",
    "### Importing libraries and parameters\n",
    "We import standard Python libraries for numerics, plotting and timing. The algorithm will search for hypersurfaces up to degree `d_max`. The number of sampling points per patch is represented by `ns`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import colors as mcolors\n",
    "import sys\n",
    "import time\n",
    "import timeit\n",
    "timeit.default_timer()\n",
    "\n",
    "d_max = 2\n",
    "ns    = 10\n",
    "\n",
    "graphics_path = \"./figs/\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Approximate implicitization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "39.2 µs ± 998 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "monomial_exponents = [np.array([[i,j] for i in range(d+1) for j in range(d-i+1)], dtype = float) for d in range(1,d_max+1)]\n",
    "dim_bases = [(d+1)*(d+2) // 2 for d in range(1,d_max+1)]\n",
    "\n",
    "def approx_implicit(d, segments):\n",
    "    \"\"\"\n",
    "    Given a degree `d`, number of sampling points `n_sample`, and segment matrix `segments`,\n",
    "    return the singular value `S[-1]` corresponding to the approximate implicit form with\n",
    "    smallest algebraic error.\n",
    "    \"\"\"\n",
    "    n_sample = segments.shape[1] // 2\n",
    "    \n",
    "    # Polynomial basis of the approximate implicit form\n",
    "    dim_basis = dim_bases[d-1]\n",
    "    bb = monomial_exponents[d-1]\n",
    "    \n",
    "    # Degree approximation\n",
    "    xx = segments[0,:n_sample].T\n",
    "    yy = segments[0,n_sample:2*n_sample].T\n",
    "    if d == 1:\n",
    "        A = np.concatenate([np.ones((n_sample, 1)), xx, yy], axis = 1)\n",
    "    elif d == 2:\n",
    "        A = np.concatenate([np.ones((n_sample, 1)), xx, yy, np.multiply(xx,xx), np.multiply(xx,yy), np.multiply(yy,yy)], axis = 1)\n",
    "    else:\n",
    "        A = np.asmatrix(np.ones((n_sample, dim_basis)))\n",
    "        for kk in range(1, dim_basis):\n",
    "            if bb[kk,1] == 0:\n",
    "                A[:,kk] = np.asmatrix(np.power(segments[0,0:n_sample].T, bb[kk,0]))\n",
    "            elif bb[kk,0] == 0:\n",
    "                A[:,kk] = np.asmatrix(np.power(segments[0,n_sample:2*n_sample].T, bb[kk,1]))\n",
    "            else:\n",
    "                A[:,kk] = np.asmatrix(np.squeeze(np.asarray(np.power(segments[0,0:n_sample].T,bb[kk,0])))*\\\n",
    "                                      np.squeeze(np.asarray(np.power(segments[0,n_sample:2*n_sample].T,bb[kk,1])))).T\n",
    "\n",
    "    S = np.linalg.svd(A, compute_uv=False)\n",
    "    return 0, S[-1]\n",
    "\n",
    "segments_joined = np.matrix([[1.54602091, 1.50307588, 1.46013086, 1.41718583, 1.37424081, 1.33129578, 1.28835076, 1.24540573, 1.20246071,  1.15951568,  0.19603428,  0.19058888, 0.18514349,  0.17969809,  0.17425269,  0.1688073 ,  0.1633619 ,  0.1579165,  0.15247111,  0.14702571,  1.26878657,  1.2335425 ,  1.19829843,  1.16305435, 1.12781028, 1.09256621, 1.05732214, 1.02207807, 0.986834, 0.95158993, -1.99036945, -1.93508141, -1.87979337, -1.82450533, -1.76921729, -1.71392925, -1.65864121, -1.60335317, -1.54806513, -1.49277709]])\n",
    "%timeit approx_implicit(2, segments_joined)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calibration and pre-processing\n",
    "We would like to distinguish the point clouds corresponding to linear segments from conical segments. For this we derive a tolerance `tol1` using the approach in [1, Algorithm 3.3??]. In addition we introduce a tolerance `tol0` to be used in the stopping criterion (deciding the final number of clusters), which is here introduced manually, but can alternatively be computed using [1, Algorithm 3.6??]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.4899359177884646e-09\n"
     ]
    }
   ],
   "source": [
    "def supervised_criterion(ns = 10, NS = 300):\n",
    "    \"\"\"    \n",
    "    Given a number `NS` of segments for each type of conic, each to be sampled\n",
    "    at `ns` points, return the tolerance `tol1` separating singular values of\n",
    "    linear segments from those of conical segments.\n",
    "    \"\"\"\n",
    "\n",
    "    # We consider parametric conics as a linear combination of 4 affine types:\n",
    "    # (1=line, 2=ellipse, 3=hyperbola, 4=parabola)\n",
    "    f = lambda tau, t: tau[0]*np.matrix([            t,           t]) + \\\n",
    "                       tau[1]*np.matrix([  math.cos(t), math.sin(t)]) + \\\n",
    "                       tau[2]*np.matrix([1/math.cos(t), math.tan(t)]) + \\\n",
    "                       tau[3]*np.matrix([            t,        t**2])\n",
    "\n",
    "    # We will generate 2*NS segments of type L_seg_type[type - 1].\n",
    "    L_seg_type = NS*[0] + (NS // 3)*[1] + (NS // 3)*[2] + (NS // 3)*[3]\n",
    "    \n",
    "    # Parametric intervals of definitions for the segments of type=1,2,3,4.\n",
    "    intervals = np.matrix([[-10,10], [0,2*math.pi], [-1.47,1.47], [-3,3]])\n",
    "\n",
    "    # `theta` is a list of random rotations for each segment\n",
    "    theta = np.random.rand(1,2*NS)*2*math.pi\n",
    "\n",
    "    # Matrix containing, for each row, the ns points sampled from a section. The\n",
    "    # points are stored as follows: the first ns coordinate of each row\n",
    "    # represent the x-coordinates, while the last ns are the y-coordinates.\n",
    "    segments = np.asmatrix(np.zeros((1, 2*ns+2)))\n",
    "    \n",
    "    # Assemble a matrix `segments` of point clouds of 2*NS segments of random types\n",
    "    for k in range(2*NS):\n",
    "        # Sampling of the endpoints of the parametric interval, for each segment\n",
    "        seg_type = L_seg_type[k]\n",
    "        sample_interval = intervals[seg_type, 0] + np.asmatrix(np.random.rand(1,2)) *\\\n",
    "                         (intervals[seg_type, 1] - intervals[seg_type, 0])\n",
    "        \n",
    "        sample_interval.sort()\n",
    "        \n",
    "        # Sampling of `ns` parameters for each parametric interval\n",
    "        sample = np.linspace(sample_interval[0,0], sample_interval[0,1], num=ns)\n",
    "        \n",
    "        # We consider the 1-hot encoding `tau` of the segment type\n",
    "        tau = [int(i == seg_type) for i in range(4)]\n",
    "        \n",
    "        # Sampling of the points for each conic section\n",
    "        sample_final = np.asmatrix(np.zeros((1, 2*ns+2)))\n",
    "        for j in range(ns):\n",
    "            sample_final[0,[j,j+ns]] = f(tau, sample[j])\n",
    "\n",
    "        # Exact algebraic variety degree is encoded as the penultimate column\n",
    "        sample_final[:,2*ns] = (seg_type != 0) + 1\n",
    "    \n",
    "        # Apply a rotation\n",
    "        R = np.matrix([[np.cos(theta[0,k]), -np.sin(theta[0,k])],\\\n",
    "                       [np.sin(theta[0,k]),  np.cos(theta[0,k])]])\n",
    "        \n",
    "        for i in range(ns):\n",
    "            sample_final[0,[i,i+ns]] = np.dot(R, sample_final[0,[i,i+ns]].T).T\n",
    "  \n",
    "        # Apply a component-wise dilatation and translation\n",
    "        sample_final[:, 0:  ns] = sample_final[:, 0:  ns] + (np.random.rand(1,1)[0,0]*20 - 10)\n",
    "        sample_final[:, 0:  ns] = sample_final[:, 0:  ns]*(1/20) # Scale to the interval [-1, 1]\n",
    "        sample_final[:,ns:2*ns] = sample_final[:,ns:2*ns] + (np.random.rand(1,1)[0,0]*20 - 10)\n",
    "        sample_final[:,ns:2*ns] = sample_final[:,ns:2*ns]*(1/20) # Scale to the interval [-1, 1]\n",
    "        segments = np.concatenate((segments,sample_final), axis=0)\n",
    "    \n",
    "    segments = segments[1:,:]    \n",
    "    \n",
    "    measures_lin = np.array([[approx_implicit(1, segments[i   ,0:2*ns])[1] for i in range(NS)]])\n",
    "    measures_con = np.array([[approx_implicit(1, segments[i+NS,0:2*ns])[1] for i in range(NS)]])\n",
    "\n",
    "    # The tolerance is the geometric mean of the average singular values\n",
    "    # for linear and conical segments.\n",
    "    tol1 = math.sqrt(np.mean(measures_lin[0])*np.mean(measures_con[0]))\n",
    "    \n",
    "    # Alternatively, one can take the geometric mean of the maximum\n",
    "    # linear singular value and minimum conical singular value.\n",
    "    #tol1 = math.sqrt(max(measures_lin[0])*min(measures_con[0]))\n",
    "    return tol1\n",
    "\n",
    "tol1 = supervised_criterion(ns = ns, NS = 30); print(tol1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assembling and updating dissimilarity matrices\n",
    "We construct an np.matrix of size $(\\#segments)\\times (2n_s + 2)$, for which the first $2n_s$ columns are coordinates of sampled points. The last column will denote will contain the degree as detected by the preprocessing step. The penultimate column will contain the degree as designed (1 for concentric line segments, and 2 for the circle segments)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def segment_dissimilarity_matrix(segments, ns, deg):\n",
    "    \"\"\"\n",
    "    For a given degree `deg`, number of segment sampling points `ns`, and\n",
    "    sampling array `segments`, assemble the dissimilarity matrix for the\n",
    "    segments.\n",
    "    \"\"\"\n",
    "    \n",
    "    n = segments.shape[0] \n",
    "    D = np.matrix(np.zeros((n, n)))\n",
    "    for i in range(n):\n",
    "        for j in range(i+1,n):\n",
    "            segment1 = np.concatenate((segments[i, 0:  ns], segments[j, 0:  ns]), axis=1)\n",
    "            segment2 = np.concatenate((segments[i,ns:2*ns], segments[j,ns:2*ns]), axis=1)\n",
    "            two_segments_joined = np.concatenate((segment1, segment2), axis=1)\n",
    "            b, d = approx_implicit(deg, two_segments_joined)\n",
    "            D[i,j] = d\n",
    "    \n",
    "    return D + D.T\n",
    "\n",
    "def update_cluster_dissimilarity_matrix(D, segment_labels, label1, label2):\n",
    "    \"\"\" Update the cluster dissimilarity matrix `D` from `segment_labels`, by\n",
    "        merging the clusters with indices `row` and `col`.\n",
    "    \"\"\"\n",
    "    \n",
    "    # label1 and label2 are indices of the clusters with ordered labels:\n",
    "    label1, label2 = min(label1, label2), max(label1, label2)\n",
    "    \n",
    "    # number of segments:\n",
    "    n_segments = len(segment_labels)\n",
    "    \n",
    "    # update dissimilarity matrix:\n",
    "    for i in range(D.shape[0]):\n",
    "        D[label1,i] = max(D[label1,i], D[label2,i])\n",
    "        D[i,label1] = max(D[i,label1], D[i,label2])\n",
    "    # maxvec = np.ones(len(D[0]))*sys.float_info.max\n",
    "    # D[label2,:] = maxvec\n",
    "    # D[:,label2] = maxvec\n",
    "    D[label2,:] = sys.float_info.max\n",
    "    D[:,label2] = sys.float_info.max\n",
    "\n",
    "    \n",
    "    # update segment_labels with respect to the merging clusters:\n",
    "    I=[i for i in range(n_segments) if segment_labels[i]==label2]\n",
    "    for i in I:\n",
    "        segment_labels[i]=label1\n",
    "    \n",
    "    return D, segment_labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Clustering procedure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clustering_by_degree(segments, ns, deg, verbose = False):\n",
    "    \"\"\"\n",
    "    For a given degree `deg`, number of segment sampling points `ns`, and\n",
    "    sampling array `segments`, starting from a cluster for each segment,\n",
    "    iterative merge clusters with smallest dissimilarity (singular value),\n",
    "    keeping a list `segment_labels` of cluster labels for each segment.\n",
    "    Return a list `SSV` of these smallest dissimilarities, together with \n",
    "    a list `segment_labels_history` of the `segment_labels` in each\n",
    "    step.\n",
    "    \"\"\"\n",
    "    \n",
    "    # compute the dissimilarity matrix at iteration 0 and print the time:\n",
    "    t0 = time.time()\n",
    "    D = segment_dissimilarity_matrix(segments, ns, deg)\n",
    "    assembling_time = time.time() - t0\n",
    "    if verbose:\n",
    "        print(\"Assembling the segment dissimilarity_matrix took\", assembling_time, \"seconds\")\n",
    "    \n",
    "    # number of segments:\n",
    "    n = D.shape[0]\n",
    "    \n",
    "    # smallest dissimilarities (singular value) in the clustering steps:\n",
    "    SSV = []\n",
    "    \n",
    "    # at the first step each segment is in its own cluster:\n",
    "    segment_labels = list(range(n))\n",
    "    # we keep track of the clustering procedures by means of segment_labels_history:\n",
    "    segment_labels_history = np.asmatrix(segment_labels)\n",
    "    \n",
    "    # set the elements in the diagonal to infinity:\n",
    "    D = D + np.diag(D.shape[0]*[math.inf])    \n",
    "\n",
    "    t0 = time.time()\n",
    "    t1a = 0\n",
    "    t1b = 0\n",
    "    t2 = 0\n",
    "    for it in range(n - 1):\n",
    "        t_old_1 = time.time()\n",
    "        # find the segments with indices row, col with minimum dissimilarity:\n",
    "        Dmin = D.argmin()\n",
    "        t1a = t1a + time.time()-t_old_1\n",
    "        t_old_1 = time.time()\n",
    "        # find the segments with indices row, col with minimum dissimilarity:\n",
    "        row, col = np.unravel_index(Dmin, D.shape)\n",
    "        t1b = t1b + time.time()-t_old_1\n",
    "        # keep track of the dissimilarity between the merging clusters:\n",
    "        SSV.append(D[row, col])\n",
    "        # update the dissimilarity matrix:\n",
    "        t_old_2 = time.time()\n",
    "        D, segment_labels = update_cluster_dissimilarity_matrix(D, segment_labels, row, col) \n",
    "        t2 = t2 + time.time() - t_old_2\n",
    "        # keep track on how the partition changed by updating segment_labels_history:\n",
    "        segment_labels_history = np.concatenate((segment_labels_history, np.asmatrix(segment_labels)), axis = 0)\n",
    "    \n",
    "    #print the time for the clustering procedure:\n",
    "    clustering_time = time.time() - t0\n",
    "    if verbose:\n",
    "        print(\"The remaining successive clustering took\", clustering_time, \"seconds:\")\n",
    "        print(\"finding the minimum costs \", t1a, \"seconds\")\n",
    "        print(\"finding the row and column indices \", t1b, \"seconds\")\n",
    "        print(\"update the dissimilarity matrix costs\", t2, \"seconds\")\n",
    "    \n",
    "    return SSV, segment_labels_history, assembling_time, clustering_time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numerical experiments: 2D gear\n",
    "To test the performance of the implementation, we create a 2D gear with `T` uniformly spaced teeth and inner circle of radius `R1`, outer circle of radius `R2`, and intermediate circle of radius `R3`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example parameters\n",
    "R1 = 1\n",
    "R2 = 2\n",
    "R3 = 1.5\n",
    "T  = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making the test data\n",
    "Using functions for creating uniformly spaced point clouds of (Bezier segments approximating) circles with radius `R` and initial segment angle `offset`, we create the point clouds of the segments of a 2D gear with `T` teeth. These point clouds are assembled in two segment matrices, one for the linear segments and one for the conical segments, which constitute a list `L_segments`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def binomial(i, j):\n",
    "    \"\"\" Return the binomial coefficient {i+j\\choose i}. \"\"\"\n",
    "    try:\n",
    "        binom = math.factorial(i+j) // math.factorial(i) // math.factorial(j)\n",
    "    except ValueError:\n",
    "        binom = 0\n",
    "    return binom\n",
    "\n",
    "def bernstein_polynomial(i, deg, t):\n",
    "    \"\"\" Return the `i`-th Bernstein polynomial of degree `deg` evaluated at `t`. \"\"\"\n",
    "    return binomial(i, deg-i) * t**i * (1-t)**(deg-i)\n",
    "\n",
    "def bernstein_polynomials(deg, L_t):\n",
    "    \"\"\" Return the `i`-th Bernstein polynomial of degree `deg` evaluated at `t`. \"\"\"\n",
    "    return np.array([[bernstein_polynomial(i, deg, t) for i in range(deg+1)] for t in L_t])\n",
    "\n",
    "def Bezier(L_c, L_t):\n",
    "    deg = L_c.shape[0] - 1\n",
    "    L_B = bernstein_polynomials(deg, L_t)\n",
    "    return np.einsum('ij,jk->ik', L_B, L_c)\n",
    "\n",
    "def Bezier_circle_segments(R, T, num, offset):\n",
    "    \"\"\"\n",
    "    For the cubic Bezier approximation of a circle with radius `R` and origin (0,0), return\n",
    "    an np.array with `num` evenly spaced points for each of the `T` evenly spaced segments,\n",
    "    the first of which starts with angle `offset`.\n",
    "    \"\"\"\n",
    "    delta_u = 2*np.pi/(2*T)\n",
    "    c = np.asmatrix(np.zeros((T,2*num)))\n",
    "    L_t = np.linspace(0, 1, num = num)\n",
    "        \n",
    "    for i in range(T):\n",
    "        # Construct the control points of the Bezier curve approximating the tooth.\n",
    "        p0 = np.array([         R*np.cos(offset          ),         R*np.sin(offset          )])\n",
    "        d0 = np.array([-delta_u*R*np.sin(offset          ), delta_u*R*np.cos(offset          )])\n",
    "        p1 = np.array([         R*np.cos(offset + delta_u),         R*np.sin(offset + delta_u)])\n",
    "        d1 = np.array([-delta_u*R*np.sin(offset + delta_u), delta_u*R*np.cos(offset + delta_u)])\n",
    "        L_c = np.array([p0, p0 + d0/3, p1 - d1/3, p1])\n",
    "\n",
    "        # Add a row for points sampled on this Bezier curve\n",
    "        c[i,:] = Bezier(L_c, L_t).T.reshape((1,2*num))\n",
    "        offset = offset + 2*delta_u\n",
    "\n",
    "    return c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def circle_entire(R, num):\n",
    "    \"\"\" \n",
    "    For the circle with radius `R` and origin (0,0), return an np.array with \n",
    "    `num` evenly spaced points including the point (R,0).\n",
    "    \"\"\"\n",
    "    u = np.linspace(0, 2*np.pi, num = num)\n",
    "    return np.concatenate( (R*np.asmatrix(np.cos(u)), R*np.asmatrix(np.sin(u))), axis = 1)\n",
    "\n",
    "def circle_segments(R, T, num, offset):\n",
    "    \"\"\"\n",
    "    For the circle with radius `R` and origin (0,0), return an np.array with\n",
    "    `num` evenly spaced points for each of the `T` evenly spaced segments, the\n",
    "    first of which starts with angle `offset`.\n",
    "    \"\"\"\n",
    "    delta_u = 2*np.pi/(2*T)\n",
    "    c = np.asmatrix(np.zeros((T,2*num)))\n",
    "    a = np.linspace(offset, offset + delta_u, num=num)\n",
    "\n",
    "    for i in range(T):\n",
    "        c[i,0:num] = a + 2*i*delta_u\n",
    "        c[i,:] = np.concatenate((R*np.cos(c[i,0:num]), R*np.sin(c[i,0:num])), axis=1)\n",
    "\n",
    "    return c\n",
    "\n",
    "def segment_data(T, R1, R2, R3, ns, Bezier = True):\n",
    "    \"\"\"\n",
    "    For a 2D gear with `T` teeth, inner radius `R1`, outer radius `R2`, and\n",
    "    intermediate radius `R3`, return the point clouds of segments with `ns`\n",
    "    number of sampling points assembled as an (1+4*T, 2*ns + 2) matrix. The\n",
    "    last column will denote will contain the degree as detected by the pre-\n",
    "    processing step. The penultimate column will contain the degree as\n",
    "    designed (1 for concentric line segments, and 2 for the circle segments).\n",
    "    \"\"\"\n",
    "    \n",
    "    delta_u = 2*np.pi/(2*T)\n",
    "    c1 = circle_entire(R1, ns)\n",
    "    if Bezier:\n",
    "        c2 = Bezier_circle_segments(R2, T, ns, 0)\n",
    "        c3 = Bezier_circle_segments(R3, T, ns, delta_u)\n",
    "    else:\n",
    "        c2 = circle_segments(R2, T, ns, 0)\n",
    "        c3 = circle_segments(R3, T, ns, delta_u)\n",
    "    \n",
    "    sample_final = np.asmatrix(np.zeros((1+4*T, 2*ns+2)))\n",
    "    sample_final[0,0:2*ns] = c1[0,0:2*ns]\n",
    "    sample_final[0,  2*ns] = 2\n",
    "\n",
    "    for i in range(T):\n",
    "        sample_final[i+1  ,0:2*ns] = c2[i,0:2*ns]\n",
    "        sample_final[i+1  ,  2*ns] = 2\n",
    "        sample_final[i+1+T,0:2*ns] = c3[i,0:2*ns]\n",
    "        sample_final[i+1+T,  2*ns] = 2\n",
    "\n",
    "    for i in range(2*T):\n",
    "        si, ci = np.sin(i*delta_u), np.cos(i*delta_u)\n",
    "        sample_final[i+1+2*T, 0:  ns] = np.linspace(R2*ci, R3*ci, num=ns)\n",
    "        sample_final[i+1+2*T,ns:2*ns] = np.linspace(R2*si, R3*si, num=ns)\n",
    "        sample_final[i+1+2*T,   2*ns] = 1\n",
    "\n",
    "    return sample_final\n",
    "\n",
    "def determine_degree(segments, ns):\n",
    "    \"\"\"\n",
    "    Using the tolerance `tol1` and sampling matrix `segments` returned by\n",
    "    the function `segment_data`, let the last entry in each row of `segments'\n",
    "    be the suspected degree of this segment.\n",
    "    \"\"\"\n",
    "    for i in range(segments.shape[0]):\n",
    "        D, d = approx_implicit(1, segments[i,0:2*ns])\n",
    "        if d < tol1:\n",
    "            segments[i, 2*ns+1] = 1\n",
    "        else:\n",
    "            segments[i, 2*ns+1] = 2\n",
    "\n",
    "    return segments\n",
    "\n",
    "def segments_ordered(T, R1, R2, R3, ns, Bezier = True):\n",
    "    \"\"\"\n",
    "    For a 2D gear with `T` teeth, inner radius `R1`, outer radius `R2`, and\n",
    "    intermediate radius `R3`, return the point clouds of segments with `ns`\n",
    "    number of sampling points assembled as two np.arrays:\n",
    "        `segments_lin` with rows the segments of suspected degree 1;\n",
    "        `segments_con` with rows the segments of suspected degree 2.\n",
    "    \n",
    "    The last column will denote will contain the degree as detected by the\n",
    "    pre-processing step. The penultimate column will contain the degree as\n",
    "    designed (1 for concentric line segments, and 2 for the circle segments).\n",
    "    \"\"\"\n",
    "    segments = segment_data(T, R1, R2, R3, ns, Bezier = Bezier)\n",
    "    segments = determine_degree(segments, ns)\n",
    "\n",
    "    return [segments[[i for i in range(segments.shape[0]) if segments[i,-1] == d]] for d in [1,2]]\n",
    "\n",
    "L_segments = segments_ordered(T, R1, R2, R3, ns, Bezier = False)\n",
    "L_n = [segments.shape[0] for segments in L_segments]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualization\n",
    "We double check the routines for constructing the point clouds by plotting them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_gear(T, R1, R2, R3, num, Bezier = True):\n",
    "    \"\"\"\n",
    "    Plot the gear with `T` teeth, inner radius `R1`, outer radius `R2`,\n",
    "    and intermediate radius `R3`, by sampling 10*`num` points on the\n",
    "    inner circle, and `num` points on the remaining segments.\n",
    "    \"\"\"\n",
    "    delta_u = 2*np.pi/(2*T)\n",
    "    cc1 = circle_entire(R1, 10*num)\n",
    "    \n",
    "    if Bezier:\n",
    "        c2 = Bezier_circle_segments(R2, T, num, 0)\n",
    "        c3 = Bezier_circle_segments(R3, T, num, delta_u)\n",
    "    else:\n",
    "        c2 = circle_segments(R2, T, num, 0)\n",
    "        c3 = circle_segments(R3, T, num, delta_u)\n",
    "    \n",
    "    a = np.linspace(0, delta_u, num = num)\n",
    "    plt.plot(cc1[0,0:10*num].tolist()[0], cc1[0,10*num:20*num].tolist()[0], \\\n",
    "             linewidth=1.5, linestyle=\"-\", color='k')\n",
    "\n",
    "    # Circle segments\n",
    "    for i in range(T):\n",
    "        xx = np.asarray(c2[i,0:a.shape[0]]).tolist()[0]\n",
    "        yy = np.asarray(c2[i,a.shape[0]:(2*a.shape[0])]).tolist()[0]\n",
    "        plt.plot(xx, yy, color='k', linewidth=1.5, linestyle=\"-\")\n",
    "\n",
    "        xx = np.asarray(c3[i,0:a.shape[0]]).tolist()[0]\n",
    "        yy = np.asarray(c3[i,a.shape[0]:(2*a.shape[0])]).tolist()[0]\n",
    "        plt.plot(xx, yy, color='k', linewidth=1.5, linestyle=\"-\")\n",
    "\n",
    "    # Line segments\n",
    "    for i in range(2*T):\n",
    "        plt.plot([R2*np.cos(i*delta_u), R3*np.cos(i*delta_u)],\n",
    "                 [R2*np.sin(i*delta_u), R3*np.sin(i*delta_u)], color='k', linewidth=1.5, linestyle=\"-\")\n",
    "\n",
    "    plt.axis('equal')\n",
    "    plt.axis('off')\n",
    "    plt.axis([- R2, R2, - R2, R2])\n",
    "    plt.show()\n",
    "\n",
    "def plot_clustered_gear(L_segments, L_segment_labels):\n",
    "    \"\"\"\n",
    "    Given a list `L_segments` of segmented matrices by inferred degree\n",
    "    and corresponding list `L_segment_labels` of segment labels by\n",
    "    inferred degree, plot the gear for which the segments are colored\n",
    "    according to the final clusters.\n",
    "    \"\"\"\n",
    "    for j in range(len(L_segments)):\n",
    "        segments = L_segments[j]\n",
    "        segment_labels = L_segment_labels[j]\n",
    "        \n",
    "        for jj in range(len(segments)):\n",
    "            segment_labels[jj]=segment_labels[jj]+j*L_segment_labels[0][-1]\n",
    "                \n",
    "        clusters   = list(set(segment_labels))\n",
    "        n_clusters = len(clusters)\n",
    "\n",
    "        for i in range(segments.shape[0]):\n",
    "            col = mcolors.hsv_to_rgb(((segment_labels[i]+j*0.3)/segment_labels[len(segment_labels)-1], \n",
    "                                      0.5 + 0.5*segment_labels[i]/segment_labels[len(segment_labels)-1], \n",
    "                                      0.5 + 0.5*segment_labels[i]/segment_labels[len(segment_labels)-1]))\n",
    "\n",
    "            # Hack: Treat the case i = 0 separately, to have a better plot of the center circle.\n",
    "            if j == 1 and i == 0:\n",
    "                segment = np.array(circle_entire(R1, 10*ns))\n",
    "                plt.plot(segment[0,:10*ns], segment[0,10*ns:20*ns], color = 'grey')            \n",
    "            else:\n",
    "                plt.plot(np.array(segments[i,:ns])[0], np.array(segments[i,ns:2*ns])[0], color = col)\n",
    "\n",
    "    plt.axis('off')\n",
    "    plt.axis('scaled')\n",
    "    plt.axis([- R2, R2, - R2, R2])\n",
    "    plt.show()\n",
    "\n",
    "plot_gear(T, R1, R2, R3, 10, Bezier = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Timing the individual components of the algorithm\n",
    "To see how the total CPU time breaks down, we time the individual components of the algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " # teeth = 4\n",
      "Assembling the segment dissimilarity_matrix took 0.002795696258544922 seconds\n",
      "The remaining successive clustering took 0.0008232593536376953 seconds:\n",
      "finding the minimum costs  0.00016999244689941406 seconds\n",
      "finding the row and column indices  6.67572021484375e-05 seconds\n",
      "update the dissimilarity matrix costs 0.00037169456481933594 seconds\n",
      "The clustering procedure for the segments of degree 1 takes 0.0040607452392578125 seconds\n",
      "Assembling the segment dissimilarity_matrix took 0.0038521289825439453 seconds\n",
      "The remaining successive clustering took 0.0008029937744140625 seconds:\n",
      "finding the minimum costs  8.392333984375e-05 seconds\n",
      "finding the row and column indices  6.866455078125e-05 seconds\n",
      "update the dissimilarity matrix costs 0.0004279613494873047 seconds\n",
      "The clustering procedure for the segments of degree 2 takes 0.005256175994873047 seconds\n",
      "\n",
      " # teeth = 8\n",
      "Assembling the segment dissimilarity_matrix took 0.008901119232177734 seconds\n",
      "The remaining successive clustering took 0.0015840530395507812 seconds:\n",
      "finding the minimum costs  0.00012922286987304688 seconds\n",
      "finding the row and column indices  0.00010514259338378906 seconds\n",
      "update the dissimilarity matrix costs 0.0009951591491699219 seconds\n",
      "The clustering procedure for the segments of degree 1 takes 0.011013031005859375 seconds\n",
      "Assembling the segment dissimilarity_matrix took 0.011916160583496094 seconds\n",
      "The remaining successive clustering took 0.0017092227935791016 seconds:\n",
      "finding the minimum costs  0.0001380443572998047 seconds\n",
      "finding the row and column indices  0.00010895729064941406 seconds\n",
      "update the dissimilarity matrix costs 0.0011031627655029297 seconds\n",
      "The clustering procedure for the segments of degree 2 takes 0.014409065246582031 seconds\n",
      "\n",
      " # teeth = 16\n",
      "Assembling the segment dissimilarity_matrix took 0.031138896942138672 seconds\n",
      "The remaining successive clustering took 0.004006862640380859 seconds:\n",
      "finding the minimum costs  0.0002148151397705078 seconds\n",
      "finding the row and column indices  0.0001494884490966797 seconds\n",
      "update the dissimilarity matrix costs 0.003050565719604492 seconds\n",
      "The clustering procedure for the segments of degree 1 takes 0.035797119140625 seconds\n",
      "Assembling the segment dissimilarity_matrix took 0.037072181701660156 seconds\n",
      "The remaining successive clustering took 0.0040667057037353516 seconds:\n",
      "finding the minimum costs  0.0002205371856689453 seconds\n",
      "finding the row and column indices  0.00015282630920410156 seconds\n",
      "update the dissimilarity matrix costs 0.0031099319458007812 seconds\n",
      "The clustering procedure for the segments of degree 2 takes 0.04165506362915039 seconds\n",
      "\n",
      " # teeth = 32\n",
      "Assembling the segment dissimilarity_matrix took 0.1159210205078125 seconds\n",
      "The remaining successive clustering took 0.021142005920410156 seconds:\n",
      "finding the minimum costs  0.006402254104614258 seconds\n",
      "finding the row and column indices  0.0005843639373779297 seconds\n",
      "update the dissimilarity matrix costs 0.012209653854370117 seconds\n",
      "The clustering procedure for the segments of degree 1 takes 0.1375288963317871 seconds\n",
      "Assembling the segment dissimilarity_matrix took 0.14528799057006836 seconds\n",
      "The remaining successive clustering took 0.021570920944213867 seconds:\n",
      "finding the minimum costs  0.006753444671630859 seconds\n",
      "finding the row and column indices  0.0004525184631347656 seconds\n",
      "update the dissimilarity matrix costs 0.011977195739746094 seconds\n",
      "The clustering procedure for the segments of degree 2 takes 0.1675121784210205 seconds\n",
      "\n",
      " # teeth = 64\n",
      "Assembling the segment dissimilarity_matrix took 0.47205114364624023 seconds\n",
      "The remaining successive clustering took 0.05219888687133789 seconds:\n",
      "finding the minimum costs  0.005390644073486328 seconds\n",
      "finding the row and column indices  0.0005102157592773438 seconds\n",
      "update the dissimilarity matrix costs 0.04321169853210449 seconds\n",
      "The clustering procedure for the segments of degree 1 takes 0.5251908302307129 seconds\n",
      "Assembling the segment dissimilarity_matrix took 0.5782170295715332 seconds\n",
      "The remaining successive clustering took 0.05724215507507324 seconds:\n",
      "finding the minimum costs  0.00565338134765625 seconds\n",
      "finding the row and column indices  0.0007848739624023438 seconds\n",
      "update the dissimilarity matrix costs 0.047264814376831055 seconds\n",
      "The clustering procedure for the segments of degree 2 takes 0.6370809078216553 seconds\n",
      "\n",
      " # teeth = 128\n",
      "Assembling the segment dissimilarity_matrix took 1.8699488639831543 seconds\n",
      "The remaining successive clustering took 0.19165992736816406 seconds:\n",
      "finding the minimum costs  0.013931035995483398 seconds\n",
      "finding the row and column indices  0.0010046958923339844 seconds\n",
      "update the dissimilarity matrix costs 0.1673576831817627 seconds\n",
      "The clustering procedure for the segments of degree 1 takes 2.062493085861206 seconds\n",
      "Assembling the segment dissimilarity_matrix took 2.188452959060669 seconds\n",
      "The remaining successive clustering took 0.2444460391998291 seconds:\n",
      "finding the minimum costs  0.01972341537475586 seconds\n",
      "finding the row and column indices  0.0016884803771972656 seconds\n",
      "update the dissimilarity matrix costs 0.20691156387329102 seconds\n",
      "The clustering procedure for the segments of degree 2 takes 2.4336929321289062 seconds\n",
      "\n",
      " # teeth = 256\n",
      "Assembling the segment dissimilarity_matrix took 6.091861009597778 seconds\n",
      "The remaining successive clustering took 1.129180908203125 seconds:\n",
      "finding the minimum costs  0.1435225009918213 seconds\n",
      "finding the row and column indices  0.004997730255126953 seconds\n",
      "update the dissimilarity matrix costs 0.857161283493042 seconds\n",
      "The clustering procedure for the segments of degree 1 takes 7.223530292510986 seconds\n",
      "Assembling the segment dissimilarity_matrix took 8.465841054916382 seconds\n",
      "The remaining successive clustering took 0.8823249340057373 seconds:\n",
      "finding the minimum costs  0.11507487297058105 seconds\n",
      "finding the row and column indices  0.0024902820587158203 seconds\n",
      "update the dissimilarity matrix costs 0.7093007564544678 seconds\n",
      "The clustering procedure for the segments of degree 2 takes 9.349972248077393 seconds\n",
      "\n",
      " # teeth = 512\n",
      "Assembling the segment dissimilarity_matrix took 25.00694704055786 seconds\n",
      "The remaining successive clustering took 4.694189786911011 seconds:\n",
      "finding the minimum costs  0.9756348133087158 seconds\n",
      "finding the row and column indices  0.0074388980865478516 seconds\n",
      "update the dissimilarity matrix costs 3.104811191558838 seconds\n",
      "The clustering procedure for the segments of degree 1 takes 29.707561016082764 seconds\n",
      "Assembling the segment dissimilarity_matrix took 32.53576111793518 seconds\n",
      "The remaining successive clustering took 4.957658290863037 seconds:\n",
      "finding the minimum costs  1.0366859436035156 seconds\n",
      "finding the row and column indices  0.010196208953857422 seconds\n",
      "update the dissimilarity matrix costs 3.298917531967163 seconds\n",
      "The clustering procedure for the segments of degree 2 takes 37.49777626991272 seconds\n",
      "\n",
      " # teeth = 1024\n",
      "Assembling the segment dissimilarity_matrix took 95.829843044281 seconds\n",
      "The remaining successive clustering took 34.25430393218994 seconds:\n",
      "finding the minimum costs  7.775526285171509 seconds\n",
      "finding the row and column indices  0.02960824966430664 seconds\n",
      "update the dissimilarity matrix costs 12.807766199111938 seconds\n",
      "The clustering procedure for the segments of degree 1 takes 130.11242413520813 seconds\n",
      "Assembling the segment dissimilarity_matrix took 120.91164708137512 seconds\n",
      "The remaining successive clustering took 33.5581169128418 seconds:\n",
      "finding the minimum costs  7.7558534145355225 seconds\n",
      "finding the row and column indices  0.0302584171295166 seconds\n",
      "update the dissimilarity matrix costs 12.801066160202026 seconds\n",
      "The clustering procedure for the segments of degree 2 takes 154.49298191070557 seconds\n"
     ]
    }
   ],
   "source": [
    "teeth_per_test = [4,8,16,32,64,128,256,512,1024]\n",
    "assembling_times =[]\n",
    "clustering_times = []\n",
    "total_times =[]\n",
    "\n",
    "for T in teeth_per_test:\n",
    "    print(\"\\n # teeth =\", T)\n",
    "    L_segments = segments_ordered(T, R1, R2, R3, ns)\n",
    "    L_n = [segments.shape[0] for segments in L_segments]\n",
    "\n",
    "\n",
    "    L_SSV = []\n",
    "    L_segment_labels_history = []\n",
    "    \n",
    "    assembling_time = 0\n",
    "    clustering_time = 0\n",
    "    total_time = 0\n",
    "    \n",
    "    for d in range(1,d_max+1):\n",
    "        \n",
    "        t0 = time.time()\n",
    "        SSV, segment_labels_history, t1, t2 = clustering_by_degree(L_segments[d-1], ns, d, verbose = True)\n",
    "        L_SSV.append(SSV)\n",
    "        L_segment_labels_history.append(segment_labels_history)\n",
    "        t3 = time.time() - t0\n",
    "        print(\"The clustering procedure for the segments of degree\", d, \"takes\", t3,\"seconds\")\n",
    "        \n",
    "        assembling_time = assembling_time + t1\n",
    "        clustering_time = clustering_time + t2\n",
    "        total_time = total_time + t3\n",
    "        \n",
    "    assembling_times = assembling_times + [assembling_time]\n",
    "    clustering_times = clustering_times + [clustering_time]\n",
    "    total_times = total_times + [total_time]\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   T |  #segments |  CPU time a |  log_2(factor) a |  CPU time b |  log_2(factor) b |  CPU time c |  log_2(factor)\n",
      "-----+------------+-------------+------------------+-------------+------------------+-------------+------------------\n",
      "   4 |         17 |        0.01 |                  |        0.00 |                  |        0.01 |                 \n",
      "   8 |         33 |        0.02 |             1.65 |        0.00 |             1.02 |        0.03 |             1.45\n",
      "  16 |         65 |        0.07 |             1.71 |        0.01 |             1.29 |        0.08 |             1.61\n",
      "  32 |        129 |        0.26 |             1.94 |        0.04 |             2.40 |        0.31 |             1.98\n",
      "  64 |        257 |        1.05 |             2.01 |        0.11 |             1.36 |        1.16 |             1.93\n",
      " 128 |        513 |        4.06 |             1.95 |        0.44 |             1.99 |        4.50 |             1.95\n",
      " 256 |       1025 |       14.56 |             1.84 |        2.01 |             2.21 |       16.57 |             1.88\n",
      " 512 |       2049 |       57.54 |             1.98 |        9.65 |             2.26 |       67.21 |             2.02\n",
      "1024 |       4097 |      216.74 |             1.91 |       67.81 |             2.81 |      284.61 |             2.08\n"
     ]
    }
   ],
   "source": [
    "L_timings = []\n",
    "for i in range(len(teeth_per_test)):\n",
    "    L_timings.append( (teeth_per_test[i], assembling_times[i], \n",
    "                       clustering_times[i], total_times[i]))\n",
    "    \n",
    "\n",
    "print(\"   T |  #segments |  CPU time a |  log_2(factor) a |  CPU time b |  log_2(factor) b |  CPU time c |  log_2(factor) c\")\n",
    "print(\"-----+------------+-------------+------------------+-------------+------------------+-------------+------------------\")\n",
    "t1_0 = 0\n",
    "t2_0 = 0\n",
    "t3_0 = 0\n",
    "for T1, t1, t2, t3 in L_timings:\n",
    "    s1a = '%.2f' % t1\n",
    "    s2a = '%.2f' % t2\n",
    "    s3a = '%.2f' % t3\n",
    "    if t1_0 == 0:\n",
    "        s1b = \"\"\n",
    "    if t2_0 == 0:\n",
    "        s2b = \"\"\n",
    "    if t3_0 == 0:\n",
    "        s3b = \"\"\n",
    "    else:\n",
    "        s1b = '%.2f' % (np.log(np.float64(t1)/t1_0)/np.log(2))\n",
    "        s2b = '%.2f' % (np.log(np.float64(t2)/t2_0)/np.log(2))\n",
    "        s3b = '%.2f' % (np.log(np.float64(t3)/t3_0)/np.log(2))\n",
    "    print(( 4 - len(str(T1    )))*\" \" + str(T1    ) + \" |\" + \\\n",
    "          (11 - len(str(4*T1+1)))*\" \" + str(4*T1+1) + \" |\" + \\\n",
    "          (12 - len(s1a         ))*\" \" + s1a          + \" |\" + \\\n",
    "          (17 - len(s1b         ))*\" \" + s1b          + \" |\" + \\\n",
    "          (12 - len(s2a         ))*\" \" + s2a          + \" |\" + \\\n",
    "          (17 - len(s2b         ))*\" \" + s2b          + \" |\" + \\\n",
    "          (12 - len(s3a         ))*\" \" + s3a          + \" |\" + \\\n",
    "          ( 17 - len(s3b         ))*\" \" + s3b          )\n",
    "          \n",
    "    t1_0, t2_0, t3_0 = t1, t2, t3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Timing and images\n",
    "We investigate the correctness and computational complexity of the algorithm, by applying it to the 2D gear example with $2^n, n = 0, 1, ...$ teeth, corresponding to $1 + 4\\cdot 2^n$ segments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Clustering of the gear with 2 teeth takes 0.002946615219116211 seconds.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Clustering of the gear with 4 teeth takes 0.006372928619384766 seconds.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Clustering of the gear with 8 teeth takes 0.020414113998413086 seconds.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Clustering of the gear with 16 teeth takes 0.07343506813049316 seconds.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Clustering of the gear with 32 teeth takes 0.27303314208984375 seconds.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def apply_clustering(L_segments):\n",
    "    L_SSV = []\n",
    "    L_segment_labels_history = []\n",
    "    Labeled_segments = []\n",
    "    for d in range(1, d_max+1):\n",
    "        SSV, segment_labels_history, assembling_time, clustering_time = clustering_by_degree(L_segments[d-1], ns, d)\n",
    "        L_SSV.append(SSV)\n",
    "        increment_SSV = [SSV[0]]\n",
    "        for i in range(1, len(SSV)):\n",
    "            increment_SSV.append(SSV[i] / SSV[i-1])\n",
    "        L_segment_labels_history.append(segment_labels_history)\n",
    "        increment_SSV.index(max(increment_SSV))        \n",
    "        Labeled_segments.append(segment_labels_history[increment_SSV.index(max(increment_SSV))])\n",
    "    return L_SSV, Labeled_segments\n",
    "\n",
    "\n",
    "L_timings = []\n",
    "for T in [2,4,8,16,32]:\n",
    "    L_segments = segments_ordered(T, R1, R2, R3, ns)\n",
    "    \n",
    "    # We time the clustering procedure, using the best out of 10 runs\n",
    "    t1 = math.inf\n",
    "    for i in range(1):\n",
    "        t0 = time.time()\n",
    "        L_SSV, Labeled_segments = apply_clustering(L_segments)\n",
    "        t1 = min(t1, time.time() - t0)\n",
    "    \n",
    "    L_timings.append( (T, t1) )\n",
    "    print(\"Clustering of the gear with\",T,\"teeth takes\",t1,\"seconds.\")\n",
    "\n",
    "    #Select the segment labels of the final step of the clustering algorithm\n",
    "    L_segment_labels = [Labeled_segments[0].tolist()[0], Labeled_segments[1].tolist()[0]]\n",
    "    plot_clustered_gear(L_segments, L_segment_labels)"
   ]
  }
 ],
 "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.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}