unit-test-counts.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import multiprocessing\n",
    "import numpy as np\n",
    "from sklearn.metrics.pairwise import euclidean_distances\n",
    "\n",
    "from SpatialUMAP import SpatialUMAP\n",
    "\n",
    "def process_cell_counts(i, cell_positions, cell_labels, dist_bin_px):\n",
    "    # squared distance\n",
    "    counts = np.sum(np.square(cell_positions[i][np.newaxis, :] - cell_positions), axis=1)\n",
    "    # inequalities around arcs\n",
    "    counts = counts[np.newaxis, :] <= np.square(np.concatenate([[0], dist_bin_px]))[:, np.newaxis]\n",
    "    # matmul to counts\n",
    "    counts = np.diff(np.matmul(counts.astype(int), cell_labels.astype(int)), axis=0)\n",
    "    # return index and counts\n",
    "    return i, counts\n",
    "\n",
    "def per_image_cell_counts_euc(image, cell_positions, cell_labels, targ_labels, dist_bin_px):\n",
    "    '''\n",
    "    per_image_cell_counts_euc() returns the number of cells within a given image\n",
    "\n",
    "    Parameters:\n",
    "        cell_positions (pd.DataFrame): DataFrame containing the cell positions\n",
    "        cell_labels (np.array): labels of the cells\n",
    "        targ_labels (np.array): labels of the cells to be counted\n",
    "        dist_bin_px (np.array): distance bins in pixels\n",
    "    '''\n",
    "    \n",
    "    start_time = time.time()\n",
    "    print(f'Starting analysis for image {image}')\n",
    "    # calculate pairwise distances between all cells in the image\n",
    "    dist_st_time = time.time()\n",
    "    distances = euclidean_distances(cell_positions)\n",
    "    dist_end_time = (time.time() - dist_st_time) / 60\n",
    "    print(f'Finished distance calculation for image {image} ({len(cell_positions)} cells) in {dist_end_time:.2f} minutes')\n",
    "\n",
    "    image_counts = None\n",
    "    for i in range(len(distances)):\n",
    "        counts = euclidian_counts(i, distances, cell_labels, targ_labels, dist_bin_px)\n",
    "        if image_counts is not None:\n",
    "            image_counts = np.vstack((image_counts, counts))\n",
    "        else:\n",
    "            image_counts = counts\n",
    "\n",
    "    comp_time = (time.time() - start_time) / 60\n",
    "    print(f'Finished analysis for image {image} in {comp_time:.2f} minutes')\n",
    "    return image_counts\n",
    "\n",
    "def euclidian_counts(idx, distances, cell_labels, targ_labels, dist_bin_px):\n",
    "    '''\n",
    "    euclidian_counts() returns the number of cells within a given \n",
    "    distance of a given cell.\n",
    "\n",
    "    Parameters:\n",
    "        idx (int): index of the cell to be counted\n",
    "        distances (np.array): pairwise distances between cells\n",
    "        cell_labels (np.array): labels of the cells\n",
    "        targ_labels (np.array): labels of the cells to be counted\n",
    "        dist_bin_px (np.array): distance bins in pixels\n",
    "    '''\n",
    "\n",
    "    idx_counts = None\n",
    "    dist_bin_px = np.concatenate([[0], dist_bin_px])\n",
    "    for i in range(len(dist_bin_px)-1):\n",
    "        present_cells = cell_labels[(distances[idx] > dist_bin_px[i]) & (distances[idx] <= dist_bin_px[i+1])]\n",
    "        these_counts = [sum(present_cells == label) for label in targ_labels]\n",
    "\n",
    "        if idx_counts is not None:\n",
    "            idx_counts = np.vstack((idx_counts, these_counts))\n",
    "        else:\n",
    "            idx_counts = np.array(these_counts)\n",
    "\n",
    "    return idx_counts[np.newaxis, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "def draw_cell_scatter(df, ind = None):\n",
    "    sns.scatterplot(data = df,\n",
    "                    x = 'Cell X Position',\n",
    "                    y = 'Cell Y Position',\n",
    "                    hue = 'Lineage')\n",
    "    \n",
    "    if ind is not None:\n",
    "        plt.Circle(df.loc[ind, ['Cell X Position', 'Cell Y Position']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from functools import partial\n",
    "\n",
    "dist_bin_um=np.array([25, 50, 100, 150, 200])\n",
    "dist_bin_px = dist_bin_um/ 0.5\n",
    "num_cpus_to_use = int(multiprocessing.cpu_count() / 2)\n",
    "\n",
    "filename = 'sample_ptptpt.csv'\n",
    "df = pd.read_csv(filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spatial_umap = SpatialUMAP(dist_bin_um=np.array([25, 50, 100, 150, 200]), um_per_px=0.5, area_downsample=.2)\n",
    "results = spatial_umap.get_counts_euc(df, dist_bin_px, num_cpus_to_use)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize keyword arguments\n",
    "images = df['Slide ID'].unique()\n",
    "kwargs_list = []\n",
    "\n",
    "for image in images:\n",
    "\n",
    "    df_image = df.loc[df['Slide ID'] == image, :]\n",
    "    cell_positions = df_image[['Cell X Position', 'Cell Y Position']]\n",
    "    cell_labels = df_image['Lineage']\n",
    "    targ_labels = df['Lineage'].unique()\n",
    "    dist_bin_px = dist_bin_px\n",
    "\n",
    "    results = per_image_cell_counts_euc(image, cell_positions, cell_labels, targ_labels, dist_bin_px)\n",
    "    print(results.shape)\n",
    "    kwargs_list.append(\n",
    "        (\n",
    "            image,\n",
    "            cell_positions,\n",
    "            cell_labels,\n",
    "            targ_labels,\n",
    "            dist_bin_px\n",
    "        )\n",
    "    )\n",
    "\n",
    "# # Create a pool of worker processes\n",
    "# with multiprocessing.Pool(processes=num_cpus_to_use) as pool:\n",
    "#     results = pool.starmap(per_image_cell_counts_euc, kwargs_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cell_positions = df[['Cell X Position', 'Cell Y Position']].values\n",
    "cell_labels = pd.get_dummies(df['Lineage'])\n",
    "\n",
    "args = dict(cell_positions=cell_positions,\n",
    "            cell_labels=cell_labels.values,\n",
    "            dist_bin_px=dist_bin_px)\n",
    "pool_map_fn = partial(process_cell_counts, **args)\n",
    "\n",
    "idxSet = range(100)\n",
    "i, counts = list(map(lambda x: np.stack(x, axis=0), list(zip(*map(pool_map_fn, idxSet)))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'input/Combo_CSVfiles_20230327_152849.csv'\n",
    "import pandas as pd\n",
    "df = pd.read_csv(filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import multiprocessing\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import utils\n",
    "import neighbors_counts_for_neighborhood_profiles\n",
    "\n",
    "# Constants\n",
    "num_cpus_to_use = int(multiprocessing.cpu_count() / 2)\n",
    "datafile = 'Combo_CSVfiles_20230327_152849.csv'\n",
    "input_file = os.path.join('.', 'input', datafile)\n",
    "\n",
    "# Read in the datafile\n",
    "df = pd.read_csv(input_file)\n",
    "radii = np.array([0, 25, 50, 100, 150, 200])\n",
    "\n",
    "image_column_name = 'ShortName'\n",
    "coord_column_names = ['CentroidX', 'CentroidY']\n",
    "phenotype_column_name = 'pheno_20230327_152849'\n",
    "\n",
    "# Variables\n",
    "image_names = df[image_column_name].unique()\n",
    "phenotypes = df[phenotype_column_name].unique()\n",
    "debug_output = True\n",
    "num_ranges = len(radii) - 1\n",
    "range_strings = [f'{radii[iradius]}, {radii[iradius + 1]})' for iradius in range(num_ranges)]\n",
    "\n",
    "# Calculate the density matrix for all images\n",
    "df_density_matrix = calculate_density_matrix_for_all_images(image_names, df, phenotypes, phenotype_column_name, image_column_name, coord_column_names, radii, range_strings, debug_output=debug_output, num_cpus_to_use=num_cpus_to_use)\n",
    "\n",
    "# Print shape of final density matrix dataframe\n",
    "print(f'Shape of final density matrix: {df_density_matrix.shape}')\n",
    "\n",
    "# Fill in any NaN values with 0 and convert to integers\n",
    "df_density_matrix = df_density_matrix.fillna(0).astype(int)\n",
    "\n",
    "df_density_matrix.to_csv('C:/Users/smithdaj/Desktop/AndrewMethod/Combo_CSVfiles_Out2.csv', index = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "full_array = None\n",
    "for phenotype in phenotypes:\n",
    "    array_set = df_density_matrix.iloc[:, 0:num_ranges].to_numpy()\n",
    "    if full_array is None:\n",
    "        full_array = array_set\n",
    "    else:\n",
    "        full_array = np.dstack((full_array, array_set))\n",
    "print(full_array.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_density_matrix"
   ]
  },
  {
   "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}