2-Dimensional Grid Square Spiral Coordinates

spiral.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "from matplotlib import pyplot as plt\n",
        "from labellines import labelLines\n",
        "from math import ceil, floor, sqrt\n",
        "import numpy as np\n",
        "import decimal\n",
        "decimal.getcontext().rounding = decimal.ROUND_HALF_UP\n",
        "rnd = lambda x: int(decimal.Decimal(x).to_integral_value())\n",
        "\n",
        "\n",
        "def draw(src, dst, label=\"None\"):\n",
        "  a = np.array([src, dst])\n",
        "  res = plt.plot(a[:,0], a[:,1], label=label)\n",
        "\n",
        "\n",
        "def get_cords(i):\n",
        "  root = floor(sqrt(i))\n",
        "  next_root = root+1\n",
        "\n",
        "  half_root = rnd(root/2)\n",
        "\n",
        "  v1 = abs(root*next_root-i)\n",
        "  next_root_sign = pow(-1, next_root)\n",
        "  root_sign = pow(-1, root)\n",
        "\n",
        "  x = (half_root*next_root_sign) + (next_root_sign * (root*next_root-i-v1)/2)\n",
        "  y = (half_root*root_sign)  + (next_root_sign * (root*next_root-i+v1)/2)        \n",
        "  return (x, -y)\n",
        "  \n",
        "\n",
        "def get_id(x, y) :\n",
        "    n = -1\n",
        "    m = max(abs(x),abs(y))\n",
        "    if (x == m and y != -m) :\n",
        "        return (4 * m) * (m - 1) + m + y\n",
        "    elif(y == m) :\n",
        "        return (4 * m) * (m - 1) + (3 * m) - x\n",
        "    elif(x == -m) :\n",
        "        return (4 * m) * (m - 1) + (5 * m) - y\n",
        "    elif(y == -m) :\n",
        "        return (4 * m) * (m - 1) + (7 * m) + x\n",
        "  \n",
        "\n",
        "fig = plt.figure(figsize=(10, 10), constrained_layout=True)\n",
        "\n",
        "for i in range(1, 100):\n",
        "  last = get_cords(i-1)\n",
        "  assert get_id(*last) == i-1, \"Ids do not match\"\n",
        "  this = get_cords(i)\n",
        "  draw(last, this)\n"
      ],
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "<Figure size 720x720 with 1 Axes>",
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "execution_count": 11,
      "metadata": {
        "collapsed": false,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "execution": {
          "iopub.status.busy": "2022-04-21T05:10:57.510Z",
          "iopub.execute_input": "2022-04-21T05:10:57.522Z",
          "iopub.status.idle": "2022-04-21T05:10:57.755Z",
          "shell.execute_reply": "2022-04-21T05:10:57.758Z"
        }
      }
    }
  ],
  "metadata": {
    "kernel_info": {
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.9.2",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "kernelspec": {
      "argv": [
        "python",
        "-m",
        "ipykernel_launcher",
        "-f",
        "{connection_file}"
      ],
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "nteract": {
      "version": "0.28.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}

One of the problems I faced while working on Plotz was how do you partion segments of a world such that the following criteria are met:

1. Plots must be near other plots. Adding extreme separation or randomness makes the world feel empty.
2. Plots arrangements should be continous. Empty plots make for an empty server.
3. A new plot should be speedy to allocate. Millions of plots may be active at any time. Referencing the x/y coordinate makes it difficult to find the next location to allocate as a plot.

These problems are solved by clamping world coordinates to a square spiral. The problem is that the conversion between x/y world coordinates and the spiral segment index is extremely difficult if not performed iteratively.

The code above defines the formulas necessary to convert x/y to index and index back to x/y.

See here for a great explaination on the math: https://math.stackexchange.com/questions/163080/on-a-two-dimensional-grid-is-there-a-formula-i-can-use-to-spiral-coordinates-in