{ "cells": [ { "cell_type": "markdown", "id": "8f77f02a-c7af-4a90-9bc2-ff9c8896199d", "metadata": {}, "source": [ "# Packing circles in 2D surface\n", "\n", "> Generating Reaction Library Compounds\n", "\n", "- toc: true \n", "- badges: true\n", "- comments: true\n", "- categories: [RDKit, Reaction Library]" ] }, { "cell_type": "code", "execution_count": 1, "id": "c2aaff73", "metadata": {}, "outputs": [], "source": [ "#collapse-hide\n", "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "\n", "# data\n", "import numpy as np\n", "import pandas as pd\n", "\n", "# useful\n", "import re, glob, os\n", "from tqdm.auto import tqdm\n", "from pathlib import Path\n", "\n", "# misc\n", "from scipy.spatial.distance import pdist\n", "np.random.seed(3141519)" ] }, { "cell_type": "markdown", "id": "d1cd54a6", "metadata": {}, "source": [ "# Motivation\n", "\n", "Packing circle is a common problem shows up in molecular modeling. For example, when we arrange lipid molecules in membrane bilayer, we are essentially packing circular areas in 2D box. One could use Monte-carlo simulation appraoch to pack these molecules, but it is a time consuming and compute intensive. Let's explore algorithmic ways to arrange these circles in 2D area, which will be an efficient approach.\n", "\n", "Here, I'm going to follow the algorithm proposed by [Weixin Wang](https://dl.acm.org/doi/10.1145/1124772.1124851). In short, the algorithm attempt to add externally tangential circles to two circles that are already added. The algorithm uses so-called \"front-chain\", which holds the list of circles at the outer most edges and attempt to extend the chain. " ] }, { "cell_type": "markdown", "id": "1a9db3fd", "metadata": {}, "source": [ "# Initial Circles" ] }, { "cell_type": "code", "execution_count": 2, "id": "40bfef13", "metadata": {}, "outputs": [], "source": [ "import math\n", "\n", "n_circles = 1000\n", "radii = [np.random.randint(1, 3) for i in range(n_circles)]\n", "\n", "class Circle:\n", " def __init__(self, x, y, r):\n", " self.x = x\n", " self.y = y\n", " self.r = r\n", " \n", " @property\n", " def center(self):\n", " return (self.x, self.y)" ] }, { "cell_type": "markdown", "id": "1b277513", "metadata": {}, "source": [ "For this excercise, let's try to add 100 circles with random radii. We defined a simple `Circle` class to hold information about circle.\n", "\n", "First thing we will have to do is to lay out three initial circles. The first two circles are straightforward; first cicles is placed on the origin (0, 0) and the second circles is placed on the X-axis at $(r_0 + r_1, 0)$. " ] }, { "cell_type": "code", "execution_count": 3, "id": "fab96f1b", "metadata": {}, "outputs": [], "source": [ "# lay out initial circles\n", "c1 = Circle(0, 0, radii[0])\n", "c2 = Circle(radii[0] + radii[1], 0, radii[1])\n", "circles = [c1, c2]\n", "chain = [0, 1, 0]" ] }, { "cell_type": "markdown", "id": "6806ce50", "metadata": {}, "source": [ "The third circle is placed as tangent to the first two circles. To find the center of the third circle, we need to solve the systems of equation using the following relationship; $(x_3, y_3)$ is distance of $(r_1 + r_3)$ from the center of the first circle and $(x_3, y_3)$ is distance of $(r_2 + r_3)$ from the center of the second circle.\n", "\n", "$\n", "(x_3 - x_1)^2 + (y_3 - y_1)^2 = (r_1 + r_3)^2 \\\\\n", "(x_3 - x_2)^2 + (y_3 - y_2)^2 = (r_2 + r_3)^2\n", "$\n", "\n", "This can be done trivially using `sympy` package" ] }, { "cell_type": "code", "execution_count": 4, "id": "2a9b0db7", "metadata": {}, "outputs": [], "source": [ "import sympy\n", "from sympy import solve_poly_system\n", "from sympy.abc import x, y" ] }, { "cell_type": "code", "execution_count": 5, "id": "99f1b5fd", "metadata": {}, "outputs": [], "source": [ "def tangent_circle_sympy(c1, c2, r3):\n", " x1, y1, r1 = c1.x, c1.y, c1.r\n", " x2, y2, r2 = c2.x, c2.y, c2.r\n", " r1 += r3\n", " r2 += r3\n", " \n", " eq1 = sympy.Eq((x - x1)**2 + (y - y1)**2, r1**2)\n", " eq2 = sympy.Eq((x - x2)**2 + (y - y2)**2, r2**2)\n", " p3 = solve_poly_system([eq1, eq2], x, y)\n", " return p3" ] }, { "cell_type": "code", "execution_count": 6, "id": "6f0d0ae3", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[(1, -2*sqrt(2)), (1, 2*sqrt(2))]" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tangent_circle_sympy(c1, c2, radii[2])" ] }, { "cell_type": "markdown", "id": "f572187f", "metadata": {}, "source": [ "Analytically, an externally tangent circle, $C_C$ to the two circles (tangent to each other), $C_A$ and $C_B$, can be found by finding an intersection point of two circles having same center as $C_A$ and $C_B$ but larger radii $r_A + r_C$ and $r_B + r_C$.\n", "\n", "![feature](files/circle_tangent.png)\n", "\n", "The detailed derivation on how to find the intersection points can be found in Paul Bourke's note: http://paulbourke.net/geometry/circlesphere/" ] }, { "cell_type": "code", "execution_count": 7, "id": "26d07828", "metadata": {}, "outputs": [], "source": [ "from math import sqrt\n", "\n", "def tangent_circle(c0, c1, r):\n", " r0 = c0.r + r\n", " r1 = c1.r + r\n", " x0, y0 = c0.center\n", " x1, y1 = c1.center\n", " \n", " d = sqrt((x0 - x1)**2 + (y0 - y1)**2)\n", " a = (r0*r0 - r1*r1 + d*d) / (2 * d)\n", " h = sqrt(r0*r0 - a*a)\n", " \n", " x2 = x0 + a * (x1 - x0) / d\n", " y2 = y0 + a * (y1 - y0) / d\n", " \n", " p3 = (\n", " (x2 + h * (y1 - y0) / d, y2 - h * (x1 - x0) / d),\n", " (x2 - h * (y1 - y0) / d, y2 + h * (x1 - x0) / d)\n", " )\n", " \n", " theta1 = math.atan2(p3[0][1]-y0, p3[0][0]-x0)\n", " theta2 = math.atan2(p3[1][1]-y0, p3[1][0]-x0)\n", " if theta2 > theta1:\n", " p3 = (p3[1], p3[0])\n", " \n", " return p3" ] }, { "cell_type": "code", "execution_count": 8, "id": "188acdc3", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "((1.0, 2.8284271247461903), (1.0, -2.8284271247461903))\n" ] } ], "source": [ "p3 = tangent_circle(c1, c2, radii[2])\n", "print(p3)" ] }, { "cell_type": "markdown", "id": "47a09416", "metadata": {}, "source": [ "Either approach works, but the latter will run faster, so we will use the analytical function. \n", "\n", "Now, let's add the third circle and visualize the circles as well as the \"front-chain\"." ] }, { "cell_type": "code", "execution_count": 9, "id": "482f874d", "metadata": {}, "outputs": [], "source": [ "c3 = Circle(p3[0][0], p3[0][1], radii[2])\n", "circles = [c1, c2, c3]\n", "chain = [0, 1, 2, 0]" ] }, { "cell_type": "code", "execution_count": 10, "id": "4286c678", "metadata": {}, "outputs": [], "source": [ "#collapse-hide\n", "def draw_circles(circles, circle_chain=[], show_label=False):\n", " fig, ax = plt.subplots(figsize=(8, 8)) # note we must use plt.subplots, not plt.subplot\n", " xmin, xmax = 999, -999\n", " ymin, ymax = 999, -999\n", "\n", " for i, c in enumerate(circles):\n", " patch = plt.Circle(c.center, c.r, color='gray')\n", " if c.x - c.r < xmin: xmin = c.x - c.r\n", " if c.x + c.r > xmax: xmax = c.x + c.r\n", " if c.y - c.r < ymin: ymin = c.y - c.r\n", " if c.y + c.r > ymax: ymax = c.y + c.r\n", " ax.add_patch(patch)\n", " if show_label:\n", " ax.text(c.x - 0.1, c.y - 0.1, f'C_{i}')\n", " \n", " line_x = [circles[idx].x for idx in circle_chain]\n", " line_y = [circles[idx].y for idx in circle_chain]\n", " ax.plot(line_x, line_y, marker='o')\n", "\n", " xwidth = xmax - xmin\n", " ywidth = ymax - ymin\n", " xcenter = xmin + xwidth / 2\n", " ycenter = ymin + ywidth / 2\n", " xwidth = ywidth = max(xwidth, ywidth)\n", " \n", " ax.set_xlim(xcenter - xwidth / 2, xcenter + xwidth / 2)\n", " ax.set_ylim(ycenter - ywidth / 2, ycenter + ywidth / 2)\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 11, "id": "502c4fbe", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "draw_circles(circles, chain, show_label=True)" ] }, { "cell_type": "markdown", "id": "698f10d0", "metadata": {}, "source": [ "# Add more circles\n", "\n", "Let's add more circles and update front-chain according to the algorithm described in paper. Following is quoted verbatim from the paper.\n", "\n", "1) Calculate the center of $C_i$ according to the radius $r_i$ and the tangency of circle $C_i$ to $C_m$ and $C_n$. The circles $C_m$ and $C_n$ are the circles next to each other in the front-chain. \n", "\n", "2) Search the front-chain and find out the circle $C_j$ intersecting with $C_i$. \n", "\n", "3) If $C_i$ does not intersect with any circle $C_j$ in the front-chain, $C_i$ is added to the front-chain directly, and packing $C_i$ is terminated. The front-chain is updated to include $C_i$, such that $\\{\\cdots C_m \\leftrightarrow C_n \\cdots\\}$ becomes $\\{\\cdots C_m \\leftrightarrow C_i \\leftrightarrow C_n \\cdots\\}$\n", "\n", "4) If $C_i$ intersects with $C_j$, and $C_j$ is a circle after $C_n$ on the front-chain, then the segments from $C_m$ to $C_j$ have to be deleted from the front-chain and the circle $C_n$ is replaced by $C_j$. Go to step 1. A new position of $C_i$ tangent to the two circles $C_m$ and $C_n$ will be calculated.\n", "\n", "5) If $C_i$ intersects with $C_j$, and $C_j$ is a circle before $C_m$ on the front-chain, then the segments from $C_j$ to $C_m$ have to be deleted from the front-chain and the circle $C_m$ is replaced by $C_j$. Go to step 1. A new position of $C_i$ tangent to the two circles $C_m$ and $C_n$ will be calculated." ] }, { "cell_type": "code", "execution_count": 17, "id": "a3616a02", "metadata": {}, "outputs": [], "source": [ "#collapse-hide\n", "def circle_intersect(circle1, circle2, test_only=False):\n", " \"\"\"\n", " Intersection points of two circles using the construction of triangles\n", " as proposed by Paul Bourke, 1997.\n", " http://paulbourke.net/geometry/circlesphere/\n", " \"\"\"\n", "\n", " x0, y0 = circle1.x, circle1.y\n", " x1, y1 = circle2.x, circle2.y\n", " r0 = circle1.r\n", " r1 = circle2.r\n", "\n", " d = sqrt((x0 - x1)**2 + (y0 - y1)**2)\n", " if d > (r0 + r1):\n", " return -1, None # do not intersect\n", " elif d <= abs(r1 - r0):\n", " return -2, None # one circle is contained within the circle\n", "\n", " if d == (r0 + r1) or d == (r0 - r1):\n", " CASE = 1\n", " else:\n", " CASE = 2\n", " \n", " if test_only:\n", " return CASE, None\n", "\n", " a = (r0*r0 - r1*r1 + d*d) / (2 * d)\n", " h = sqrt(r0*r0 - a*a)\n", "\n", " x2 = x0 + a * (x1 - x0) / d\n", " y2 = y0 + a * (y1 - y0) / d\n", "\n", " I1 = (x2 + h * (y1 - y0) / d, y2 - h * (x1 - x0) / d)\n", " if CASE == 1:\n", " return CASE, (I1,)\n", "\n", " I2 = (x2 - h * (y1 - y0) / d, y2 + h * (x1 - x0) / d)\n", "\n", " theta1 = math.degrees(math.atan2(I1[1]-y0, I1[0]-x0))\n", " theta2 = math.degrees(math.atan2(I2[1]-y0, I2[0]-x0))\n", " if theta2 > theta1:\n", " I1, I2 = I2, I1\n", " return CASE, (I1, I2)\n", " \n", "def tangent_circle_center(circle1, circle2, radius3):\n", " \"\"\"\n", " find center of circle tangent to both circle1 and circle2\n", " \n", " circle1 and circle2 is assumed to be tangent\n", " \"\"\"\n", "\n", " x0, y0 = circle1.x, circle1.y\n", " x1, y1 = circle2.x, circle2.y\n", " r0 = circle1.r + radius3\n", " r1 = circle2.r + radius3\n", "\n", " d = sqrt((x0 - x1)**2 + (y0 - y1)**2)\n", " a = (r0*r0 - r1*r1 + d*d) / (2 * d)\n", " h = sqrt(r0*r0 - a*a)\n", "\n", " x2 = x0 + a * (x1 - x0) / d\n", " y2 = y0 + a * (y1 - y0) / d\n", "\n", " I1 = (x2 + h * (y1 - y0) / d, y2 - h * (x1 - x0) / d)\n", " I2 = (x2 - h * (y1 - y0) / d, y2 + h * (x1 - x0) / d)\n", "\n", " torque = (x1-x0)*(I1[1]-y0)-(y1-y0)*(I1[0]-x0)\n", " if torque > 0:\n", " I1, I2 = I2, I1\n", " return I1, I2" ] }, { "cell_type": "code", "execution_count": 18, "id": "09d211d2", "metadata": {}, "outputs": [], "source": [ "def add_circle(circles, chain, index, radius):\n", " c_m = circles[chain[index]]\n", " c_n = circles[chain[index+1]]\n", " \n", " p3 = tangent_circle_center(c_m, c_n, radius)\n", " c_i = Circle(p3[0][0], p3[0][1], radius)\n", "\n", " update = False\n", " for i, idx in enumerate(chain[:-1]):\n", " if i == index or i == index+1:\n", " continue\n", " if i == 0 and index + 1 == len(chain) - 1:\n", " continue\n", "\n", " c_j = circles[idx]\n", " CASE, _ = circle_intersect(c_i, c_j, test_only=True)\n", " if CASE > 1:\n", " distance_left = index - i if index - i > 0 else index - i + len(chain) - 1\n", " distance_right = i - index - 1 if i - index - 1 > 0 else i - index - 1 + len(chain) - 1\n", " left = distance_left < distance_right\n", "\n", " #print(left, chain, chain[index], chain[i], i, index)\n", "\n", " if left:\n", " if i < index:\n", " chain = chain[:i+1] + chain[index+1:]\n", " else:\n", " chain = chain[i:] + chain[index+1:i] + [chain[i]]\n", " else:\n", " if i > index:\n", " chain = chain[:index+1] + chain[i:]\n", " else:\n", " chain = chain[i:index+1] + [chain[i]]\n", "\n", " if index > len(chain) - 2:\n", " index = 0\n", "\n", " return add_circle(circles, chain, index, radius)\n", " \n", " circles.append(c_i)\n", " chain = chain[:index+1] + [len(circles)-1] + chain[index+1:] \n", " return circles, chain" ] }, { "cell_type": "markdown", "id": "a23633b3-2a9d-4566-b2da-caa03d9ab5c2", "metadata": {}, "source": [ "Now we can repeatedly call above function to add circles to our " ] }, { "cell_type": "code", "execution_count": 19, "id": "58a5df09", "metadata": {}, "outputs": [], "source": [ "c3 = Circle(p3[0][0], p3[0][1], radii[2])\n", "circles = [c1, c2, c3]\n", "chain = [0, 1, 2, 0]\n", "index = 0\n", "\n", "for i in range(100):\n", " circles, chain = add_circle(circles, chain, index, radii[3 + i])\n", " index += 1\n", " if index > len(chain) - 2:\n", " index = 0" ] }, { "cell_type": "code", "execution_count": 20, "id": "f40ec9bd", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "draw_circles(circles, chain, show_label=True)" ] }, { "cell_type": "markdown", "id": "91a7bb4b-141b-49f2-b84f-636a48033edd", "metadata": {}, "source": [ "And here's a little animation of the process." ] }, { "cell_type": "code", "execution_count": 21, "id": "d365f4ce", "metadata": {}, "outputs": [ { "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#collapse-hide\n", "\"\"\"\n", "A simple example of an animated plot\n", "\"\"\"\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import matplotlib.animation as animation\n", "\n", "fig, ax = plt.subplots(figsize=(8, 8)) # note we must use plt.subplots, not plt.subplot\n", "xmin, xmax = 999, -999\n", "ymin, ymax = 999, -999\n", "\n", "line, = ax.plot([], [])\n", "\n", "c3 = Circle(p3[0][0], p3[0][1], radii[2])\n", "circles = [c1, c2, c3]\n", "chain = [0, 1, 2, 0]\n", "index = 0\n", "\n", "ax.set_xlim(-20, 20)\n", "ax.set_ylim(-20, 20)\n", "\n", "def animate(index):\n", " global circles, chain\n", " if index > len(chain) - 2:\n", " index = 0\n", " \n", " circles, chain = add_circle(circles, chain, index, radii[3 + index])\n", "\n", " #line.set_xdata(circles[-1].x)\n", " #line.set_ydata(circles[-1].y)\n", " \n", " patch = plt.Circle(circles[-1].center, circles[-1].r, color='gray')\n", " ax.add_patch(patch)\n", " \n", " x = []\n", " y = []\n", " \n", " for idx in chain:\n", " x.append(circles[idx].x)\n", " y.append(circles[idx].y)\n", " \n", " x.append(circles[chain[0]].x)\n", " y.append(circles[chain[0]].y)\n", " \n", " line.set_data(x, y)\n", " return line,\n", "\n", "#Init only required for blitting to give a clean slate.\n", "def init():\n", " x = []\n", " y = []\n", " \n", " for i in range(3):\n", " patch = plt.Circle(circles[i].center, circles[i].r, color='gray')\n", " ax.add_patch(patch)\n", " x.append(circles[i].x)\n", " y.append(circles[i].y)\n", " \n", " x.append(circles[0].x)\n", " y.append(circles[0].y)\n", " \n", " line.set_data(x, y)\n", " return line,\n", "\n", "#ani = animation.FuncAnimation(fig, animate, np.arange(1, 200), init_func=init,\n", "# interval=25, blit=False)\n", "\n", "ani = animation.FuncAnimation(fig, animate, np.arange(1, 100), interval=350, \n", " init_func=init, blit=True)\n", "plt.close()\n", "\n", "from IPython.display import HTML\n", "HTML(ani.to_html5_video())" ] }, { "cell_type": "code", "execution_count": null, "id": "d82c309f-eb7a-4649-893a-7ebb9a9ac8f8", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.11" } }, "nbformat": 4, "nbformat_minor": 5 }