diff --git a/.DS_Store b/.DS_Store
index 79fb2de..8d8b72d 100644
Binary files a/.DS_Store and b/.DS_Store differ
diff --git a/Python_implementation/.DS_Store b/Python_implementation/.DS_Store
new file mode 100644
index 0000000..0998073
Binary files /dev/null and b/Python_implementation/.DS_Store differ
diff --git a/Python_implementation/Readme.md b/Python_implementation/Readme.md
index 8b13789..39dfe1a 100644
--- a/Python_implementation/Readme.md
+++ b/Python_implementation/Readme.md
@@ -1 +1,31 @@
+## Python implementation details
 
+This is the Python3 implementation of dCrawler is a fully independent clustering algorithm that only requires a distance threshold (Th(d)) to perform clustering.
+
+## Dependencies
+Main libraries. Python version `3.9.18`
+
+````
+matplotlib==3.8.3
+
+numpy==1.26.4
+
+pandas==2.0.3
+
+scikit_learn==1.3.2
+
+scipy==1.11.3
+````
+
+## Usage
+The main implementation is in `dCrawler_api.py` and can be easily used as:
+````python
+from dCrawler_api import*
+crawler = dCrawler(threshold=1.0)
+crawler.fit(data)
+centroids,clusters = crawler.centroids,crawler.clusters
+````
+
+
+## Animation
+![clustering_process](https://github.com/Elsword016/dCrawler/assets/29883365/dd47a04e-43ab-4f59-80a7-18b270d9d135)
diff --git a/Python_implementation/__pycache__/dCrawler_api.cpython-311.pyc b/Python_implementation/__pycache__/dCrawler_api.cpython-311.pyc
new file mode 100644
index 0000000..62850c8
Binary files /dev/null and b/Python_implementation/__pycache__/dCrawler_api.cpython-311.pyc differ
diff --git a/Python_implementation/clustering_process.gif b/Python_implementation/clustering_process.gif
new file mode 100644
index 0000000..3905716
Binary files /dev/null and b/Python_implementation/clustering_process.gif differ
diff --git a/Python_implementation/crawler_animate.ipynb b/Python_implementation/crawler_animate.ipynb
new file mode 100644
index 0000000..dbc5608
--- /dev/null
+++ b/Python_implementation/crawler_animate.ipynb
@@ -0,0 +1,425 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from scipy.spatial import cKDTree\n",
+    "import matplotlib.pyplot as plt\n",
+    "from copy import deepcopy\n",
+    "import pandas as pd\n",
+    "from matplotlib.animation import FuncAnimation\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib.patches import Circle"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 106,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class dCrawler:\n",
+    "    def __init__(self,threshold=1.5): #just a placeholder value user need to the define at the call\n",
+    "        self.threshold = threshold\n",
+    "        self.centroids = None\n",
+    "        self.clusters = None \n",
+    "        self.points = None #initialise the points to none ref at the start, fix the bug of points not being defined \n",
+    "        self.history = [] #for anim saving states for each step\n",
+    " \n",
+    "    def fit(self, points):\n",
+    "        self.points = points\n",
+    "        self.centroids = []\n",
+    "        self.clusters = []\n",
+    "        self.centroids, self.clusters = self._crawler(points)\n",
+    "        #removed because I update at each step: self.history.append((deepcopy(self.centroids), deepcopy(self.clusters), \"Initial Crawl\"))  #deepcopy to avoid the reference issue and overwriting each state is copied independently without overwriting the previous one\n",
+    "        self.centroids, self.clusters = self._adjust_clusters(points)\n",
+    "        #removed because I update at each step: self.history.append((deepcopy(self.centroids), deepcopy(self.clusters), \"Adjust Steps\"))\n",
+    "        self.centroids, self.clusters = self._merge_clusters(points)\n",
+    "        #removed because I update at each step: self.history.append((deepcopy(self.centroids), deepcopy(self.clusters), \"Merge Steps\"))\n",
+    "        self._cleanup_clusters()\n",
+    "        self.history.append((deepcopy(self.centroids), deepcopy(self.clusters), \"Cleanup clusters\"))\n",
+    "        return self\n",
+    "\n",
+    "    def predict(self, points):\n",
+    "        if self.centroids is None or self.clusters is None:\n",
+    "            raise ValueError(\"Model not fitted yet. Call 'fit' before 'predict'.\")\n",
+    "\n",
+    "        kdtree = cKDTree(self.centroids)\n",
+    "        _, labels = kdtree.query(points)\n",
+    "        return labels\n",
+    "\n",
+    "    def _distance(self, point1, point2):\n",
+    "        return np.sqrt(np.sum((point1 - point2) ** 2))\n",
+    "\n",
+    "    def _crawler(self, points):\n",
+    "        n = len(points)\n",
+    "        centroids = []\n",
+    "        clusters = []\n",
+    "        assigned = np.zeros(n, dtype=bool)\n",
+    "\n",
+    "        i = 0\n",
+    "        while i < n:\n",
+    "            if not assigned[i]:\n",
+    "                centroid = points[i]\n",
+    "                cluster = [i]\n",
+    "                assigned[i] = True\n",
+    "                \n",
+    "                while True:\n",
+    "                    distances = np.sqrt(np.sum((points[~assigned] - centroid) ** 2, axis=1))\n",
+    "                    if len(distances) == 0:\n",
+    "                        break\n",
+    "\n",
+    "                    closest_idx = np.argmin(distances)\n",
+    "                    closest_point = points[~assigned][closest_idx]\n",
+    "\n",
+    "                    if distances[closest_idx] <= self.threshold:\n",
+    "                        cluster.append(np.where(~assigned)[0][closest_idx])\n",
+    "                        assigned[np.where(~assigned)[0][closest_idx]] = True\n",
+    "                        centroid = np.mean(points[cluster], axis=0)\n",
+    "\n",
+    "                        distances = np.sqrt(np.sum((points[cluster] - centroid) ** 2, axis=1))\n",
+    "                        cluster = [c for c, d in zip(cluster, distances) if d <= self.threshold]\n",
+    "                        assigned[cluster] = True\n",
+    "\n",
+    "                        #Add step for animation\n",
+    "                        if not self.centroids:\n",
+    "                            vis_centroids = centroids.copy()\n",
+    "                        else:\n",
+    "                            vis_centroids = self.centroids.copy()\n",
+    "                        \n",
+    "                        if not self.centroids:\n",
+    "                            vis_clusters = clusters.copy()\n",
+    "                        else:\n",
+    "                            vis_clusters = self.clusters.copy()\n",
+    "                        \n",
+    "                        vis_centroids.append(centroid)\n",
+    "                        vis_clusters.append(cluster)\n",
+    "                        self.history.append((deepcopy(vis_centroids), deepcopy(vis_clusters), \"Initial Crawl\"))\n",
+    "                        \n",
+    "                    else:\n",
+    "                        break\n",
+    "\n",
+    "                centroids.append(centroid)\n",
+    "                clusters.append(cluster)\n",
+    "\n",
+    "                vis_centroids = centroids\n",
+    "                vis_clusters = clusters\n",
+    "\n",
+    "            i += 1\n",
+    "\n",
+    "        return centroids, clusters\n",
+    "\n",
+    "    def _adjust_clusters(self, points):\n",
+    "        n = len(points)\n",
+    "        assigned = np.zeros(n, dtype=bool)\n",
+    "\n",
+    "        while True:\n",
+    "            kdtree = cKDTree(self.centroids)\n",
+    "            _, labels = kdtree.query(points)\n",
+    "\n",
+    "            if np.all(assigned == labels):\n",
+    "                break\n",
+    "\n",
+    "            assigned = labels\n",
+    "\n",
+    "            for i in range(len(self.centroids)):\n",
+    "                cluster_points = points[labels == i]\n",
+    "                if len(cluster_points) > 0:\n",
+    "                    self.centroids[i] = np.mean(cluster_points, axis=0)\n",
+    "\n",
+    "        self.clusters = [np.where(labels == i)[0] for i in range(len(self.centroids))]\n",
+    "        \n",
+    "        #Add step for animation\n",
+    "        self.history.append((deepcopy(self.centroids), deepcopy(self.clusters), \"Adjust Phase\"))\n",
+    "        \n",
+    "        return self.centroids, self.clusters\n",
+    "\n",
+    "    def _merge_clusters(self, points):\n",
+    "        cluster_thresh = self.threshold\n",
+    "        n_loop = 0\n",
+    "\n",
+    "        while True:\n",
+    "            merged = False\n",
+    "            kdtree = cKDTree(self.centroids)\n",
+    "            distances, _ = kdtree.query(self.centroids, k=2)\n",
+    "            distances = distances[:, 1]\n",
+    "\n",
+    "            merge_indices = np.where(distances <= cluster_thresh)[0]\n",
+    "            #Removed list - this needs to be added to account for the fact that if the cluster has already been merged then we skip it\n",
+    "            removed_list = []\n",
+    "            for i in merge_indices:\n",
+    "                #j = np.argmin(np.sqrt(np.sum((self.centroids - self.centroids[i]) ** 2, axis=1))) --> Here's the problem this should find the second one instead, because the minimum will be itself\n",
+    "                ds = np.sqrt(np.sum((self.centroids - self.centroids[i]) ** 2, axis=1)) # Get all the distances\n",
+    "                ds[i] = cluster_thresh #change it to the cluster thresh\n",
+    "                j = np.argmin(ds) #so now j should be different to i unless it is above the cluster_threshold\n",
+    "\n",
+    "                if i != j:\n",
+    "                    if i not in removed_list:\n",
+    "                        self.centroids[i] = np.mean([self.centroids[i], self.centroids[j]], axis=0) #\n",
+    "                        #self.clusters[i].extend(self.clusters[j]) --> you can't extend a numpy array will concatenate instead\n",
+    "                        self.clusters[i] = np.concatenate((self.clusters[i], self.clusters[j]))\n",
+    "                        self.clusters[j] = []\n",
+    "                        merged = True\n",
+    "                        if len(self.clusters[i]) > 0: #check if the cluster is empty, fix the issue with the range of thresholds\n",
+    "                            cluster_indices = self.clusters[i].astype(int)\n",
+    "                            distances = np.sqrt(np.sum((points[cluster_indices] - self.centroids[i]) ** 2, axis=1))\n",
+    "                            self.clusters[i] = [c for c, d in zip(self.clusters[i], distances) if d <= self.threshold]\n",
+    "                        removed_list.append(j) #add j to the exclude list\n",
+    "            if not merged:\n",
+    "                break\n",
+    "\n",
+    "            self.centroids = [c for c, cl in zip(self.centroids, self.clusters) if len(cl) > 0]\n",
+    "            self.clusters = [cl for cl in self.clusters if len(cl) > 0]\n",
+    "            #Add step for animation\n",
+    "            self.history.append((deepcopy(self.centroids), deepcopy(self.clusters), \"Merge Clusters\"))\n",
+    "\n",
+    "            unassigned_points = np.where(np.isin(np.arange(len(points)), np.concatenate(self.clusters), invert=True))[0]\n",
+    "\n",
+    "            if len(unassigned_points) > 0:\n",
+    "                new_centroids, new_clusters = self._crawler(points[unassigned_points])\n",
+    "                self.centroids.extend(new_centroids)\n",
+    "                self.clusters.extend(new_clusters)\n",
+    "                n_loop += 1\n",
+    "            \n",
+    "            #Add in the adjust step\n",
+    "            self.centroids, self.clusters = self._adjust_clusters(points)\n",
+    "            \n",
+    "            if n_loop > 20:\n",
+    "                break\n",
+    "\n",
+    "            cluster_thresh *= 0.95\n",
+    "\n",
+    "        return self.centroids, self.clusters\n",
+    "\n",
+    "    def _cleanup_clusters(self):\n",
+    "        cluster_ids = np.zeros(len(np.concatenate(self.clusters)), dtype=int)\n",
+    "        for i, cluster in enumerate(self.clusters):\n",
+    "            cluster_ids[cluster] = i + 1\n",
+    "\n",
+    "        self.clusters = [np.where(cluster_ids == i)[0] for i in range(1, np.max(cluster_ids) + 1)] \n",
+    "        self.centroids = [np.mean(self.points[cluster], axis=0) for cluster in self.clusters] #instance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 107,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_state(points, centroids, clusters, title=\"Cluster State\"):\n",
+    "    plt.figure(figsize=(10, 8))\n",
+    "    plt.scatter(points[:, 0], points[:, 1], c='gray', alpha=0.5)  # plot all points\n",
+    "    for idx, cluster_indices in enumerate(clusters):\n",
+    "        plt.scatter(points[cluster_indices, 0], points[cluster_indices, 1], label=f'Cluster {idx + 1}')\n",
+    "        plt.scatter(centroids[idx][0], centroids[idx][1], marker='x', s=100, linewidths=3)\n",
+    "    plt.title(title)\n",
+    "    plt.xlabel('Dimension 1')\n",
+    "    plt.ylabel('Dimension 2')\n",
+    "    plt.legend()\n",
+    "    plt.grid(True)\n",
+    "    plt.show()\n",
+    "\n",
+    "def animate_clustering(history, points, threshold):\n",
+    "    fig, ax = plt.subplots(figsize=(10, 8))\n",
+    "\n",
+    "    x_min = np.floor(np.min(points[:,0]))\n",
+    "    x_max = np.ceil(np.min(points[:,0]))\n",
+    "    y_min = np.floor(np.min(points[:,1]))\n",
+    "    y_max = np.ceil(np.min(points[:,1]))\n",
+    "\n",
+    "    def update(frame_number, x_min=0, x_max=10, y_min=0, y_max=10):\n",
+    "        ax.clear()\n",
+    "        centroids, clusters, step_description = history[frame_number]  # Unpack including the step description\n",
+    "        # Plotting points and clusters\n",
+    "        ax.scatter(points[:, 0], points[:, 1], c='gray', alpha=0.5)  # all points\n",
+    "        # Add in a conditional if clusters exists\n",
+    "        if clusters:\n",
+    "            for idx, cluster_indices in enumerate(clusters):\n",
+    "                ax.scatter(points[cluster_indices, 0], points[cluster_indices, 1], label=f'Cluster {idx + 1}')\n",
+    "                ax.scatter(centroids[idx][0], centroids[idx][1], color='red', marker='x', s=100, linewidths=3)\n",
+    "                # Drawing a circle around the centroid\n",
+    "                circle = Circle((centroids[idx][0], centroids[idx][1]), threshold, color='blue', fill=False, linestyle='--', linewidth=1.5)\n",
+    "                ax.add_patch(circle)\n",
+    "        ax.set_title(f\"{step_description}\")\n",
+    "        ax.set_xlim([x_min,x_max])\n",
+    "        ax.set_ylim([y_min,y_max])\n",
+    "        ax.set_xlabel('Dimension 1')\n",
+    "        ax.set_ylabel('Dimension 2')\n",
+    "        if clusters:\n",
+    "            ax.legend()\n",
+    "        ax.grid(True)\n",
+    "\n",
+    "    ani = FuncAnimation(fig, update, frames=range(len(history)), repeat=False)\n",
+    "    ani.save('clustering_process.gif', writer='pillow', fps=2) #change the name and fps "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 108,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv('../DemoData/demodata.csv')\n",
+    "data = df.to_numpy()[:,:2]\n",
+    "#points = data #some weird bug with the var name in the class fixedb-< properly referenced in the class\n",
+    "true_labels = df['Cluster'].to_numpy()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 109,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "crawler = dCrawler(threshold=1.0)\n",
+    "crawler.fit(data) \n",
+    "animate_clustering(crawler.history, data, crawler.threshold) #it will always show the final state of the clustering but the gif will show the process"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "range(0, 486)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(range(len(crawler.history)))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[(None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), (None, None, 'Initial Crawl'), ([array([1.68733764, 1.91140838]), array([0.49018457, 2.15471646]), array([1.00334237, 7.97143963]), array([3.99590172, 0.96870191]), array([2.95616436, 8.04957297]), array([3.70838213, 0.        ]), array([4.00138897, 5.51919087]), array([4.10543659, 4.29679213]), array([3.80904423, 6.62505413]), array([6.96461861, 0.99698935]), array([7.97758093, 4.06132701]), array([8.9600848 , 7.02169029])], [[0, 24, 22, 3, 60, 20, 18, 17, 23, 1, 63, 51, 53, 74, 55, 59, 69, 19, 12, 68, 11, 65, 52, 61, 4, 7, 16, 15, 67, 14, 73, 56, 8, 50, 64, 71, 57, 54, 72, 66, 6, 13, 62, 58, 9], [2, 21, 5, 10], [25, 49, 47, 26, 40, 29, 37, 48, 34, 46, 32, 45, 28, 31, 38, 36, 42, 27, 35, 41, 33, 39, 30, 44, 43], [114, 124, 101, 117, 116, 119, 123, 110, 104, 113, 109, 103, 100, 108, 105, 107, 102, 106, 115, 120, 118, 121, 111, 122], [75, 99, 94, 90, 98, 77, 76, 93, 83, 84, 81, 85, 92, 78, 91, 97, 95, 87, 86, 80, 79, 82, 89, 96, 88], [112], [125, 137, 129, 126, 145, 128, 144, 135, 143, 127, 134, 130, 153, 163, 147, 138, 158, 156, 165, 142, 131, 151, 140, 155, 171, 160, 157, 152, 169, 159, 174, 133, 167, 166, 172, 150, 173, 168, 132, 162, 154, 136, 164], [139, 141, 149, 146, 148], [161, 170], [175, 190, 182, 176, 194, 198, 191, 193, 183, 189, 199, 177, 181, 186, 197, 192, 188, 184, 195, 196, 187, 185, 179, 180, 178], [200, 205, 224, 215, 216, 207, 218, 221, 212, 214, 223, 204, 206, 208, 217, 219, 211, 202, 220, 222, 201, 203, 213, 210, 209], [225, 238, 242, 248, 249, 232, 243, 234, 241, 229, 235, 231, 245, 228, 246, 240, 237, 230, 233, 227, 239, 244, 236, 247, 226]], 'Initial Crawl'), ([array([2.08294713, 1.8538119 ]), array([1.11261139, 2.00446074]), array([1.00334237, 7.97143963]), array([4.04574056, 1.02099486]), array([2.95616436, 8.04957297]), array([3.6623679 , 0.45198845]), array([4.16704437, 5.27364466]), array([3.84078678, 4.61438774]), array([3.95543785, 6.08805099]), array([6.96461861, 0.99698935]), array([7.97758093, 4.06132701]), array([8.9600848 , 7.02169029])], [array([ 8,  9, 11, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 61, 62, 63, 64,\n",
+      "       65, 66, 68, 69, 70, 71, 72, 73, 74]), array([ 0,  1,  2,  3,  4,  5,  6,  7, 10, 12, 13, 14, 15, 16, 17, 18, 19,\n",
+      "       20, 21, 22, 23, 24, 60, 67]), array([25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,\n",
+      "       42, 43, 44, 45, 46, 47, 48, 49]), array([100, 101, 102, 103, 104, 105, 106, 108, 109, 110, 111, 113, 114,\n",
+      "       116, 117, 118, 119, 121, 122, 123, 124]), array([75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,\n",
+      "       92, 93, 94, 95, 96, 97, 98, 99]), array([107, 112, 115, 120]), array([127, 128, 130, 131, 133, 134, 135, 138, 142, 143, 144, 145, 147,\n",
+      "       153, 156, 158, 163, 165]), array([125, 126, 129, 132, 136, 137, 139, 140, 141, 146, 148, 149]), array([150, 151, 152, 154, 155, 157, 159, 160, 161, 162, 164, 166, 167,\n",
+      "       168, 169, 170, 171, 172, 173, 174]), array([175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,\n",
+      "       188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199]), array([200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212,\n",
+      "       213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224]), array([225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237,\n",
+      "       238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249])], 'Adjust Steps'), ([array([1.59777926, 1.92913632]), array([1.00334237, 7.97143963]), array([3.85405423, 0.73649166]), array([2.95616436, 8.04957297]), array([4.00391557, 4.9440162 ]), array([3.95543785, 6.08805099]), array([6.96461861, 0.99698935]), array([7.97758093, 4.06132701]), array([8.9600848 , 7.02169029])], [[8, 9, 11, 50, 51, 52, 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, 65, 66, 68, 69, 71, 72, 73, 74, 0, 1, 3, 4, 6, 7, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 60, 67], array([25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,\n",
+      "       42, 43, 44, 45, 46, 47, 48, 49]), [100, 101, 102, 103, 104, 105, 106, 108, 109, 110, 111, 113, 114, 116, 117, 118, 119, 121, 122, 123, 124, 107, 112, 115, 120], array([75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,\n",
+      "       92, 93, 94, 95, 96, 97, 98, 99]), [127, 128, 130, 131, 133, 134, 135, 138, 142, 143, 144, 145, 147, 153, 156, 158, 163, 165, 125, 126, 129, 132, 136, 137, 139, 140, 141, 146, 148, 149], array([150, 151, 152, 154, 155, 157, 159, 160, 161, 162, 164, 166, 167,\n",
+      "       168, 169, 170, 171, 172, 173, 174]), array([175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,\n",
+      "       188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199]), array([200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212,\n",
+      "       213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224]), array([225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237,\n",
+      "       238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249])], 'Initial Crawl'), ([array([1.59777926, 1.92913632]), array([1.00334237, 7.97143963]), array([3.85405423, 0.73649166]), array([2.95616436, 8.04957297]), array([4.00391557, 4.9440162 ]), array([3.95543785, 6.08805099]), array([6.96461861, 0.99698935]), array([7.97758093, 4.06132701]), array([8.9600848 , 7.02169029])], [[8, 9, 11, 50, 51, 52, 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, 65, 66, 68, 69, 71, 72, 73, 74, 0, 1, 3, 4, 6, 7, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 60, 67], array([25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,\n",
+      "       42, 43, 44, 45, 46, 47, 48, 49]), [100, 101, 102, 103, 104, 105, 106, 108, 109, 110, 111, 113, 114, 116, 117, 118, 119, 121, 122, 123, 124, 107, 112, 115, 120], array([75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,\n",
+      "       92, 93, 94, 95, 96, 97, 98, 99]), [127, 128, 130, 131, 133, 134, 135, 138, 142, 143, 144, 145, 147, 153, 156, 158, 163, 165, 125, 126, 129, 132, 136, 137, 139, 140, 141, 146, 148, 149], array([150, 151, 152, 154, 155, 157, 159, 160, 161, 162, 164, 166, 167,\n",
+      "       168, 169, 170, 171, 172, 173, 174]), array([175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,\n",
+      "       188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199]), array([200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212,\n",
+      "       213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224]), array([225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237,\n",
+      "       238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249])], 'Initial Crawl'), ([array([1.59777926, 1.92913632]), array([1.00334237, 7.97143963]), array([3.85405423, 0.73649166]), array([2.95616436, 8.04957297]), array([4.00391557, 4.9440162 ]), array([3.95543785, 6.08805099]), array([6.96461861, 0.99698935]), array([7.97758093, 4.06132701]), array([8.9600848 , 7.02169029])], [[8, 9, 11, 50, 51, 52, 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, 65, 66, 68, 69, 71, 72, 73, 74, 0, 1, 3, 4, 6, 7, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 60, 67], array([25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,\n",
+      "       42, 43, 44, 45, 46, 47, 48, 49]), [100, 101, 102, 103, 104, 105, 106, 108, 109, 110, 111, 113, 114, 116, 117, 118, 119, 121, 122, 123, 124, 107, 112, 115, 120], array([75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,\n",
+      "       92, 93, 94, 95, 96, 97, 98, 99]), [127, 128, 130, 131, 133, 134, 135, 138, 142, 143, 144, 145, 147, 153, 156, 158, 163, 165, 125, 126, 129, 132, 136, 137, 139, 140, 141, 146, 148, 149], array([150, 151, 152, 154, 155, 157, 159, 160, 161, 162, 164, 166, 167,\n",
+      "       168, 169, 170, 171, 172, 173, 174]), array([175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,\n",
+      "       188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199]), array([200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212,\n",
+      "       213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224]), array([225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237,\n",
+      "       238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249])], 'Initial Crawl'), ([array([1.59777926, 1.92913632]), array([1.00334237, 7.97143963]), array([3.85405423, 0.73649166]), array([2.95616436, 8.04957297]), array([4.00391557, 4.9440162 ]), array([3.95543785, 6.08805099]), array([6.96461861, 0.99698935]), array([7.97758093, 4.06132701]), array([8.9600848 , 7.02169029])], [[8, 9, 11, 50, 51, 52, 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, 65, 66, 68, 69, 71, 72, 73, 74, 0, 1, 3, 4, 6, 7, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 60, 67], array([25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,\n",
+      "       42, 43, 44, 45, 46, 47, 48, 49]), [100, 101, 102, 103, 104, 105, 106, 108, 109, 110, 111, 113, 114, 116, 117, 118, 119, 121, 122, 123, 124, 107, 112, 115, 120], array([75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,\n",
+      "       92, 93, 94, 95, 96, 97, 98, 99]), [127, 128, 130, 131, 133, 134, 135, 138, 142, 143, 144, 145, 147, 153, 156, 158, 163, 165, 125, 126, 129, 132, 136, 137, 139, 140, 141, 146, 148, 149], array([150, 151, 152, 154, 155, 157, 159, 160, 161, 162, 164, 166, 167,\n",
+      "       168, 169, 170, 171, 172, 173, 174]), array([175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,\n",
+      "       188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199]), array([200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212,\n",
+      "       213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224]), array([225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237,\n",
+      "       238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249])], 'Initial Crawl'), ([array([1.59777926, 1.92913632]), array([1.00334237, 7.97143963]), array([3.85405423, 0.73649166]), array([2.95616436, 8.04957297]), array([4.00391557, 4.9440162 ]), array([3.95543785, 6.08805099]), array([6.96461861, 0.99698935]), array([7.97758093, 4.06132701]), array([8.9600848 , 7.02169029])], [[8, 9, 11, 50, 51, 52, 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, 65, 66, 68, 69, 71, 72, 73, 74, 0, 1, 3, 4, 6, 7, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 60, 67], array([25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,\n",
+      "       42, 43, 44, 45, 46, 47, 48, 49]), [100, 101, 102, 103, 104, 105, 106, 108, 109, 110, 111, 113, 114, 116, 117, 118, 119, 121, 122, 123, 124, 107, 112, 115, 120], array([75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,\n",
+      "       92, 93, 94, 95, 96, 97, 98, 99]), [127, 128, 130, 131, 133, 134, 135, 138, 142, 143, 144, 145, 147, 153, 156, 158, 163, 165, 125, 126, 129, 132, 136, 137, 139, 140, 141, 146, 148, 149], array([150, 151, 152, 154, 155, 157, 159, 160, 161, 162, 164, 166, 167,\n",
+      "       168, 169, 170, 171, 172, 173, 174]), array([175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,\n",
+      "       188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199]), array([200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212,\n",
+      "       213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224]), array([225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237,\n",
+      "       238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249])], 'Initial Crawl'), ([array([1.59777926, 1.92913632]), array([1.00334237, 7.97143963]), array([3.85405423, 0.73649166]), array([2.95616436, 8.04957297]), array([4.00391557, 4.9440162 ]), array([3.95543785, 6.08805099]), array([6.96461861, 0.99698935]), array([7.97758093, 4.06132701]), array([8.9600848 , 7.02169029])], [[8, 9, 11, 50, 51, 52, 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, 65, 66, 68, 69, 71, 72, 73, 74, 0, 1, 3, 4, 6, 7, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 60, 67], array([25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,\n",
+      "       42, 43, 44, 45, 46, 47, 48, 49]), [100, 101, 102, 103, 104, 105, 106, 108, 109, 110, 111, 113, 114, 116, 117, 118, 119, 121, 122, 123, 124, 107, 112, 115, 120], array([75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,\n",
+      "       92, 93, 94, 95, 96, 97, 98, 99]), [127, 128, 130, 131, 133, 134, 135, 138, 142, 143, 144, 145, 147, 153, 156, 158, 163, 165, 125, 126, 129, 132, 136, 137, 139, 140, 141, 146, 148, 149], array([150, 151, 152, 154, 155, 157, 159, 160, 161, 162, 164, 166, 167,\n",
+      "       168, 169, 170, 171, 172, 173, 174]), array([175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,\n",
+      "       188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199]), array([200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212,\n",
+      "       213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224]), array([225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237,\n",
+      "       238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249])], 'Initial Crawl'), ([array([1.17213772, 2.01157769]), array([1.00334237, 7.97143963]), array([3.98440093, 0.92995384]), array([2.95616436, 8.04957297]), array([4.03980802, 4.97016852]), array([3.95865329, 6.04066172]), array([6.96461861, 0.99698935]), array([7.97758093, 4.06132701]), array([8.9600848 , 7.02169029]), array([2.13963393, 1.82580737])], [array([ 0,  1,  2,  3,  4,  5,  6,  7, 10, 12, 13, 14, 15, 16, 17, 18, 19,\n",
+      "       20, 21, 22, 23, 24, 51, 60, 63, 67, 69]), array([25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,\n",
+      "       42, 43, 44, 45, 46, 47, 48, 49]), array([100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n",
+      "       113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124]), array([75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,\n",
+      "       92, 93, 94, 95, 96, 97, 98, 99]), array([125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137,\n",
+      "       138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 153,\n",
+      "       158, 163]), array([150, 151, 152, 154, 155, 156, 157, 159, 160, 161, 162, 164, 165,\n",
+      "       166, 167, 168, 169, 170, 171, 172, 173, 174]), array([175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,\n",
+      "       188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199]), array([200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212,\n",
+      "       213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224]), array([225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237,\n",
+      "       238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249]), array([ 8,  9, 11, 50, 52, 53, 54, 55, 56, 57, 58, 59, 61, 62, 64, 65, 66,\n",
+      "       68, 70, 71, 72, 73, 74])], 'Merge Steps'), ([array([1.17213772, 2.01157769]), array([1.00334237, 7.97143963]), array([3.98440093, 0.92995384]), array([2.95616436, 8.04957297]), array([4.03980802, 4.97016852]), array([3.95865329, 6.04066172]), array([6.96461861, 0.99698935]), array([7.97758093, 4.06132701]), array([8.9600848 , 7.02169029]), array([2.13963393, 1.82580737])], [array([ 0,  1,  2,  3,  4,  5,  6,  7, 10, 12, 13, 14, 15, 16, 17, 18, 19,\n",
+      "       20, 21, 22, 23, 24, 51, 60, 63, 67, 69]), array([25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,\n",
+      "       42, 43, 44, 45, 46, 47, 48, 49]), array([100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n",
+      "       113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124]), array([75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,\n",
+      "       92, 93, 94, 95, 96, 97, 98, 99]), array([125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137,\n",
+      "       138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 153,\n",
+      "       158, 163]), array([150, 151, 152, 154, 155, 156, 157, 159, 160, 161, 162, 164, 165,\n",
+      "       166, 167, 168, 169, 170, 171, 172, 173, 174]), array([175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,\n",
+      "       188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199]), array([200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212,\n",
+      "       213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224]), array([225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237,\n",
+      "       238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249]), array([ 8,  9, 11, 50, 52, 53, 54, 55, 56, 57, 58, 59, 61, 62, 64, 65, 66,\n",
+      "       68, 70, 71, 72, 73, 74])], 'Cleanup clusters')]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(crawler.history)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "stable",
+   "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.11.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Python_implementation/dCrawler_api.py b/Python_implementation/dCrawler_api.py
new file mode 100644
index 0000000..8dc5e9c
--- /dev/null
+++ b/Python_implementation/dCrawler_api.py
@@ -0,0 +1,158 @@
+# %%
+from scipy.spatial import cKDTree
+import numpy as np
+from scipy.spatial import distance_matrix
+from sklearn.metrics import pairwise_distances
+import pandas as pd 
+import matplotlib.pyplot as plt
+from scipy.spatial import cKDTree
+
+# %%
+class dCrawler:
+    def __init__(self,threshold=1.5): #just a placeholder value user need to the define at the call
+        self.threshold = threshold
+        self.centroids = None
+        self.clusters = None 
+        self.points = None #initialise the points to none ref at the start, fix the bug of points not being defined 
+ 
+    def fit(self, points):
+        self.points = points
+        self.centroids, self.clusters = self._crawler(points)
+        self.centroids, self.clusters = self._adjust_clusters(points)
+        self.centroids, self.clusters = self._merge_clusters(points)
+        self._cleanup_clusters()
+        return self
+
+    def predict(self, points):
+        if self.centroids is None or self.clusters is None:
+            raise ValueError("Model not fitted yet. Call 'fit' before 'predict'.")
+
+        kdtree = cKDTree(self.centroids)
+        _, labels = kdtree.query(points)
+        return labels
+
+    def _distance(self, point1, point2):
+        return np.sqrt(np.sum((point1 - point2) ** 2))
+
+    def _crawler(self, points):
+        n = len(points)
+        centroids = []
+        clusters = []
+        assigned = np.zeros(n, dtype=bool)
+
+        i = 0
+        while i < n:
+            if not assigned[i]:
+                centroid = points[i]
+                cluster = [i]
+                assigned[i] = True
+
+                while True:
+                    distances = np.sqrt(np.sum((points[~assigned] - centroid) ** 2, axis=1))
+                    if len(distances) == 0:
+                        break
+
+                    closest_idx = np.argmin(distances)
+                    closest_point = points[~assigned][closest_idx]
+
+                    if distances[closest_idx] <= self.threshold:
+                        cluster.append(np.where(~assigned)[0][closest_idx])
+                        assigned[np.where(~assigned)[0][closest_idx]] = True
+                        centroid = np.mean(points[cluster], axis=0)
+
+                        distances = np.sqrt(np.sum((points[cluster] - centroid) ** 2, axis=1))
+                        cluster = [c for c, d in zip(cluster, distances) if d <= self.threshold]
+                        assigned[cluster] = True
+                    else:
+                        break
+
+                centroids.append(centroid)
+                clusters.append(cluster)
+
+            i += 1
+
+        return centroids, clusters
+
+    def _adjust_clusters(self, points):
+        n = len(points)
+        assigned = np.zeros(n, dtype=bool)
+
+        while True:
+            kdtree = cKDTree(self.centroids)
+            _, labels = kdtree.query(points)
+
+            if np.all(assigned == labels):
+                break
+
+            assigned = labels
+
+            for i in range(len(self.centroids)):
+                cluster_points = points[labels == i]
+                if len(cluster_points) > 0:
+                    self.centroids[i] = np.mean(cluster_points, axis=0)
+
+        self.clusters = [np.where(labels == i)[0] for i in range(len(self.centroids))]
+        return self.centroids, self.clusters
+
+    def _merge_clusters(self, points):
+        cluster_thresh = self.threshold
+        n_loop = 0
+
+        while True:
+            merged = False
+            kdtree = cKDTree(self.centroids)
+            distances, _ = kdtree.query(self.centroids, k=2)
+            distances = distances[:, 1]
+
+            merge_indices = np.where(distances <= cluster_thresh)[0]
+            #Removed list - this needs to be added to account for the fact that if the cluster has already been merged then we skip it
+            removed_list = []
+            for i in merge_indices:
+                #j = np.argmin(np.sqrt(np.sum((self.centroids - self.centroids[i]) ** 2, axis=1))) --> Here's the problem this should find the second one instead, because the minimum will be itself
+                ds = np.sqrt(np.sum((self.centroids - self.centroids[i]) ** 2, axis=1)) # Get all the distances
+                ds[i] = cluster_thresh #change it to the cluster thresh
+                j = np.argmin(ds) #so now j should be different to i unless it is above the cluster_threshold
+
+                if i != j:
+                    if i not in removed_list:
+                        self.centroids[i] = np.mean([self.centroids[i], self.centroids[j]], axis=0) #
+                        #self.clusters[i].extend(self.clusters[j]) --> you can't extend a numpy array will concatenate instead
+                        self.clusters[i] = np.concatenate((self.clusters[i], self.clusters[j]))
+                        self.clusters[j] = []
+                        merged = True
+                        if len(self.clusters[i]) > 0: #check if the cluster is empty, fix the issue with the range of thresholds
+                            cluster_indices = self.clusters[i].astype(int)
+                            distances = np.sqrt(np.sum((points[cluster_indices] - self.centroids[i]) ** 2, axis=1))
+                            self.clusters[i] = [c for c, d in zip(self.clusters[i], distances) if d <= self.threshold]
+                        removed_list.append(j) #add j to the exclude list
+            if not merged:
+                break
+
+            self.centroids = [c for c, cl in zip(self.centroids, self.clusters) if len(cl) > 0]
+            self.clusters = [cl for cl in self.clusters if len(cl) > 0]
+
+            unassigned_points = np.where(np.isin(np.arange(len(points)), np.concatenate(self.clusters), invert=True))[0]
+
+            if len(unassigned_points) > 0:
+                new_centroids, new_clusters = self._crawler(points[unassigned_points])
+                self.centroids.extend(new_centroids)
+                self.clusters.extend(new_clusters)
+                n_loop += 1
+            
+            #Add in the adjust step
+            self.centroids, self.clusters = self._adjust_clusters(points)
+            
+            if n_loop > 20:
+                break
+
+            cluster_thresh *= 0.95
+
+        return self.centroids, self.clusters
+
+    def _cleanup_clusters(self):
+        cluster_ids = np.zeros(len(np.concatenate(self.clusters)), dtype=int)
+        for i, cluster in enumerate(self.clusters):
+            cluster_ids[cluster] = i + 1
+
+        self.clusters = [np.where(cluster_ids == i)[0] for i in range(1, np.max(cluster_ids) + 1)] 
+        self.centroids = [np.mean(self.points[cluster], axis=0) for cluster in self.clusters] #instance
\ No newline at end of file
diff --git a/Python_implementation/test.py b/Python_implementation/test.py
new file mode 100644
index 0000000..8ed92ab
--- /dev/null
+++ b/Python_implementation/test.py
@@ -0,0 +1,13 @@
+from dCrawler_api import *
+
+import pandas as pd
+data_path = "../DemoData/demodata.csv"
+df = pd.read_csv(data_path)
+data = df.to_numpy()[:,:2]
+
+crawler = dCrawler(threshold=1.0)
+crawler.fit(data)
+centroids,clusters = crawler.centroids,crawler.clusters
+print(clusters)
+
+
diff --git a/dCrawler/LICENSE b/dCrawler/LICENSE
new file mode 100644
index 0000000..d933426
--- /dev/null
+++ b/dCrawler/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) <year> Marcus Lewie,et;al
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/dCrawler/README.md b/dCrawler/README.md
new file mode 100644
index 0000000..0d0cd63
--- /dev/null
+++ b/dCrawler/README.md
@@ -0,0 +1,58 @@
+## dCrawler 
+
+This is the Python3 implementation of dCrawler is a fully independent clustering algorithm that only requires a distance threshold (Th(d)) to perform clustering.
+
+Featured in the preprint:  **Automated neuronal reconstruction with super-multicolour fluorescence imaging** , Lewie et,al (2022) [bioRxiv](https://www.biorxiv.org/content/10.1101/2022.10.20.512984v1)
+
+## Implementation details
+
+A few things are different in the Python version to make it a bit more efficient, the results are the same as the MATLAB code.
+- Vectorized operations are used wherever possible to speed up computations.
+- The `cKDTree` from the `scipy.spatial` module is used for efficient nearest neighbor search. Instead of calculating distances to all centroids for each point, the k-d tree is used to find the nearest centroid quickly.
+
+
+![clustering_process](https://github.com/Elsword016/dCrawler/assets/29883365/2f7e6394-50e5-452a-b398-4e3022bf2ce1)
+
+## Installation
+
+```bash
+pip install dCrawler
+```
+
+## Build from source - local development
+Recommended to build a separate environment to prevent any possible errors
+- Clone the repository
+- Build the package with the command `python setup.py sdist`
+- Then `pip install .`
+
+## Usage
+
+```python
+from dCrawler import dCrawler
+# Initialize the dCrawler object
+crawler = dCrawler(threshold=1.0)
+crawler.fit(data)
+centroids,clusters = crawler.centroids,crawler.clusters
+```
+
+
+
+
+## Contributing
+
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
+
+## Cite
+```bash
+@article {Leiwe2022.10.20.512984,
+	author = {Marcus N. Leiwe and Satoshi Fujimoto and Toshikazu Baba and Daichi Moriyasu and Biswanath Saha and Richi Sakaguchi and Shigenori Inagaki and Takeshi Imai},
+	title = {Automated neuronal reconstruction with super-multicolour fluorescence imaging},
+	elocation-id = {2022.10.20.512984},
+	year = {2022},
+	doi = {10.1101/2022.10.20.512984},
+	abstract = {Fluorescence imaging is widely used for the mesoscopic mapping of neuronal connectivity. However, neurite reconstruction is challenging, especially when neurons are densely labelled. Here we report a strategy for the fully automated reconstruction of densely labelled neuronal circuits. Firstly, we established stochastic {\textquotedblleft}super-multicolour{\textquotedblright} labelling with up to seven different fluorescent proteins using the Tetbow method. With this method, each neuron was labelled with a unique combination of fluorescent proteins, which were then imaged and separated by linear unmixing. We also established an automated neurite reconstruction pipeline based on the quantitative analysis of multiple dyes (QDyeFinder). To classify colour combinations, we used a newly developed unsupervised clustering algorithm, dCrawler, in which data points in multi-dimensional space were clustered based on a given threshold distance. Our new strategy allows for the reconstruction of neurites for up to hundreds of neurons at a millimetre scale without manual tracing. Competing Interest StatementTI, MNL, and SF has filed a patent application for QDyeFinder.},
+	URL = {https://www.biorxiv.org/content/early/2022/10/20/2022.10.20.512984},
+	eprint = {https://www.biorxiv.org/content/early/2022/10/20/2022.10.20.512984.full.pdf},
+	journal = {bioRxiv}
+}
+```
diff --git a/dCrawler/dCrawler/__init__.py b/dCrawler/dCrawler/__init__.py
new file mode 100644
index 0000000..dafe584
--- /dev/null
+++ b/dCrawler/dCrawler/__init__.py
@@ -0,0 +1 @@
+from .dCrawler import dCrawler
\ No newline at end of file
diff --git a/dCrawler/dCrawler/__pycache__/__init__.cpython-311.pyc b/dCrawler/dCrawler/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000..2b445e5
Binary files /dev/null and b/dCrawler/dCrawler/__pycache__/__init__.cpython-311.pyc differ
diff --git a/dCrawler/dCrawler/__pycache__/dCrawler.cpython-311.pyc b/dCrawler/dCrawler/__pycache__/dCrawler.cpython-311.pyc
new file mode 100644
index 0000000..59e4328
Binary files /dev/null and b/dCrawler/dCrawler/__pycache__/dCrawler.cpython-311.pyc differ
diff --git a/dCrawler/dCrawler/dCrawler.py b/dCrawler/dCrawler/dCrawler.py
new file mode 100644
index 0000000..509ce09
--- /dev/null
+++ b/dCrawler/dCrawler/dCrawler.py
@@ -0,0 +1,157 @@
+# %%
+from scipy.spatial import cKDTree
+import numpy as np
+from scipy.spatial import distance_matrix
+from sklearn.metrics import pairwise_distances
+import pandas as pd 
+import matplotlib.pyplot as plt
+
+# %%
+class dCrawler:
+    def __init__(self,threshold=1.5): #just a placeholder value user need to the define at the call
+        self.threshold = threshold
+        self.centroids = None
+        self.clusters = None 
+        self.points = None #initialise the points to none ref at the start, fix the bug of points not being defined 
+ 
+    def fit(self, points):
+        self.points = points
+        self.centroids, self.clusters = self._crawler(points)
+        self.centroids, self.clusters = self._adjust_clusters(points)
+        self.centroids, self.clusters = self._merge_clusters(points)
+        self._cleanup_clusters()
+        return self
+
+    def predict(self, points):
+        if self.centroids is None or self.clusters is None:
+            raise ValueError("Model not fitted yet. Call 'fit' before 'predict'.")
+
+        kdtree = cKDTree(self.centroids)
+        _, labels = kdtree.query(points)
+        return labels
+
+    def _distance(self, point1, point2):
+        return np.sqrt(np.sum((point1 - point2) ** 2))
+
+    def _crawler(self, points):
+        n = len(points)
+        centroids = []
+        clusters = []
+        assigned = np.zeros(n, dtype=bool)
+
+        i = 0
+        while i < n:
+            if not assigned[i]:
+                centroid = points[i]
+                cluster = [i]
+                assigned[i] = True
+
+                while True:
+                    distances = np.sqrt(np.sum((points[~assigned] - centroid) ** 2, axis=1))
+                    if len(distances) == 0:
+                        break
+
+                    closest_idx = np.argmin(distances)
+                    closest_point = points[~assigned][closest_idx]
+
+                    if distances[closest_idx] <= self.threshold:
+                        cluster.append(np.where(~assigned)[0][closest_idx])
+                        assigned[np.where(~assigned)[0][closest_idx]] = True
+                        centroid = np.mean(points[cluster], axis=0)
+
+                        distances = np.sqrt(np.sum((points[cluster] - centroid) ** 2, axis=1))
+                        cluster = [c for c, d in zip(cluster, distances) if d <= self.threshold]
+                        assigned[cluster] = True
+                    else:
+                        break
+
+                centroids.append(centroid)
+                clusters.append(cluster)
+
+            i += 1
+
+        return centroids, clusters
+
+    def _adjust_clusters(self, points):
+        n = len(points)
+        assigned = np.zeros(n, dtype=bool)
+
+        while True:
+            kdtree = cKDTree(self.centroids)
+            _, labels = kdtree.query(points)
+
+            if np.all(assigned == labels):
+                break
+
+            assigned = labels
+
+            for i in range(len(self.centroids)):
+                cluster_points = points[labels == i]
+                if len(cluster_points) > 0:
+                    self.centroids[i] = np.mean(cluster_points, axis=0)
+
+        self.clusters = [np.where(labels == i)[0] for i in range(len(self.centroids))]
+        return self.centroids, self.clusters
+
+    def _merge_clusters(self, points):
+        cluster_thresh = self.threshold
+        n_loop = 0
+
+        while True:
+            merged = False
+            kdtree = cKDTree(self.centroids)
+            distances, _ = kdtree.query(self.centroids, k=2)
+            distances = distances[:, 1]
+
+            merge_indices = np.where(distances <= cluster_thresh)[0]
+            #Removed list - this needs to be added to account for the fact that if the cluster has already been merged then we skip it
+            removed_list = []
+            for i in merge_indices:
+                #j = np.argmin(np.sqrt(np.sum((self.centroids - self.centroids[i]) ** 2, axis=1))) --> Here's the problem this should find the second one instead, because the minimum will be itself
+                ds = np.sqrt(np.sum((self.centroids - self.centroids[i]) ** 2, axis=1)) # Get all the distances
+                ds[i] = cluster_thresh #change it to the cluster thresh
+                j = np.argmin(ds) #so now j should be different to i unless it is above the cluster_threshold
+
+                if i != j:
+                    if i not in removed_list:
+                        self.centroids[i] = np.mean([self.centroids[i], self.centroids[j]], axis=0) #
+                        #self.clusters[i].extend(self.clusters[j]) --> you can't extend a numpy array will concatenate instead
+                        self.clusters[i] = np.concatenate((self.clusters[i], self.clusters[j]))
+                        self.clusters[j] = []
+                        merged = True
+                        if len(self.clusters[i]) > 0: #check if the cluster is empty, fix the issue with the range of thresholds
+                            cluster_indices = self.clusters[i].astype(int)
+                            distances = np.sqrt(np.sum((points[cluster_indices] - self.centroids[i]) ** 2, axis=1))
+                            self.clusters[i] = [c for c, d in zip(self.clusters[i], distances) if d <= self.threshold]
+                        removed_list.append(j) #add j to the exclude list
+            if not merged:
+                break
+
+            self.centroids = [c for c, cl in zip(self.centroids, self.clusters) if len(cl) > 0]
+            self.clusters = [cl for cl in self.clusters if len(cl) > 0]
+
+            unassigned_points = np.where(np.isin(np.arange(len(points)), np.concatenate(self.clusters), invert=True))[0]
+
+            if len(unassigned_points) > 0:
+                new_centroids, new_clusters = self._crawler(points[unassigned_points])
+                self.centroids.extend(new_centroids)
+                self.clusters.extend(new_clusters)
+                n_loop += 1
+            
+            #Add in the adjust step
+            self.centroids, self.clusters = self._adjust_clusters(points)
+            
+            if n_loop > 20:
+                break
+
+            cluster_thresh *= 0.95
+
+        return self.centroids, self.clusters
+
+    def _cleanup_clusters(self):
+        cluster_ids = np.zeros(len(np.concatenate(self.clusters)), dtype=int)
+        for i, cluster in enumerate(self.clusters):
+            cluster_ids[cluster] = i + 1
+
+        self.clusters = [np.where(cluster_ids == i)[0] for i in range(1, np.max(cluster_ids) + 1)] 
+        self.centroids = [np.mean(self.points[cluster], axis=0) for cluster in self.clusters] #instance
\ No newline at end of file
diff --git a/dCrawler/setup.py b/dCrawler/setup.py
new file mode 100644
index 0000000..7619136
--- /dev/null
+++ b/dCrawler/setup.py
@@ -0,0 +1,23 @@
+from setuptools import setup,find_packages
+setup(
+    name='dCrawler',
+    version='0.1',
+    author='Marcus Lewie,Biswanath Saha',
+    author_email='mlewie@gmail.com',
+    description='dCrawler is a fully independent clustering algorithm that only requires a distance threshold (Th(d)) to perform clustering.',
+    packages=find_packages(),
+    install_requires=[
+        'numpy',
+        'scipy',
+        'matplotlib',
+        'scikit-learn',
+        'pandas',
+        'scipy',
+    ],
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+    python_requires='>=3.9',
+)