Voronoi.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class voronoi:\n",
    "    \n",
    "    def __init__(self, data, data_name = \"\"):\n",
    "        self.data = np.array(data)\n",
    "        self.data_name = data_name\n",
    "        self.cells = []\n",
    "    \n",
    "    def plot_points(self):\n",
    "        fig, ax = plt.subplots()\n",
    "        ax.set_title(self.data_name)\n",
    "        ax.scatter(self.data[:, 0], self.data[:, 1])\n",
    "        plt.show()\n",
    "    \n",
    "    # Finds which cell is the point located\n",
    "    def find_cell(self, point):\n",
    "        dist = float(\"inf\")\n",
    "        for i, cell in enumerate(self.cells):\n",
    "            aux = np.sqrt((point[0]-cell[0][0])**2+(point[1]-cell[0][1])**2)\n",
    "            if aux < dist:\n",
    "                dist = aux\n",
    "                pos = i\n",
    "        return pos\n",
    "    \n",
    "    # Returns the cell that belongs to edge which is different than origin_cell \n",
    "    def find_cell_by_edge(self, edge_ref, origin_cell):\n",
    "        precision = 0.7\n",
    "        for i, cell in enumerate(self.cells):\n",
    "            for j, edge in enumerate(cell[1]):\n",
    "                if i != origin_cell:\n",
    "                    if abs(edge[0][0] - edge_ref[0][0]) <= precision and abs(edge[0][1] - edge_ref[0][1]) <= precision:\n",
    "                        if abs(edge[1][0] - edge_ref[1][0]) <= precision and abs(edge[1][1] - edge_ref[1][1]) <= precision:\n",
    "                            output = i\n",
    "                            \n",
    "                    if abs(edge[1][0] - edge_ref[0][0]) <= precision and abs(edge[1][1] - edge_ref[0][1]) <= precision: \n",
    "                        if abs(edge[0][0] - edge_ref[1][0]) <= precision and abs(edge[0][1] - edge_ref[1][1]) <= precision:\n",
    "                            output = i\n",
    "        return output\n",
    "\n",
    "    \n",
    "    # Remakes the cell when edge is added\n",
    "    def remake_cell(self, visited_cell, edge_added, point_added):\n",
    "        drop = []\n",
    "        \n",
    "        for i, edge in enumerate(self.cells[visited_cell][1]):\n",
    "            \n",
    "            A = edge[0]\n",
    "            B = edge[1]\n",
    "            C = edge_added[0]\n",
    "            D_0 = round(A[0]*B[1] + A[1]*C[0] + B[0]*C[1] - C[0]*B[1] - A[0]*C[1] - A[1]*B[0], 4)\n",
    "            C = edge_added[1]\n",
    "            D_1 = round(A[0]*B[1] + A[1]*C[0] + B[0]*C[1] - C[0]*B[1] - A[0]*C[1] - A[1]*B[0], 4)\n",
    "\n",
    "            # Checking if one of the points from the new edge is colinear to the existing edge\n",
    "\n",
    "            if max(abs(D_0), abs(D_1)) >= 2000000: precision = 1.5\n",
    "            if max(abs(D_0), abs(D_1)) < 2000000 and max(abs(D_0), abs(D_1)) > 50000: precision = 0.8\n",
    "            if max(abs(D_0), abs(D_1)) <= 50000 and max(abs(D_0), abs(D_1)) > 1000: precision = 0.5\n",
    "            if max(abs(D_0), abs(D_1)) <= 1000: precision = 0.01\n",
    "            \n",
    "            if abs(D_0) <= precision or abs(D_1) <= precision: \n",
    "                if abs(D_0) <= precision: p = edge_added[0]\n",
    "                else: p = edge_added[1]\n",
    "                \n",
    "                dist_1 = np.sqrt((point_added[0] - A[0])**2+(point_added[1] - A[1])**2)\n",
    "                dist_2 = np.sqrt((self.cells[visited_cell][0][0] - A[0])**2+(self.cells[visited_cell][0][1] - A[1])**2) \n",
    "                \n",
    "                if dist_1 < dist_2:\n",
    "                    self.cells[visited_cell][1][i][0] = [p[0], p[1], 1][:]\n",
    "                else:\n",
    "                    self.cells[visited_cell][1][i][1] = [p[0], p[1], 1][:]\n",
    "                \n",
    "                \n",
    "            if abs(D_0) > precision and abs(D_1) > precision: \n",
    "                dist_1 = np.sqrt((point_added[0] - A[0])**2+(point_added[1] - A[1])**2)\n",
    "                dist_2 = np.sqrt((self.cells[visited_cell][0][0] - A[0])**2+(self.cells[visited_cell][0][1] - A[1])**2)\n",
    "                \n",
    "                if dist_1 < dist_2:\n",
    "                    drop.append(edge)\n",
    "            \n",
    "        self.cells[visited_cell][1].append(edge_added[:])\n",
    "        \n",
    "        for element in drop:\n",
    "            self.cells[visited_cell][1].remove(element)\n",
    "        \n",
    "    # Returns an edge in the mean distance between p and the cell's centre. \n",
    "    # Also returns the neighbour cells which need to be updates\n",
    "    def make_edge(self, cell, p):\n",
    "        C = self.cells[cell][0]\n",
    "        M = [round((C[0] + p[0])/2, 4), round((C[1] + p[1])/2, 4)]\n",
    "        V_1 = [C[0] - M[0], C[1] - M[1]]\n",
    "        if V_1[1] == 0:\n",
    "            V_2 = [0, 1]\n",
    "        else:\n",
    "            V_2 = [1, -V_1[0]/V_1[1]]\n",
    "        output = []\n",
    "        NEIGHBOURS = []\n",
    "\n",
    "        for edge in self.cells[cell][1]:\n",
    "            A = edge[0]\n",
    "            B = edge[1]\n",
    "            \n",
    "            if A[0] == B[0]: \n",
    "                A[0] = A[0] + 0.1\n",
    "                B[0] = B[0] - 0.1\n",
    "            \n",
    "            if A[1] == B[1]: \n",
    "                A[1] = A[1] + 0.1\n",
    "                B[1] = B[1] - 0.1\n",
    "            \n",
    "            V_3 = [B[0] - A[0], B[1] - A[1]]\n",
    "            D = round((-V_3[0]*V_2[1] + V_3[1]*V_2[0]), 4)\n",
    "                \n",
    "            if abs(D) > 0.1: # If D == 0, than the new edge does not cross edge\n",
    "                D_t = (M[1] - A[1])*V_3[0] - (M[0] - A[0])*V_3[1]\n",
    "                t = D_t/D\n",
    "                INTERSECT = [round(M[0] + t*V_2[0], 4), round(M[1] + t*V_2[1], 4), 1]\n",
    "                IS_VALID = False\n",
    "                \n",
    "                # Double checking if the intersection is valid by checking if the intersection if in between the edge limits\n",
    "                \n",
    "                if A[2] == 1 and B[2] == 1:\n",
    "                    if INTERSECT[0] < max(A[0], B[0]) and INTERSECT[0] > min(A[0], B[0]):\n",
    "                        IS_VALID = True                        \n",
    "                \n",
    "                if A[2] == 0 and B[2] == 1:\n",
    "                    if A[0] > B[0] and INTERSECT[0] > B[0]:                        \n",
    "                        IS_VALID = True\n",
    "                    if A[0] < B[0] and INTERSECT[0] < B[0]:                        \n",
    "                        IS_VALID = True\n",
    "\n",
    "                    \n",
    "                if A[2] == 1 and B[2] == 0:\n",
    "                    if A[0] > B[0] and INTERSECT[0] < A[0]:\n",
    "                        IS_VALID = True\n",
    "                    if A[0] < B[0] and INTERSECT[0] > A[0]:\n",
    "                        IS_VALID = True \n",
    "                    \n",
    "                if A[2] == 0 and B[2] == 0:\n",
    "                    IS_VALID = True\n",
    "\n",
    "            \n",
    "                if IS_VALID:\n",
    "                    T = t\n",
    "                    output.append(INTERSECT)\n",
    "                    NEIGHBOURS.append(self.find_cell_by_edge(edge, cell))    \n",
    "                    \n",
    "        # In case len(output == 1), there is only one intersection. Thus, we need to create a half line\n",
    "        if len(output) == 1:\n",
    "            \n",
    "            if self.find_cell(M) == cell: # If M is inside the cell, we just need to extend it (-10*V_2)                \n",
    "                inf_point = [round(M[0] - 10*T*V_2[0], 4), round(M[1] - 10*T*V_2[1], 4), 0]\n",
    "                i = 2\n",
    "                while np.sqrt((self.cells[cell][0][0] - inf_point[0])**2 + (self.cells[cell][0][1] -inf_point[0])**2) < 1000:\n",
    "                    inf_point = [round(M[0] - i*10*T*V_2[0], 4), round(M[1] - i*10*T*V_2[1], 4), 0]\n",
    "                    i += 1\n",
    "                \n",
    "            else: # If not in cell, we need to move it to the cell (+10*V_2)\n",
    "                inf_point = [round(M[0] + 10*T*V_2[0], 4), round(M[1] + 10*T*V_2[1], 4), 0]\n",
    "                i = 2\n",
    "                while np.sqrt((self.cells[cell][0][0] - inf_point[0])**2 + (self.cells[cell][0][1] -inf_point[0])**2) < 1000 or self.find_cell(inf_point) != cell:\n",
    "                    inf_point = [round(M[0] + i*10*T*V_2[0], 4), round(M[1] + i*10*T*V_2[1], 4), 0]\n",
    "                    i += 1\n",
    "            \n",
    "            output.append(inf_point)\n",
    "\n",
    "        return output, NEIGHBOURS\n",
    "        \n",
    "        \n",
    "    # Receives a new point and the current cell where it is located\n",
    "    # Recursevly calls make_edge until the cell is made, and returns the new cell\n",
    "    def make_cell(self, cell, p):\n",
    "        edges = []\n",
    "        VISITED = [] # List of visited cells\n",
    "        edge, NEIGHBOURS = self.make_edge(cell, p)\n",
    "        VISITED.append(cell)\n",
    "        edges.append(edge)        \n",
    "        \n",
    "        for N in NEIGHBOURS: # If the new edge touches two existing edges, it runs twice \n",
    "            NEXT_CELL = N\n",
    "            if NEXT_CELL not in VISITED: FLAG = True\n",
    "            while FLAG:  # Runs until all the neighbours are visited\n",
    "                edge, NEIGHBOURS = self.make_edge(NEXT_CELL, p)\n",
    "                edges.append(edge)\n",
    "                VISITED.append(NEXT_CELL)\n",
    "                FLAG = False\n",
    "                if NEIGHBOURS != []:\n",
    "                    for NEIGHBOUR in NEIGHBOURS:\n",
    "                        if NEIGHBOUR not in VISITED: \n",
    "                            FLAG = True\n",
    "                            NEXT_CELL = NEIGHBOUR\n",
    "                        \n",
    "        for i, VISIT in enumerate(VISITED):\n",
    "            self.remake_cell(VISIT, edges[i], p)\n",
    "\n",
    "        return [p, edges]          \n",
    "    \n",
    "    # Main function that returns the list of cells of n size. For each element, cell[0] contains the centre coordinates\n",
    "    # and cell[1] contains the list of edges\n",
    "    def make_voronoi(self):\n",
    "        \n",
    "        # First divisinon is made by spliting in the middle of the two first points\n",
    "        mid = [(self.data[1][0] + self.data[0][0])/2, (self.data[1][1] + self.data[0][1])/2]\n",
    "        V = [self.data[0][0] - mid[0], self.data[0][1] - mid[1]]\n",
    "        self.cells.append([self.data[0],\n",
    "                           [[[round(mid[0] + 1000, 4), round(mid[1] - (V[0]/V[1])*1000, 4), 0], \n",
    "                             [round(mid[0] - 1000, 4), round(mid[1] + (V[0]/V[1])*1000, 4), 0]]]])\n",
    "        self.cells.append([self.data[1],\n",
    "                           [[[round(mid[0] + 1000, 4), round(mid[1] - (V[0]/V[1])*1000, 4), 0], \n",
    "                             [round(mid[0] - 1000, 4), round(mid[1] + (V[0]/V[1])*1000, 4), 0]]]])\n",
    "        \n",
    "        for i in range(2, len(self.data)):\n",
    "            \n",
    "            cell = self.find_cell(self.data[i])\n",
    "            self.cells.append(self.make_cell(cell, self.data[i]))\n",
    "            \n",
    "    def plot_voronoi(self):\n",
    "        \n",
    "        self.make_voronoi()\n",
    "        fig, ax = plt.subplots(figsize = (4, 4))\n",
    "        ax.set_title(\"Voronoi Diagram for \" + str(self.data_name))\n",
    "        ax.scatter(self.data[:, 0], self.data[:, 1])\n",
    "        axes = plt.axis()\n",
    "        \n",
    "        for c in self.cells:\n",
    "            for line in c[1]:\n",
    "                plt.plot([line[0][0], line[1][0]], [line[0][1], line[1][1]], color = \"red\")\n",
    "\n",
    "        ax.set_aspect(1)\n",
    "        plt.xlim([axes[0], axes[1]])\n",
    "        plt.ylim([axes[2], axes[3]])\n",
    "        plt.show() \n",
    "        \n",
    "    def export_edges(self):\n",
    "        edges = []\n",
    "        for cell in self.cells:\n",
    "            for edge in cell[1]:\n",
    "                edges.append(edge)\n",
    "        for i, edge in enumerate(edges):\n",
    "            for j, point in enumerate(edge):\n",
    "                for k, value in enumerate(point):\n",
    "                    edges[i][j][k] = round(edges[i][j][k], 1)\n",
    "                    \n",
    "        \n",
    "        return edges\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data1 = voronoi(np.loadtxt(\"nuvem1.txt\"), \"Nuvem_1\")\n",
    "data2 = voronoi(np.loadtxt(\"nuvem2.txt\")[0:32], \"Nuvem_2\")\n",
    "data1.plot_voronoi()\n",
    "data2.plot_voronoi()\n",
    "edges1 = data1.export_edges()\n",
    "edges2 = data2.export_edges()\n",
    "\n",
    "with open('arestas_1.txt', 'w') as f:\n",
    "    for edge in edges1:\n",
    "        for i, point in enumerate(edge):\n",
    "            for j, value in enumerate(point):\n",
    "                f.write(str(value))\n",
    "                if i != 1 or j != 2:\n",
    "                    f.write(\",\")\n",
    "        f.write(\"\\n\")\n",
    "\n",
    "with open('arestas_2.txt', 'w') as f:\n",
    "    for edge in edges2:\n",
    "        for i, point in enumerate(edge):\n",
    "            for j, value in enumerate(point):\n",
    "                f.write(str(value))\n",
    "                if i != 1 or j != 2:\n",
    "                    f.write(\",\")\n",
    "        f.write(\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sizes = [3, 4, 5, 6, 7, 8, 9, 10, 20]\n",
    "run_time = []\n",
    "\n",
    "for N in sizes:\n",
    "    points = voronoi(np.random.rand(N, 2)*1000)\n",
    "    start = time.time()\n",
    "    points.make_voronoi()\n",
    "    end = time.time()\n",
    "    run_time.append(end-start)\n",
    "             \n",
    "plt.plot(sizes, run_time, \"r\")\n",
    "plt.plot(sizes, [size**2/20000 for size in sizes], \"b\")\n",
    "plt.xlabel('Input size')\n",
    "plt.ylabel('time (s)')\n",
    "plt.legend([\"Voronoi\",\"n**2\"])\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data1 = voronoi(np.loadtxt(\"nuvem1.txt\")[0:3], \"Nuvem_1\")\n",
    "data1.plot_voronoi()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}