From fc085ab4a2e02e093f4d2ccc7f4b5f66238175fc Mon Sep 17 00:00:00 2001 From: Jaspreet Ishar Date: Tue, 14 Jul 2026 17:08:49 -0400 Subject: [PATCH 01/14] methods for calculating radial expansion; example notebook; unit tests --- .../Nuclear_Expansion_Radial_Buffering.ipynb | 1023 +++++++++++++++++ src/celldega/nbhd/collection.py | 287 ++++- src/celldega/nbhd/neighborhoods.py | 130 ++- src/celldega/nbhd/radial_expansion.py | 194 ++++ src/celldega/nbhd/trx_streaming.py | 149 +++ tests/unit/test_nbhd/test_radial_expansion.py | 314 +++++ tests/unit/test_nbhd/test_trx_streaming.py | 88 ++ 7 files changed, 2125 insertions(+), 60 deletions(-) create mode 100644 docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb create mode 100644 src/celldega/nbhd/radial_expansion.py create mode 100644 src/celldega/nbhd/trx_streaming.py create mode 100644 tests/unit/test_nbhd/test_radial_expansion.py create mode 100644 tests/unit/test_nbhd/test_trx_streaming.py diff --git a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb new file mode 100644 index 00000000..d7a7f9bb --- /dev/null +++ b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb @@ -0,0 +1,1023 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3341e980", + "metadata": {}, + "source": [ + "# Nuclear-to-Cell Radial Buffering with `celldega.nbhd`\n", + "\n", + "This notebook is a runnable companion to a nucleus/cell segmentation-sensitivity\n", + "analysis: starting from a nucleus polygon, grow it outward in fixed steps until it\n", + "reaches the boundary of its corresponding (larger) cell segmentation, and compute a\n", + "cell-by-gene matrix at every step -- the original nucleus radius plus each expanded\n", + "radius.\n", + "\n", + "That workflow is now a first-class part of Celldega's neighborhood API:\n", + "\n", + "- **`NeighborhoodCollection.calc_radial_expansion`** replaces the manual\n", + " `expand_nuclei_within_cell` buffering loop. It is deliberately generic: give it a\n", + " `NeighborhoodCollection` of *any* entity and a matching per-entity bounding\n", + " `GeoDataFrame`; it buffers every entity outward at each requested radius (in\n", + " microns), clips each one to its own bound so growth never overshoots it, and\n", + " returns one new `NeighborhoodCollection` per radius, all sharing the same\n", + " observation axis so results stay directly comparable across radii. Nucleus ->\n", + " cell is just the running example below -- the same method works for any other\n", + " pair of nested per-entity geometries.\n", + "- **`NeighborhoodCollection.calc_signature(by=\"cell-free\", gdf_trx=...)`** replaces\n", + " the custom `assign_trx_to_entity_streaming_parquet_optimized` + manual pivot.\n", + " It spatially joins transcripts to each radius's polygons and returns a cell-by-\n", + " gene `AnnData`, ready for the usual scanpy pipeline. A `feature_col` argument\n", + " lets it work directly with non-Xenium transcript column names (e.g. `\"name\"`\n", + " instead of `\"feature_name\"`), so a custom `transcripts.parquet` with `x`/`y`/\n", + " `name` columns doesn't need to be reshaped first.\n", + "\n", + "Because the real instrument files (OME-TIFF, per-dataset contour CSVs, a full-tile\n", + "`transcripts.parquet`) aren't available here, this notebook builds a small\n", + "**synthetic** nucleus/cell/transcript dataset with the same shape as a real\n", + "segmentation export, so every cell below runs standalone. The final section maps\n", + "each synthetic variable back to the real pipeline's inputs so you can swap in your\n", + "own paths." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4d0f46b0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-14T20:59:26.316776Z", + "iopub.status.busy": "2026-07-14T20:59:26.316514Z", + "iopub.status.idle": "2026-07-14T20:59:29.288981Z", + "shell.execute_reply": "2026-07-14T20:59:29.287996Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'0.18.0'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import os\n", + "import tempfile\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import geopandas as gpd\n", + "import scanpy as sc\n", + "import matplotlib.pyplot as plt\n", + "from shapely.geometry import Point\n", + "\n", + "import celldega as dega\n", + "\n", + "dega.__version__" + ] + }, + { + "cell_type": "markdown", + "id": "0077007a", + "metadata": {}, + "source": [ + "## 1. Nucleus + cell-boundary polygons\n", + "\n", + "A real pipeline builds these from segmentation contour CSVs (one polygon per cell,\n", + "in each of a nucleus file and an expanded-cell-boundary file). Here we synthesize\n", + "the same shape: two `GeoDataFrame`s sharing a `cell_id` column, one with a small\n", + "nucleus polygon per cell and one with its larger enclosing cell polygon." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5f2394c8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-14T20:59:29.291486Z", + "iopub.status.busy": "2026-07-14T20:59:29.291013Z", + "iopub.status.idle": "2026-07-14T20:59:29.304093Z", + "shell.execute_reply": "2026-07-14T20:59:29.303573Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "((120, 2), (120, 2))" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rng = np.random.default_rng(0)\n", + "\n", + "N_ROWS, N_COLS = 10, 12\n", + "SPACING_UM = 20.0\n", + "\n", + "records_nuclei, records_cells, cell_meta = [], [], []\n", + "\n", + "cell_id = 0\n", + "for row in range(N_ROWS):\n", + " for col in range(N_COLS):\n", + " cx = col * SPACING_UM + rng.normal(0, 1.5)\n", + " cy = row * SPACING_UM + rng.normal(0, 1.5)\n", + "\n", + " cell_radius = rng.uniform(7.0, 9.0)\n", + " nucleus_radius = rng.uniform(2.5, 3.5)\n", + " jitter = rng.uniform(0, 2.0, size=2)\n", + " nx, ny = cx + jitter[0], cy + jitter[1]\n", + "\n", + " # two synthetic \"cell types\" so downstream clustering has real structure\n", + " cell_type = \"TypeA\" if (row + col) % 2 == 0 else \"TypeB\"\n", + "\n", + " records_nuclei.append(\n", + " {\"cell_id\": cell_id, \"geometry\": Point(nx, ny).buffer(nucleus_radius, resolution=12)}\n", + " )\n", + " records_cells.append(\n", + " {\"cell_id\": cell_id, \"geometry\": Point(cx, cy).buffer(cell_radius, resolution=12)}\n", + " )\n", + " cell_meta.append(\n", + " {\"cell_id\": cell_id, \"cell_type\": cell_type, \"cx\": cx, \"cy\": cy,\n", + " \"nx\": nx, \"ny\": ny, \"nucleus_radius\": nucleus_radius, \"cell_radius\": cell_radius}\n", + " )\n", + " cell_id += 1\n", + "\n", + "gdf_nuclei = gpd.GeoDataFrame(records_nuclei)\n", + "gdf_cells = gpd.GeoDataFrame(records_cells)\n", + "df_cell_meta = pd.DataFrame(cell_meta).set_index(\"cell_id\")\n", + "\n", + "gdf_nuclei.shape, gdf_cells.shape" + ] + }, + { + "cell_type": "markdown", + "id": "69869e12", + "metadata": {}, + "source": [ + "## 2. Wrap the nuclei as a `NeighborhoodCollection`\n", + "\n", + "Each nucleus becomes one observation (\"neighborhood\"), keyed by `cell_id`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "85a6f217", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-14T20:59:29.305897Z", + "iopub.status.busy": "2026-07-14T20:59:29.305763Z", + "iopub.status.idle": "2026-07-14T20:59:29.317657Z", + "shell.execute_reply": "2026-07-14T20:59:29.317158Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
area_um2
neighborhood_id
019.838659
136.964149
222.426905
321.573983
437.955601
\n", + "
" + ], + "text/plain": [ + " area_um2\n", + "neighborhood_id \n", + "0 19.838659\n", + "1 36.964149\n", + "2 22.426905\n", + "3 21.573983\n", + "4 37.955601" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nbhd_nuclei = dega.nbhd.NeighborhoodCollection(\n", + " gdf=gdf_nuclei, nbhd_type=\"nucleus\", nbhd_col=\"cell_id\"\n", + ")\n", + "nbhd_nuclei.obs[[\"area_um2\"]].head()" + ] + }, + { + "cell_type": "markdown", + "id": "2bda07c4", + "metadata": {}, + "source": [ + "## 3. Radial expansion series\n", + "\n", + "`calc_radial_expansion` buffers every nucleus outward at each radius in\n", + "`radii_um` and intersects it with the matching row of `gdf_cells`, so a nucleus\n", + "never grows past its own cell's membrane. It returns a dict keyed by radius, each\n", + "value a new `NeighborhoodCollection` sharing the same `cell_id` observation axis." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "658414fd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-14T20:59:29.319060Z", + "iopub.status.busy": "2026-07-14T20:59:29.318957Z", + "iopub.status.idle": "2026-07-14T20:59:29.410156Z", + "shell.execute_reply": "2026-07-14T20:59:29.409631Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "radius= 0.0 um -> n= 120 mean_area= 28.34 um^2\n", + "radius= 0.5 um -> n= 120 mean_area= 38.52 um^2\n", + "radius= 1.0 um -> n= 120 mean_area= 50.28 um^2\n", + "radius= 1.5 um -> n= 120 mean_area= 63.58 um^2\n", + "radius= 2.0 um -> n= 120 mean_area= 78.40 um^2\n", + "radius= 2.5 um -> n= 120 mean_area= 94.52 um^2\n", + "radius= 3.0 um -> n= 120 mean_area=111.39 um^2\n" + ] + } + ], + "source": [ + "radii_um = [0, 0.5, 1, 1.5, 2, 2.5, 3]\n", + "nbhd_series = nbhd_nuclei.calc_radial_expansion(gdf_cells, radii_um=radii_um)\n", + "\n", + "for radius, nbhd in nbhd_series.items():\n", + " print(f\"radius={radius:>4} um -> n={len(nbhd.gdf):>4} mean_area={nbhd.gdf['area_um2'].mean():6.2f} um^2\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "140c06c5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-14T20:59:29.411802Z", + "iopub.status.busy": "2026-07-14T20:59:29.411669Z", + "iopub.status.idle": "2026-07-14T20:59:30.241487Z", + "shell.execute_reply": "2026-07-14T20:59:30.240806Z" + } + }, + "outputs": [], + "source": [ + "# visual sanity check for one example cell, mirroring the original notebook's plot\n", + "example_id = str(int(df_cell_meta.index[7]))\n", + "\n", + "fig, axes = plt.subplots(1, len(radii_um), figsize=(3 * len(radii_um), 3))\n", + "for ax, radius in zip(axes, radii_um):\n", + " nbhd = nbhd_series[radius]\n", + " gdf_cells[gdf_cells[\"cell_id\"].astype(str) == example_id].boundary.plot(ax=ax, color=\"black\")\n", + " nbhd.gdf.loc[[example_id]].plot(ax=ax, color=\"lightblue\", edgecolor=\"blue\", alpha=0.7)\n", + " ax.set_title(f\"+{radius} um\")\n", + " ax.set_aspect(\"equal\")\n", + " ax.axis(\"off\")\n", + "fig.suptitle(f\"cell_id {example_id}\")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "29cf4d67", + "metadata": {}, + "source": [ + "### Working in pixel space\n", + "\n", + "Segmentation pipelines often store nucleus/cell polygons in image-pixel\n", + "coordinates rather than microns -- e.g. the original notebook builds them via\n", + "`vertex_x * high_res_scale`, where `high_res_scale = 1 / scaling_factor` is a\n", + "pixels-per-micron factor (`scaling_factor` itself, from `PhysicalSizeX`, is\n", + "microns-per-pixel). `calc_radial_expansion` needs to know that scale to convert\n", + "`radii_um` into the geometry's own units before buffering.\n", + "\n", + "Pass whichever factor your pipeline already has on hand:\n", + "\n", + "- `scale_um_per_pixel=` for a microns-per-pixel factor (e.g. OME-XML `PhysicalSizeX`) -- a micron distance is *divided* by this to get pixels.\n", + "- `pixels_per_micron=` for the reciprocal, pixels-per-micron convention (e.g. `high_res_scale` above) -- a micron distance is *multiplied* by this to get pixels, matching `buffer_dist = expand_um * high_res_scale` directly.\n", + "\n", + "Both are shown below on the same nuclei, scaled up into a toy \"pixel\" coordinate\n", + "space, and confirmed to reproduce the same real-world (micron) areas as the\n", + "micron-space series computed earlier." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2f1d3bf5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-14T20:59:30.243478Z", + "iopub.status.busy": "2026-07-14T20:59:30.243354Z", + "iopub.status.idle": "2026-07-14T20:59:30.347139Z", + "shell.execute_reply": "2026-07-14T20:59:30.346575Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pixel-space geometry + pixels_per_micron reproduces the micron-space result\n" + ] + } + ], + "source": [ + "high_res_scale = 4.0 # pixels per micron, e.g. derived from an OME-XML PhysicalSizeX\n", + "\n", + "# stand-in for \"already-in-pixel-space\" geometry, as produced by a real\n", + "# segmentation pipeline's `vertex_x * high_res_scale` step\n", + "gdf_nuclei_px = gdf_nuclei.copy()\n", + "gdf_nuclei_px[\"geometry\"] = gdf_nuclei_px.geometry.scale(high_res_scale, high_res_scale, origin=(0, 0))\n", + "gdf_cells_px = gdf_cells.copy()\n", + "gdf_cells_px[\"geometry\"] = gdf_cells_px.geometry.scale(high_res_scale, high_res_scale, origin=(0, 0))\n", + "\n", + "nbhd_nuclei_px = dega.nbhd.NeighborhoodCollection(\n", + " gdf=gdf_nuclei_px, nbhd_type=\"nucleus\", nbhd_col=\"cell_id\"\n", + ")\n", + "nbhd_series_px = nbhd_nuclei_px.calc_radial_expansion(\n", + " gdf_cells_px,\n", + " radii_um=radii_um,\n", + " is_pixel_space=True,\n", + " pixels_per_micron=high_res_scale, # same variable your own notebook already computes\n", + ")\n", + "\n", + "micron_areas = pd.Series({r: nbhd.gdf[\"area_um2\"].sum() for r, nbhd in nbhd_series.items()}).sort_index()\n", + "pixel_areas = pd.Series({r: nbhd.gdf[\"area_um2\"].sum() for r, nbhd in nbhd_series_px.items()}).sort_index()\n", + "pd.testing.assert_series_equal(micron_areas, pixel_areas, check_names=False, rtol=1e-6)\n", + "print(\"pixel-space geometry + pixels_per_micron reproduces the micron-space result\")" + ] + }, + { + "cell_type": "markdown", + "id": "05b9882a", + "metadata": {}, + "source": [ + "## 4. Synthetic transcripts\n", + "\n", + "Stand-in for a `transcripts.parquet` with non-Xenium columns -- `x`, `y`, `name` --\n", + "matching the columns used in the original notebook's\n", + "`assign_trx_to_entity_streaming_parquet_optimized(..., x_col=\"x\", y_col=\"y\",\n", + "gene_col=\"name\")` call. Two gene pairs simulate real biology: `NucGene*`\n", + "transcripts cluster tightly at the nucleus center (captured at every radius), while\n", + "`CytoGene*` and a cell-type marker gene (`MarkerA`/`MarkerB`) scatter through the\n", + "cytoplasm and are only picked up as the buffer radius grows.\n", + "\n", + "We also write these to an actual `transcripts.parquet` file, so the streaming\n", + "API below reads from disk exactly like it would on a real, whole-tile transcript\n", + "file." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "09ef320b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-14T20:59:30.349203Z", + "iopub.status.busy": "2026-07-14T20:59:30.349082Z", + "iopub.status.idle": "2026-07-14T20:59:30.451245Z", + "shell.execute_reply": "2026-07-14T20:59:30.450605Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "((5490, 2),\n", + " {np.str_('CytoGene1'): 1243,\n", + " np.str_('CytoGene2'): 1157,\n", + " np.str_('NucGene1'): 984,\n", + " np.str_('NucGene2'): 837,\n", + " 'MarkerA': 644,\n", + " 'MarkerB': 625})" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trx_rows = []\n", + "for cid, meta in df_cell_meta.iterrows():\n", + " n_nuc = rng.poisson(15)\n", + " nuc_xy = rng.normal([meta[\"nx\"], meta[\"ny\"]], meta[\"nucleus_radius\"] / 3, size=(n_nuc, 2))\n", + " nuc_genes = rng.choice([\"NucGene1\", \"NucGene2\"], size=n_nuc)\n", + "\n", + " # rejection-sample points in the cytoplasm annulus (inside cell, outside nucleus)\n", + " cyto_xy = []\n", + " while len(cyto_xy) < 20:\n", + " theta = rng.uniform(0, 2 * np.pi)\n", + " r = meta[\"cell_radius\"] * np.sqrt(rng.uniform(0, 1))\n", + " x, y = meta[\"cx\"] + r * np.cos(theta), meta[\"cy\"] + r * np.sin(theta)\n", + " if (x - meta[\"nx\"]) ** 2 + (y - meta[\"ny\"]) ** 2 > meta[\"nucleus_radius\"] ** 2:\n", + " cyto_xy.append((x, y))\n", + " cyto_xy = np.array(cyto_xy)\n", + " cyto_genes = rng.choice([\"CytoGene1\", \"CytoGene2\"], size=len(cyto_xy))\n", + "\n", + " marker_gene = \"MarkerA\" if meta[\"cell_type\"] == \"TypeA\" else \"MarkerB\"\n", + " marker_xy = cyto_xy[rng.integers(0, len(cyto_xy), size=rng.poisson(10))]\n", + "\n", + " for xy, gene in zip(nuc_xy, nuc_genes):\n", + " trx_rows.append({\"x\": xy[0], \"y\": xy[1], \"name\": gene})\n", + " for xy, gene in zip(cyto_xy, cyto_genes):\n", + " trx_rows.append({\"x\": xy[0], \"y\": xy[1], \"name\": gene})\n", + " for xy in marker_xy:\n", + " trx_rows.append({\"x\": xy[0], \"y\": xy[1], \"name\": marker_gene})\n", + "\n", + "df_trx = pd.DataFrame(trx_rows)\n", + "gdf_trx = gpd.GeoDataFrame(df_trx[[\"name\"]], geometry=gpd.points_from_xy(df_trx[\"x\"], df_trx[\"y\"]))\n", + "\n", + "# persist to a real parquet file, so the streaming API (below) reads from disk\n", + "# the same way it would for a real, whole-tile transcripts.parquet\n", + "trx_parquet_path = os.path.join(tempfile.mkdtemp(), \"transcripts.parquet\")\n", + "df_trx.to_parquet(trx_parquet_path)\n", + "\n", + "gdf_trx.shape, gdf_trx[\"name\"].value_counts().to_dict()" + ] + }, + { + "cell_type": "markdown", + "id": "103af3bf", + "metadata": {}, + "source": [ + "## 5. Cell-by-gene matrix at every radius\n", + "\n", + "`calc_signature(by=\"cell-free\", ...)` spatially joins transcripts to each\n", + "radius's polygons and returns transcript counts as an `AnnData` in\n", + "`nbhd.mod[\"gene_cell_free\"]` -- one call per radius, no custom pivot code\n", + "needed. It supports the same transcript source in two ways:\n", + "\n", + "- **In-memory** (`gdf_trx=...`): loads the whole transcript table into memory as\n", + " points and does a single spatial join. Simple, and fine when the transcripts\n", + " already fit comfortably in memory (or you've pre-filtered them yourself).\n", + "- **Streaming** (`trx_parquet_path=...`): reads the parquet file in batches via\n", + " `pyarrow`, narrowing candidate entities per batch with a spatial index before\n", + " testing exact polygons -- the same mechanics as the original notebook's\n", + " `assign_trx_to_entity_streaming_parquet_optimized`. Use this for a real,\n", + " whole-tile `transcripts.parquet` (tens of millions of rows) that you don't want\n", + " to load into memory seven times over (once per radius).\n", + "\n", + "Both produce identical counts -- the cell below runs the streaming path (as you\n", + "would on real data) and spot-checks it against the in-memory path for one radius." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "10f40fda", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-14T20:59:30.452882Z", + "iopub.status.busy": "2026-07-14T20:59:30.452768Z", + "iopub.status.idle": "2026-07-14T20:59:30.682663Z", + "shell.execute_reply": "2026-07-14T20:59:30.682091Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n", + "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n", + "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n", + "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n", + "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n", + "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CytoGene1CytoGene2MarkerAMarkerBNucGene1NucGene2
0.0NaNNaNNaNNaN970.0824.0
0.582.079.037.041.0982.0834.0
1.0171.0162.076.075.0984.0837.0
1.5274.0255.0118.0121.0984.0837.0
2.0379.0367.0170.0172.0984.0837.0
2.5485.0463.0228.0217.0984.0837.0
3.0610.0571.0291.0284.0984.0837.0
\n", + "
" + ], + "text/plain": [ + " CytoGene1 CytoGene2 MarkerA MarkerB NucGene1 NucGene2\n", + "0.0 NaN NaN NaN NaN 970.0 824.0\n", + "0.5 82.0 79.0 37.0 41.0 982.0 834.0\n", + "1.0 171.0 162.0 76.0 75.0 984.0 837.0\n", + "1.5 274.0 255.0 118.0 121.0 984.0 837.0\n", + "2.0 379.0 367.0 170.0 172.0 984.0 837.0\n", + "2.5 485.0 463.0 228.0 217.0 984.0 837.0\n", + "3.0 610.0 571.0 291.0 284.0 984.0 837.0" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "for radius, nbhd in nbhd_series.items():\n", + " nbhd.calc_signature(\n", + " by=\"cell-free\",\n", + " trx_parquet_path=trx_parquet_path,\n", + " x_col=\"x\",\n", + " y_col=\"y\",\n", + " feature_col=\"name\",\n", + " drop_missing=False,\n", + " )\n", + "\n", + "gene_totals = pd.DataFrame(\n", + " {\n", + " radius: pd.DataFrame(\n", + " nbhd.mod[\"gene_cell_free\"].X, columns=nbhd.mod[\"gene_cell_free\"].var_names\n", + " ).sum()\n", + " for radius, nbhd in nbhd_series.items()\n", + " }\n", + ").T\n", + "gene_totals" + ] + }, + { + "cell_type": "markdown", + "id": "081a93dd", + "metadata": {}, + "source": [ + "### Streaming vs. in-memory sanity check\n", + "\n", + "Confirms the streaming path above (`trx_parquet_path=`) and the in-memory path\n", + "(`gdf_trx=`) agree, using the radius=3um collection as a spot check." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4a21421e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-14T20:59:30.684526Z", + "iopub.status.busy": "2026-07-14T20:59:30.684405Z", + "iopub.status.idle": "2026-07-14T20:59:30.710037Z", + "shell.execute_reply": "2026-07-14T20:59:30.709320Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculating neighborhood-by-gene (cell-free, provided gdf_trx)\n", + "streaming and in-memory paths agree\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jishar/Documents/celldega/dega/lib/python3.12/site-packages/mudata/_core/mudata.py:931: UserWarning: Cannot join columns with the same name because var_names are intersecting.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "nbhd_check = nbhd_series[3.0]\n", + "nbhd_check.calc_signature(\n", + " by=\"cell-free\", gdf_trx=gdf_trx, feature_col=\"name\",\n", + " modality_name=\"gene_cell_free_in_memory\", drop_missing=False,\n", + ")\n", + "\n", + "streamed = pd.DataFrame(\n", + " nbhd_check.mod[\"gene_cell_free\"].X, columns=nbhd_check.mod[\"gene_cell_free\"].var_names,\n", + " index=nbhd_check.mod[\"gene_cell_free\"].obs_names,\n", + ")\n", + "in_memory = pd.DataFrame(\n", + " nbhd_check.mod[\"gene_cell_free_in_memory\"].X,\n", + " columns=nbhd_check.mod[\"gene_cell_free_in_memory\"].var_names,\n", + " index=nbhd_check.mod[\"gene_cell_free_in_memory\"].obs_names,\n", + ")\n", + "assert streamed.equals(in_memory[streamed.columns])\n", + "print(\"streaming and in-memory paths agree\")" + ] + }, + { + "cell_type": "markdown", + "id": "80360cd9", + "metadata": {}, + "source": [ + "### Transcript totals via `calc_transcript_assignment`\n", + "\n", + "For just a per-entity transcript *total* (no gene breakdown), the same streaming\n", + "join backs `calc_transcript_assignment(trx_parquet_path=...)` -- e.g. as a quick\n", + "QC pass before committing to a full `calc_signature` call at every radius." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8e9a96f8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-14T20:59:30.711881Z", + "iopub.status.busy": "2026-07-14T20:59:30.711716Z", + "iopub.status.idle": "2026-07-14T20:59:30.734739Z", + "shell.execute_reply": "2026-07-14T20:59:30.734108Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
total_transcripts
neighborhood_id
033
129
223
337
434
\n", + "
" + ], + "text/plain": [ + " total_transcripts\n", + "neighborhood_id \n", + "0 33\n", + "1 29\n", + "2 23\n", + "3 37\n", + "4 34" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nbhd_series[3.0].calc_transcript_assignment(\n", + " trx_parquet_path=trx_parquet_path, x_col=\"x\", y_col=\"y\", gene_col=\"name\"\n", + ")\n", + "nbhd_series[3.0].obs[[\"total_transcripts\"]].head()" + ] + }, + { + "cell_type": "markdown", + "id": "0566b5a3", + "metadata": {}, + "source": [ + "## 6. Downstream analysis per radius\n", + "\n", + "The same scanpy pipeline as the original notebook (normalize, log1p, scale, PCA,\n", + "neighbors, Leiden, UMAP), run once per radius on `nbhd.mod[\"gene_cell_free\"]`.\n", + "Pipeline parameters (`n_comps`, `n_neighbors`) are scaled down here for this small\n", + "synthetic demo -- use your usual settings (e.g. `n_top_genes=5000`,\n", + "`n_neighbors=30`) on real data." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "f4ec2540", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-14T20:59:30.736344Z", + "iopub.status.busy": "2026-07-14T20:59:30.736217Z", + "iopub.status.idle": "2026-07-14T20:59:40.545232Z", + "shell.execute_reply": "2026-07-14T20:59:40.544494Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jishar/Documents/celldega/dega/lib/python3.12/site-packages/scipy/sparse/_index.py:216: SparseEfficiencyWarning: Changing the sparsity structure of a csr_matrix is expensive. lil and dok are more efficient.\n", + " self._set_arrayXarray(i, j, x)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jishar/Documents/celldega/dega/lib/python3.12/site-packages/scanpy/plotting/_utils.py:364: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " plt.show()\n" + ] + } + ], + "source": [ + "adatas = {}\n", + "for radius, nbhd in nbhd_series.items():\n", + " adata = nbhd.mod[\"gene_cell_free\"].copy()\n", + " adata.X = adata.X.astype(\"float32\")\n", + " adata.obs[\"cell_type\"] = df_cell_meta.loc[adata.obs_names.astype(int), \"cell_type\"].to_numpy()\n", + "\n", + " sc.pp.normalize_total(adata)\n", + " sc.pp.log1p(adata)\n", + " sc.pp.scale(adata, max_value=10)\n", + "\n", + " n_comps = min(5, adata.n_vars - 1, adata.n_obs - 1)\n", + " sc.tl.pca(adata, n_comps=n_comps, random_state=0)\n", + " sc.pp.neighbors(adata, n_neighbors=10, use_rep=\"X_pca\", random_state=0)\n", + " sc.tl.leiden(adata, flavor=\"igraph\", key_added=\"leiden\", resolution=0.5, random_state=0)\n", + " sc.tl.umap(adata, random_state=0)\n", + "\n", + " adatas[radius] = adata\n", + "\n", + "sc.pl.umap(adatas[3.0], color=[\"leiden\", \"cell_type\"], title=[f\"radius=3um: leiden\", f\"radius=3um: true cell_type\"])" + ] + }, + { + "cell_type": "markdown", + "id": "62d274dc", + "metadata": {}, + "source": [ + "## 7. Compare across radii\n", + "\n", + "Nuclear genes are already fully captured at radius 0; cytoplasmic and marker genes\n", + "climb steadily as the buffer reaches further into the cell. Clustering into the two\n", + "true cell types only stabilizes once enough cytoplasmic/marker signal is\n", + "captured." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "1a864fad", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-14T20:59:40.547317Z", + "iopub.status.busy": "2026-07-14T20:59:40.547174Z", + "iopub.status.idle": "2026-07-14T20:59:40.595300Z", + "shell.execute_reply": "2026-07-14T20:59:40.594550Z" + } + }, + "outputs": [], + "source": [ + "n_clusters = {radius: adata.obs[\"leiden\"].nunique() for radius, adata in adatas.items()}\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(11, 4))\n", + "axes[0].plot(gene_totals.index, gene_totals[\"NucGene1\"] + gene_totals[\"NucGene2\"], \"o-\", label=\"nuclear genes\")\n", + "axes[0].plot(gene_totals.index, gene_totals[\"CytoGene1\"] + gene_totals[\"CytoGene2\"], \"o-\", label=\"cytoplasmic genes\")\n", + "axes[0].plot(gene_totals.index, gene_totals[\"MarkerA\"] + gene_totals[\"MarkerB\"], \"o-\", label=\"marker genes\")\n", + "axes[0].set_xlabel(\"buffer radius (um)\")\n", + "axes[0].set_ylabel(\"total transcripts captured\")\n", + "axes[0].legend()\n", + "axes[0].set_title(\"Transcript capture vs. nuclear buffer radius\")\n", + "\n", + "axes[1].plot(list(n_clusters.keys()), list(n_clusters.values()), \"o-\", color=\"crimson\")\n", + "axes[1].set_xlabel(\"buffer radius (um)\")\n", + "axes[1].set_ylabel(\"n leiden clusters\")\n", + "axes[1].set_title(\"Cluster count vs. nuclear buffer radius\")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "0768b44c", + "metadata": {}, + "source": [ + "## Mapping this onto a real pipeline\n", + "\n", + "| Original notebook | This notebook / Celldega API |\n", + "| --- | --- |\n", + "| `gdf_nuclei_original` (parsed from `..._nuclei_contour_coords.csv`) | `gdf_nuclei` -> `NeighborhoodCollection(gdf=gdf_nuclei, nbhd_col=\"cell_id\")` |\n", + "| `gdf_cells` / `gdf_cells2` (parsed from `..._Expanded_5um_cell_contour_coords.csv`) | `gdf_cells` passed to `calc_radial_expansion` |\n", + "| `expand_nuclei_within_cell(nuclei_gdf, expand_um)` loop building `nuclei_gdfs = {\"original\": ..., \"expanded_0_5um\": ..., ...}` | `nbhd_series = nbhd_nuclei.calc_radial_expansion(gdf_cells, radii_um=[0, 0.5, 1, 1.5, 2, 2.5, 3])` |\n", + "| `assign_trx_to_entity_streaming_parquet_optimized(trx_parquet_path, entity_gdf, x_col=\"x\", y_col=\"y\", gene_col=\"name\", batch_size=1_000_000)` + manual `pivot_table` per radius | `nbhd.calc_signature(by=\"cell-free\", trx_parquet_path=trx_parquet_path, x_col=\"x\", y_col=\"y\", feature_col=\"name\", batch_size=1_000_000)` per radius -- same batched-parquet-plus-spatial-index mechanics, now built in |\n", + "| `assignments_out=...` (per-transcript assignment parquet) | not written by `calc_signature` (it only needs the resulting counts); if you need per-transcript assignments too, keep using your own writer alongside it |\n", + "| Just the transcript *total* per entity, no gene breakdown | `nbhd.calc_transcript_assignment(trx_parquet_path=trx_parquet_path, x_col=\"x\", y_col=\"y\", gene_col=\"name\")` -> adds a `total_transcripts` column to `nbhd.obs` via the same streaming join |\n", + "| Per-radius `pd.read_parquet(..._nuclei_by_gene.parquet)` -> `AnnData` | `nbhd.mod[\"gene_cell_free\"]` (already an `AnnData`) |\n", + "| Per-radius `adata.write(...h5ad)` | `nbhd.mod[\"gene_cell_free\"].write_h5ad(...)`, or persist the whole collection (geometry + all modalities) with `nbhd.write(\"radius.h5mu\")` |\n", + "\n", + "`calc_signature` also accepts `gdf_trx=` (an already-in-memory `GeoDataFrame` of\n", + "transcript points) for smaller or pre-filtered transcript sources -- see the\n", + "sanity-check cell above, which confirms both paths agree. Use `trx_parquet_path=`\n", + "whenever the transcripts don't comfortably fit in memory, especially since a\n", + "radial-expansion series re-joins the same transcripts once per radius.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fa4b647b-4dd6-42b0-9231-5896987aaa62", + "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.12.11" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/celldega/nbhd/collection.py b/src/celldega/nbhd/collection.py index 6aeb269f..b4ca55ee 100644 --- a/src/celldega/nbhd/collection.py +++ b/src/celldega/nbhd/collection.py @@ -2,6 +2,7 @@ from __future__ import annotations +from collections.abc import Sequence from pathlib import Path from typing import Any @@ -313,6 +314,130 @@ def calc_gradient( ) return type(self)(gdf=gdf_rings, nbhd_type=nbhd_type, **kwargs) + def calc_radial_expansion( + self, + gdf_bounds: gpd.GeoDataFrame, + radii_um: Sequence[float] = (0, 0.5, 1, 1.5, 2, 2.5, 3), + nbhd_type: str = "radial_expansion", + *, + technology: str | None = None, + scale_um_per_pixel: float | None = None, + pixels_per_micron: float | None = None, + is_pixel_space: bool = False, + join_style: int = 2, + mitre_limit: float = 5.0, + add_colors: bool = True, + **kwargs: Any, + ) -> dict[float, NeighborhoodCollection]: + """Buffer every entity in this collection outward, clipped to its own bound. + + Unlike :meth:`calc_gradient` — which grows concentric rings from ONE + dissolved region of interest — this grows **every** neighborhood in this + collection independently, using each one as its own tiny ROI, and clips + the result to a matching row in ``gdf_bounds`` (joined by + ``self.nbhd_col``). One new ``NeighborhoodCollection`` is returned per + radius, all sharing the same observation axis (the entity ids) so + ``calc_signature``/``calc_population`` results stay directly comparable + across radii. + + The canonical use case is a segmented nucleus growing outward until it + reaches its corresponding cell boundary — e.g. to see how nuclear vs. + cytoplasmic transcript capture changes as the working boundary is + expanded toward the true cell membrane — but ``gdf_bounds`` can be any + per-entity containing geometry (this collection's entities need not be + nuclei, and ``gdf_bounds`` need not be cells). + + Args: + gdf_bounds: Per-entity clipping boundary (e.g. a cell segmentation + polygon for each nucleus), with a column named ``self.nbhd_col`` + matching this collection's neighborhood ids and a ``geometry`` + column. Every buffered entity is intersected with its matching + row. + radii_um: Buffer distances in microns (default ``0`` through ``3`` in + ``0.5`` steps). ``0`` returns the original (validity-repaired) + entity geometry, clipped to its bound. + nbhd_type: Label recorded on each returned collection (default + ``"radial_expansion"``). + technology: Imaging platform used to look up ``scale_um_per_pixel`` + for pixel-space geometry (e.g. ``"Xenium"``). + scale_um_per_pixel: Microns per pixel — the factor a micron distance + is *divided* by to get pixels. Required (directly, via + ``technology``, or via ``pixels_per_micron``) when + ``is_pixel_space=True``. Takes precedence over + ``pixels_per_micron`` if both are given. + pixels_per_micron: Pixels per micron — the reciprocal convention, + where a micron distance is *multiplied* by this factor to get + pixels (e.g. a notebook's own ``buffer_dist = expand_um * + high_res_scale``). Equivalent to passing + ``scale_um_per_pixel=1 / pixels_per_micron``. + is_pixel_space: ``True`` if this collection's geometry is in pixel + units; ``False`` (default) if already in microns. + join_style: Shapely buffer join style (``1``=round, ``2``=mitre + (default), ``3``=bevel). + mitre_limit: Shapely mitre limit, used when ``join_style=2``. + add_colors: If ``True`` (default), add a ``color`` column — one + shade per radius (dark to light) — for visualization. + **kwargs: Forwarded to each new ``NeighborhoodCollection`` (e.g. + ``name``, ``data_dir``). + + Returns: + A dict mapping each radius in ``radii_um`` (in microns) to a new + ``NeighborhoodCollection`` of that radius's buffered, clipped + geometries. + + Raises: + ValueError: If this collection has no geometry, if ids are not + unique or fail to match between this collection and + ``gdf_bounds``, or if ``is_pixel_space=True`` without a + resolvable scale (``scale_um_per_pixel``, ``pixels_per_micron``, + or ``technology``). + + Examples: + >>> nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_col="cell_id") + >>> series = nbhd_nuclei.calc_radial_expansion(gdf_cells, radii_um=[0, 1, 2, 3]) + >>> for radius, nbhd in series.items(): + ... nbhd.calc_signature(by="cell-free", gdf_trx=gdf_trx, drop_missing=False) + + If this collection's geometry is in pixel space, pass whichever + scale factor your pipeline already computes — e.g. a + ``high_res_scale`` (pixels/micron) straight from a notebook, with no + need to invert it into microns/pixel first:: + + >>> series = nbhd_nuclei.calc_radial_expansion( + ... gdf_cells, radii_um=[0, 1, 2, 3], + ... is_pixel_space=True, pixels_per_micron=high_res_scale, + ... ) + """ + from celldega.nbhd.radial_expansion import _calc_radial_expansion + + if self.gdf is None: + raise ValueError( + "gdf or geometry is required to calculate a radial expansion series" + ) + + if self.transformation_matrix is not None and "transformation_matrix" not in kwargs: + kwargs["transformation_matrix"] = self.transformation_matrix + + per_radius_gdf = _calc_radial_expansion( + self.gdf, + gdf_bounds, + radii_um=radii_um, + id_col=self.nbhd_col, + technology=technology, + scale_um_per_pixel=scale_um_per_pixel, + pixels_per_micron=pixels_per_micron, + is_pixel_space=is_pixel_space, + join_style=join_style, + mitre_limit=mitre_limit, + add_colors=add_colors, + ) + return { + radius: type(self)( + gdf=gdf_radius, nbhd_type=nbhd_type, nbhd_col=self.nbhd_col, **kwargs + ) + for radius, gdf_radius in per_radius_gdf.items() + } + @property def geometry(self) -> gpd.GeoDataFrame | None: """Neighborhood geometry. Alias of :attr:`gdf` (single source of truth).""" @@ -450,6 +575,12 @@ def calc_signature( modality_name: str | None = None, min_cells: int = 1, data_dir: str | None = None, + gdf_trx: gpd.GeoDataFrame | None = None, + feature_col: str = "feature_name", + trx_parquet_path: str | None = None, + x_col: str = "x", + y_col: str = "y", + batch_size: int = 1_000_000, drop_missing: bool = True, ) -> None: """Calculate a neighborhood-by-gene modality and attach it to ``self.mod``. @@ -465,8 +596,31 @@ def calc_signature( modality_name: Key for the modality; defaults to ``"gene"`` (cell-derived) or ``"gene_cell_free"`` (transcript-derived). min_cells: Minimum cells/transcripts for a neighborhood to be kept. - data_dir: Transcript directory for ``by="cell-free"``; defaults to - ``self.data_dir``. + data_dir: Transcript directory for ``by="cell-free"`` (Xenium + convention: `transcripts.parquet` with `feature_name`/ + `x_location`/`y_location` columns); defaults to ``self.data_dir``. + Used only when neither ``gdf_trx`` nor ``trx_parquet_path`` is + given. + gdf_trx: Pre-loaded transcript points for ``by="cell-free"``, for + transcript sources that don't follow the ``data_dir`` convention + (custom paths, column names, or pre-filtering). Loads the whole + frame into memory for one spatial join; takes precedence over + ``trx_parquet_path`` and ``data_dir``. + feature_col: Gene/feature column name (default ``"feature_name"``). + Used as the column in ``gdf_trx`` when given, or as the gene + column when streaming from ``trx_parquet_path``. + trx_parquet_path: Path to a transcripts parquet file (or dataset) to + stream in batches instead of loading into memory — for transcript + files too large for an in-memory ``gdf_trx``/``data_dir`` join + (e.g. a whole-tile file streamed once per radius across a + :meth:`calc_radial_expansion` series). Requires + ``x_col``/``y_col``/``feature_col`` to match its columns. Takes + precedence over ``data_dir`` but not ``gdf_trx``. + x_col: Transcript x-coordinate column in ``trx_parquet_path``. + y_col: Transcript y-coordinate column in ``trx_parquet_path``. + batch_size: Rows read per streamed batch when using + ``trx_parquet_path``. Bounds peak memory use; does not affect the + result. drop_missing: When ``True`` (default), neighborhoods with fewer than ``min_cells`` cells (or transcripts) are removed from the collection entirely. When ``False``, the collection keeps all @@ -477,8 +631,9 @@ def calc_signature( ``None`` — the modality is attached to ``self.mod``. Raises: - ValueError: If ``adata`` is missing for ``by="cell"``, or ``data_dir`` - is missing for ``by="cell-free"``. + ValueError: If ``adata`` is missing for ``by="cell"``, or none of + ``data_dir``, ``gdf_trx``, or ``trx_parquet_path`` is given for + ``by="cell-free"``. """ from celldega.nbhd.neighborhoods import ( _calc_nbhd_by_gene, @@ -491,14 +646,27 @@ def calc_signature( resolved_data_dir = data_dir if data_dir is not None else self.data_dir if by == "cell" and adata is None: raise ValueError("adata is required when by='cell'") - if by == "cell-free" and resolved_data_dir is None: - raise ValueError("data_dir is required when by='cell-free'") + if ( + by == "cell-free" + and gdf_trx is None + and trx_parquet_path is None + and resolved_data_dir is None + ): + raise ValueError( + "data_dir, gdf_trx, or trx_parquet_path is required when by='cell-free'" + ) modality = _calc_nbhd_by_gene( self.gdf, by=by, adata=adata, data_dir=resolved_data_dir, + gdf_trx=gdf_trx, + feature_col=feature_col, + trx_parquet_path=trx_parquet_path, + x_col=x_col, + y_col=y_col, + batch_size=batch_size, nbhd_col=self.nbhd_col, min_cells=min_cells, ) @@ -589,47 +757,106 @@ def calc_bordering( def calc_transcript_assignment( self, data_dir: str | None = None, + *, + trx_parquet_path: str | None = None, + x_col: str = "x", + y_col: str = "y", + gene_col: str = "gene", + batch_size: int = 1_000_000, ) -> None: - """Add per-neighborhood transcript-assignment columns to ``obs``. - - From ``transcripts.parquet`` in ``data_dir``, adds three ``obs`` columns - (on the underlying MuData) for each neighborhood: - - - ``total_transcripts`` — transcripts falling inside the neighborhood. - - ``unassigned_transcripts`` — those with ``cell_id == "UNASSIGNED"``. - - ``transcript_assignment_proportion`` — assigned / total (``0.0`` when - the neighborhood has no transcripts). - - Assumption: the transcript-to-cell assignment is **not computed here** — - it must already be present in the instrument data, with unassigned - transcripts marked by the ``"UNASSIGNED"`` sentinel (Xenium convention). - Only transcripts are needed — no ``adata`` or cell polygons. + """Add per-neighborhood transcript-count columns to ``obs``. + + Two mutually exclusive modes: + + - **Audit mode** (default, ``data_dir``): reads a Xenium-convention + ``transcripts.parquet`` that already carries a per-transcript + ``cell_id`` column (unassigned transcripts marked by the + ``"UNASSIGNED"`` sentinel) and adds ``total_transcripts``, + ``unassigned_transcripts``, and ``transcript_assignment_proportion``. + The transcript-to-cell assignment is **not computed** in this mode — + it must already be present in the instrument data. + - **Streaming mode** (``trx_parquet_path``): computes transcript-to- + neighborhood assignment from geometry — via the same batched, + spatial-index-accelerated point-in-polygon join used by + ``calc_signature(trx_parquet_path=...)`` — for transcript files that + don't carry a pre-existing per-transcript assignment (e.g. a custom + pipeline's ``x``/``y``/gene ``transcripts.parquet`` with no + ``cell_id`` column, or a radius from + :meth:`calc_radial_expansion`). Adds only ``total_transcripts`` — + there's no pre-existing assignment to compare against, so + ``unassigned_transcripts``/``transcript_assignment_proportion`` don't + apply. For a full gene expression matrix (not just totals) in this + mode, use ``calc_signature(by="cell-free", trx_parquet_path=...)`` + instead. Args: - data_dir: Directory containing ``transcripts.parquet``; defaults to - ``self.data_dir``. + data_dir: Directory containing a Xenium-convention + ``transcripts.parquet`` for audit mode; defaults to + ``self.data_dir``. Ignored when ``trx_parquet_path`` is given. + trx_parquet_path: Path to a transcripts parquet file (or dataset) to + stream in batches for streaming mode, instead of audit mode. + x_col: Transcript x-coordinate column in ``trx_parquet_path`` + (streaming mode only). + y_col: Transcript y-coordinate column in ``trx_parquet_path`` + (streaming mode only). + gene_col: Transcript gene/feature column in ``trx_parquet_path`` + (streaming mode only) — only used to batch the point-in-polygon + join; the per-gene breakdown itself is discarded here. + batch_size: Rows read per streamed batch (streaming mode only). + Bounds peak memory use; does not affect the result. Returns: - ``None`` — the three columns are added to ``self.obs``. + ``None`` — the columns are added to ``self.obs``. Raises: - ValueError: If geometry or a usable ``data_dir`` is missing, or the - transcripts lack a ``cell_id`` column. A complete absence of the - ``"UNASSIGNED"`` sentinel only warns. + ValueError: If geometry is missing, the transcripts lack a + ``cell_id`` column in audit mode, or neither ``data_dir`` nor + ``trx_parquet_path`` resolves to a usable transcript source. A + complete absence of the ``"UNASSIGNED"`` sentinel in audit mode + only warns. + + Examples: + >>> nbhd.calc_transcript_assignment( + ... trx_parquet_path="dataset_transcripts.parquet", + ... x_col="x", y_col="y", gene_col="name", + ... ) """ + if self.gdf is None: + raise ValueError("gdf or geometry is required to calculate transcript assignment") + + obs = self.obs.copy() + + if trx_parquet_path is not None: + from celldega.nbhd.trx_streaming import _assign_trx_to_entity_streaming_parquet + + counts = _assign_trx_to_entity_streaming_parquet( + trx_parquet_path, + self.gdf, + id_col=self.nbhd_col, + x_col=x_col, + y_col=y_col, + gene_col=gene_col, + batch_size=batch_size, + ) + total_transcripts = ( + counts.sum(axis=1).reindex(self.obs.index.astype(str)).fillna(0).astype(int) + ) + obs["total_transcripts"] = total_transcripts.to_numpy() + self.obs = obs + return + from celldega.nbhd.neighborhoods import _calc_nbhd_transcript_assignment from celldega.nbhd.utils import _get_gdf_trx - if self.gdf is None: - raise ValueError("gdf or geometry is required to calculate transcript assignment") resolved_data_dir = data_dir if data_dir is not None else self.data_dir if resolved_data_dir is None: - raise ValueError("data_dir is required to calculate transcript assignment") + raise ValueError( + "data_dir or trx_parquet_path is required to calculate transcript assignment" + ) gdf_trx = _get_gdf_trx(resolved_data_dir) stats = _calc_nbhd_transcript_assignment(self.gdf, self.nbhd_col, gdf_trx) stats = stats.reindex(self.obs.index.astype(str)) - obs = self.obs.copy() for col in stats.columns: obs[col] = stats[col].to_numpy() self.obs = obs diff --git a/src/celldega/nbhd/neighborhoods.py b/src/celldega/nbhd/neighborhoods.py index b82469dc..f64b76a8 100644 --- a/src/celldega/nbhd/neighborhoods.py +++ b/src/celldega/nbhd/neighborhoods.py @@ -27,11 +27,45 @@ def _nbhd_geometry_for_join(gdf_nbhd: gpd.GeoDataFrame, nbhd_col: str) -> gpd.Ge return gdf_nbhd[[nbhd_col, "geometry"]].reset_index(drop=True) +def _pivot_trx_counts_by_sjoin( + gdf_trx_pts: gpd.GeoDataFrame, + feature_col: str, + nbhd_col: str, + gdf_nbhd: gpd.GeoDataFrame, +) -> pd.DataFrame: + """In-memory transcript-to-neighborhood counts via a single spatial join. + + Shared by the ``gdf_trx=`` and ``data_dir=`` cell-free code paths. For + transcript files too large to hold in memory this way, see + :mod:`celldega.nbhd.trx_streaming` (``trx_parquet_path=``) instead. + """ + joined = gdf_trx_pts.sjoin( + _nbhd_geometry_for_join(gdf_nbhd, nbhd_col), + how="left", + predicate="within", + ) + return ( + joined.groupby([nbhd_col, feature_col]) + .size() + .unstack(fill_value=0) + .rename_axis(None, axis=1) + .reindex(gdf_nbhd[nbhd_col]) + .fillna(0) + .astype(int) + ) + + def _calc_nbhd_by_gene( gdf_nbhd: gpd.GeoDataFrame, by: str = "cell", adata: AnnData | None = None, data_dir: str | None = None, + gdf_trx: gpd.GeoDataFrame | None = None, + feature_col: str = "feature_name", + trx_parquet_path: str | None = None, + x_col: str = "x", + y_col: str = "y", + batch_size: int = 1_000_000, nbhd_col: str = "name", min_cells: int = 1, ) -> AnnData: @@ -53,13 +87,37 @@ def _calc_nbhd_by_gene( by : str, default "cell" Method for calculating gene expression: - "cell": Mean expression of cells within each neighborhood (requires `adata`) - - "cell-free": Transcript counts within each neighborhood (requires `data_dir`) + - "cell-free": Transcript counts within each neighborhood (requires `data_dir` + or a pre-loaded `gdf_trx`) adata : AnnData, optional AnnData object with cell data. Required when `by="cell"`. Must have spatial coordinates in `obsm["spatial"]`. data_dir : str, optional - Path to directory containing `transcripts.parquet`. Required when - `by="cell-free"`. + Path to a directory containing a Xenium-convention `transcripts.parquet` + (`feature_name`/`x_location`/`y_location` columns). Used when + `by="cell-free"` and neither `gdf_trx` nor `trx_parquet_path` is given. + gdf_trx : gpd.GeoDataFrame, optional + Pre-loaded transcript points, for transcript sources that don't follow the + `data_dir` convention (custom file paths, column names, or pre-filtering). + Must have a `geometry` column of transcript points and a gene/feature + column named `feature_col`. Takes precedence over `trx_parquet_path` and + `data_dir`. + feature_col : str, default "feature_name" + Gene/feature column name. Used as the column in `gdf_trx` when it is + given, or as `gene_col` when streaming from `trx_parquet_path` (transcripts + loaded from `data_dir` always use the Xenium `feature_name` column). + trx_parquet_path : str, optional + Path to a transcripts parquet file (or dataset) to stream in batches + instead of loading into memory — for transcript files too large for an + in-memory `gdf_trx`/`data_dir` join. Requires `x_col`/`y_col`/`feature_col` + to match its columns. Takes precedence over `data_dir` but not `gdf_trx`. + x_col : str, default "x" + Transcript x-coordinate column in `trx_parquet_path`. + y_col : str, default "y" + Transcript y-coordinate column in `trx_parquet_path`. + batch_size : int, default 1_000_000 + Rows read per streamed batch when using `trx_parquet_path`. Bounds peak + memory use; does not affect the result. nbhd_col : str, default "name" Column in `gdf_nbhd` containing neighborhood identifiers. min_cells : int, default 1 @@ -132,33 +190,45 @@ def _calc_nbhd_by_gene( adata_nbg.obs["n_cells"] = [cell_counts.get(n, 0) for n in adata_nbg.obs.index] elif by == "cell-free": - if data_dir is None: - raise ValueError("data_dir is required when by='cell-free'") - - print("Calculating neighborhood-by-gene (cell-free)") - - df_trx = pd.read_parquet( - f"{data_dir}/transcripts.parquet", - columns=["feature_name", "x_location", "y_location"], - engine="pyarrow", - ) - geometry = gpd.points_from_xy(df_trx["x_location"], df_trx["y_location"]) - gdf_trx = gpd.GeoDataFrame(df_trx[["feature_name"]], geometry=geometry) - gdf_trx = gdf_trx.sjoin( - _nbhd_geometry_for_join(gdf_nbhd, nbhd_col), - how="left", - predicate="within", - ) - - df_result = ( - gdf_trx.groupby([nbhd_col, "feature_name"]) - .size() - .unstack(fill_value=0) - .rename_axis(None, axis=1) - .reindex(gdf_nbhd[nbhd_col]) - .fillna(0) - .astype(int) - ) + if gdf_trx is not None: + print("Calculating neighborhood-by-gene (cell-free, provided gdf_trx)") + df_result = _pivot_trx_counts_by_sjoin( + gdf_trx[[feature_col, "geometry"]], feature_col, nbhd_col, gdf_nbhd + ) + elif trx_parquet_path is not None: + print("Calculating neighborhood-by-gene (cell-free, streaming parquet)") + from celldega.nbhd.trx_streaming import _assign_trx_to_entity_streaming_parquet + + df_result = ( + _assign_trx_to_entity_streaming_parquet( + trx_parquet_path, + gdf_nbhd, + id_col=nbhd_col, + x_col=x_col, + y_col=y_col, + gene_col=feature_col, + batch_size=batch_size, + ) + .reindex(gdf_nbhd[nbhd_col]) + .fillna(0) + .astype(int) + ) + elif data_dir is not None: + print("Calculating neighborhood-by-gene (cell-free)") + + df_trx = pd.read_parquet( + f"{data_dir}/transcripts.parquet", + columns=["feature_name", "x_location", "y_location"], + engine="pyarrow", + ) + geometry = gpd.points_from_xy(df_trx["x_location"], df_trx["y_location"]) + gdf_trx_xenium = gpd.GeoDataFrame(df_trx[["feature_name"]], geometry=geometry) + feature_col = "feature_name" + df_result = _pivot_trx_counts_by_sjoin(gdf_trx_xenium, feature_col, nbhd_col, gdf_nbhd) + else: + raise ValueError( + "data_dir, gdf_trx, or trx_parquet_path is required when by='cell-free'" + ) # Filter by min_cells (here it's min transcripts total) trx_counts = df_result.sum(axis=1) diff --git a/src/celldega/nbhd/radial_expansion.py b/src/celldega/nbhd/radial_expansion.py new file mode 100644 index 00000000..75caa80a --- /dev/null +++ b/src/celldega/nbhd/radial_expansion.py @@ -0,0 +1,194 @@ +"""Radial expansion: per-entity buffering clipped to a matching bounding geometry. + +Unlike :mod:`celldega.nbhd.gradient` — which grows concentric rings outward from and +inward into ONE dissolved region of interest (e.g. a tumor alpha shape) — this grows +**every** neighborhood in a collection independently, using each one as its own tiny +ROI. Each buffered entity is clipped to a matching row of a per-entity bounding +GeoDataFrame, so the expansion never grows past that entity's own outer limit. The +canonical use case is growing a segmented nucleus outward until it reaches its +corresponding cell boundary (to profile how nuclear vs. cytoplasmic transcript +capture changes with the working boundary), but the same mechanics apply to any +pair of nested per-entity geometries — e.g. a core region expanding into a parent +tissue domain, or a seed point buffer expanding into a Voronoi/tile boundary. +""" + +from __future__ import annotations + +from collections.abc import Sequence + +import geopandas as gpd +import numpy as np +from shapely.validation import make_valid + +from .gradient import _get_micron_per_pixel, _ring_colors + + +_DEFAULT_RADII_UM: tuple[float, ...] = (0, 0.5, 1, 1.5, 2, 2.5, 3) + + +def _calc_radial_expansion( + gdf_source: gpd.GeoDataFrame, + gdf_bounds: gpd.GeoDataFrame, + radii_um: Sequence[float] = _DEFAULT_RADII_UM, + *, + id_col: str = "id", + technology: str | None = None, + scale_um_per_pixel: float | None = None, + pixels_per_micron: float | None = None, + is_pixel_space: bool = False, + join_style: int = 2, + mitre_limit: float = 5.0, + add_colors: bool = True, +) -> dict[float, gpd.GeoDataFrame]: + """Engine behind :meth:`NeighborhoodCollection.calc_radial_expansion`. + + For each radius in ``radii_um``, buffers every entity in ``gdf_source`` outward + by that distance and intersects the result with the matching row (by + ``id_col``) in ``gdf_bounds``, so growth stops at that entity's own bounding + geometry (e.g. a nucleus growing into its cell, or any other per-entity + container). Invalid input geometries are repaired with ``shapely.make_valid`` + first. + + Args: + gdf_source: One row per entity to expand (e.g. a nucleus), with an + ``id_col`` column and a ``geometry`` column. + gdf_bounds: One row per entity's clipping boundary (e.g. its cell), with + an ``id_col`` column matching ``gdf_source`` and a ``geometry`` + column. Must have exactly one row per id. + radii_um: Buffer distances in microns. ``0`` returns the original + (validity-repaired) source geometry, clipped to its bound. + id_col: Column identifying each entity, shared by both frames (default + ``"id"``). + technology: Imaging platform (e.g. ``"Xenium"``) used to look up + ``scale_um_per_pixel`` when the geometry is in pixel space. Ignored if + ``scale_um_per_pixel`` is given. + scale_um_per_pixel: Microns per pixel — the factor a micron distance is + *divided* by to get pixels (e.g. an OME-XML ``PhysicalSizeX``). + Required (directly, via ``technology``, or via ``pixels_per_micron``) + when ``is_pixel_space=True``. Takes precedence over + ``pixels_per_micron`` if both are given. + pixels_per_micron: Pixels per micron — the reciprocal convention, where a + micron distance is *multiplied* by this factor to get pixels (e.g. a + notebook's own ``buffer_dist = expand_um * high_res_scale``). Only + used when ``scale_um_per_pixel`` is not resolved some other way; + equivalent to passing ``scale_um_per_pixel=1 / pixels_per_micron``. + is_pixel_space: ``True`` if ``gdf_source``/``gdf_bounds`` geometry is in + pixel units; ``False`` (default) if already in microns. + join_style: Shapely buffer join style (``1``=round, ``2``=mitre (default, + matches sharp polygon corners), ``3``=bevel). + mitre_limit: Shapely mitre limit, used when ``join_style=2``. + add_colors: If ``True`` (default), add a ``color`` column — one shade per + radius (dark to light) — for visualization. + + Returns: + A dict mapping each radius in ``radii_um`` (in microns, ascending) to a + ``GeoDataFrame`` of that radius's buffered, clipped entities, with columns + ``id_col``, ``geometry``, ``radius_um``, ``center_x``, ``center_y``, + ``area``/``area_um2``/``area_px2``, and (when ``add_colors``) ``color``. + Entities that vanish entirely at a given radius (empty intersection) are + dropped from that radius's frame. + + Raises: + KeyError: If ``id_col`` is missing from either frame. + ValueError: If ids are duplicated in ``gdf_bounds``, if any source id is + missing from ``gdf_bounds``, or if ``is_pixel_space=True`` without a + resolvable scale (``scale_um_per_pixel``, ``pixels_per_micron``, or + ``technology``). + + Examples: + Prefer the public method, which anchors on a collection of entities and + returns one new collection per radius:: + + >>> series = nbhd_nuclei.calc_radial_expansion(gdf_cells, radii_um=[0, 1, 2, 3]) + + If geometry is in pixel space (e.g. built with a ``high_res_scale = + 1 / scaling_factor`` px/micron factor, so ``buffer_dist = expand_um * + high_res_scale``), pass that same factor directly as + ``pixels_per_micron`` instead of inverting it yourself:: + + >>> series = nbhd_nuclei.calc_radial_expansion( + ... gdf_cells, radii_um=[0, 1, 2, 3], + ... is_pixel_space=True, pixels_per_micron=high_res_scale, + ... ) + """ + if id_col not in gdf_source.columns: + raise KeyError(f"gdf_source missing '{id_col}'") + if id_col not in gdf_bounds.columns: + raise KeyError(f"gdf_bounds missing '{id_col}'") + + if scale_um_per_pixel is None and technology is not None: + scale_um_per_pixel = _get_micron_per_pixel(technology) + if scale_um_per_pixel is None and pixels_per_micron is not None: + scale_um_per_pixel = 1.0 / pixels_per_micron + if is_pixel_space and scale_um_per_pixel is None: + raise ValueError( + "scale_um_per_pixel, pixels_per_micron, or technology is required " + "when is_pixel_space=True" + ) + effective_scale = scale_um_per_pixel if is_pixel_space else 1.0 + + source = gdf_source[[id_col, "geometry"]].copy() + source[id_col] = source[id_col].astype(str) + if source[id_col].duplicated().any(): + dupes = source.loc[source[id_col].duplicated(), id_col].unique()[:5] + raise ValueError(f"gdf_source has duplicate '{id_col}' values, e.g. {list(dupes)}") + source["geometry"] = source["geometry"].apply(make_valid) + + bounds = gdf_bounds[[id_col, "geometry"]].copy() + bounds[id_col] = bounds[id_col].astype(str) + if bounds[id_col].duplicated().any(): + dupes = bounds.loc[bounds[id_col].duplicated(), id_col].unique()[:5] + raise ValueError(f"gdf_bounds has duplicate '{id_col}' values, e.g. {list(dupes)}") + bounds_lookup = bounds.set_index(id_col)["geometry"].apply(make_valid) + + missing = set(source[id_col]) - set(bounds_lookup.index) + if missing: + example = sorted(missing)[:5] + raise ValueError( + f"{len(missing)} entities have no matching row in gdf_bounds (by '{id_col}'), " + f"e.g. {example}" + ) + + radii_sorted = sorted({float(r) for r in radii_um}) + colors = _ring_colors("viridis", len(radii_sorted)) if add_colors else [None] * len(radii_sorted) + color_by_radius = dict(zip(radii_sorted, colors, strict=True)) + + results: dict[float, gpd.GeoDataFrame] = {} + for radius_um in radii_sorted: + radius_native = radius_um / effective_scale + + buffered = source["geometry"].buffer( + radius_native, join_style=join_style, mitre_limit=mitre_limit + ) + clipped = [ + geom.intersection(bounds_lookup.loc[eid]) + for eid, geom in zip(source[id_col], buffered, strict=True) + ] + + gdf_radius = gpd.GeoDataFrame( + {id_col: source[id_col].to_numpy()}, + geometry=clipped, + crs=gdf_source.crs, + ) + gdf_radius = gdf_radius[~gdf_radius.geometry.is_empty].reset_index(drop=True) + gdf_radius["radius_um"] = radius_um + gdf_radius["center_x"] = gdf_radius.centroid.x + gdf_radius["center_y"] = gdf_radius.centroid.y + + area_native = gdf_radius.geometry.area + if is_pixel_space: + gdf_radius["area_px2"] = area_native + gdf_radius["area_um2"] = area_native * (scale_um_per_pixel**2) + else: + gdf_radius["area_um2"] = area_native + gdf_radius["area_px2"] = ( + area_native / (scale_um_per_pixel**2) if scale_um_per_pixel else np.nan + ) + gdf_radius["area"] = gdf_radius["area_um2"] + + if add_colors: + gdf_radius["color"] = color_by_radius[radius_um] + + results[radius_um] = gdf_radius + + return results diff --git a/src/celldega/nbhd/trx_streaming.py b/src/celldega/nbhd/trx_streaming.py new file mode 100644 index 00000000..0857416a --- /dev/null +++ b/src/celldega/nbhd/trx_streaming.py @@ -0,0 +1,149 @@ +"""Streaming, spatial-index-accelerated transcript-to-entity assignment. + +The other cell-free code paths in :mod:`celldega.nbhd.neighborhoods` +(``gdf_trx=`` or ``data_dir=``) load every transcript into memory as point +geometries and run a single :meth:`geopandas.GeoDataFrame.sjoin`. For a +whole-tile ``transcripts.parquet`` (tens of millions of rows, e.g. covering a +55,000 x 55,000 micron tile) that is more memory than is comfortable to hold — +especially when the same file is assigned once per radius in a +:meth:`~celldega.nbhd.collection.NeighborhoodCollection.calc_radial_expansion` +series. + +This module instead streams the parquet file in batches via ``pyarrow``, and for +each batch only tests the entities whose bounding box the batch could plausibly +intersect (using the entity ``GeoDataFrame``'s spatial index), so memory use stays +bounded by the batch size regardless of the total transcript count. +""" + +from __future__ import annotations + +from collections import defaultdict + +import geopandas as gpd +import numpy as np +import pandas as pd +import pyarrow.dataset as ds +import shapely + + +def _assign_trx_to_entity_streaming_parquet( + trx_parquet_path: str, + gdf_entity: gpd.GeoDataFrame, + id_col: str, + *, + x_col: str = "x", + y_col: str = "y", + gene_col: str = "gene", + batch_size: int = 1_000_000, + assume_non_overlapping: bool = True, +) -> pd.DataFrame: + """Stream transcripts from ``trx_parquet_path`` and count them per entity/gene. + + For each streamed batch of transcripts, candidate entities are first narrowed + down with ``gdf_entity``'s spatial index (by the batch's bounding box), then + each candidate's exact polygon is tested with a vectorized point-in-polygon + check (``shapely.contains_xy``). Counts are accumulated across batches. + + Args: + trx_parquet_path: Path to a transcripts parquet file (or partitioned + dataset directory) containing at least ``x_col``, ``y_col``, and + ``gene_col``. + gdf_entity: One row per entity to assign transcripts to — e.g. a nucleus, + cell, or a single radius's buffered polygons from + :meth:`NeighborhoodCollection.calc_radial_expansion` — with an + ``id_col`` column and a ``geometry`` column. + id_col: Column in ``gdf_entity`` identifying each entity. + x_col: Transcript x-coordinate column in the parquet file. + y_col: Transcript y-coordinate column in the parquet file. + gene_col: Transcript gene/feature column in the parquet file. + batch_size: Number of transcript rows read per streamed batch. Bounds + peak memory use; does not affect the result. + assume_non_overlapping: If ``True`` (default), a transcript is excluded + from consideration for further entities once assigned. Valid whenever + entities don't overlap (nuclei, cells, non-overlapping radial-buffer + rings), and lets a batch stop early once every point has a match. + + Returns: + A ``DataFrame`` indexed by entity id (as ``str``) with one integer count + column per gene seen in an assigned transcript. Entities with zero + assigned transcripts, and genes never seen in an assigned transcript, are + simply absent — callers typically reindex/``fillna(0)`` against the full + entity and gene axes. + + Raises: + KeyError: If ``id_col`` is missing from ``gdf_entity``. + ValueError: If ``gdf_entity`` has no valid (non-null) geometries. + """ + if id_col not in gdf_entity.columns: + raise KeyError(f"gdf_entity missing '{id_col}'") + + entity = gdf_entity[[id_col, "geometry"]].copy() + entity = entity[entity.geometry.notna()].reset_index(drop=True) + if entity.empty: + raise ValueError("gdf_entity has no valid geometries") + entity["geometry"] = entity.geometry.buffer(0) + entity[id_col] = entity[id_col].astype(str) + + ids = entity[id_col].to_numpy() + geoms = entity.geometry.to_numpy() + bboxes = np.array([g.bounds for g in geoms], dtype=np.float64) + sindex = entity.sindex + + dataset = ds.dataset(trx_parquet_path, format="parquet") + scanner = dataset.scanner(columns=[x_col, y_col, gene_col], batch_size=batch_size) + + counts: dict[tuple[str, str], int] = defaultdict(int) + + for batch in scanner.to_batches(): + if batch.num_rows == 0: + continue + + x = batch.column(batch.schema.get_field_index(x_col)).to_numpy(zero_copy_only=False) + y = batch.column(batch.schema.get_field_index(y_col)).to_numpy(zero_copy_only=False) + gene = batch.column(batch.schema.get_field_index(gene_col)).to_numpy(zero_copy_only=False) + + valid = np.isfinite(x) & np.isfinite(y) + if not valid.all(): + x, y, gene = x[valid], y[valid], gene[valid] + if len(x) == 0: + continue + + assigned = np.full(len(x), -1, dtype=np.int64) + + candidates = list(sindex.intersection((x.min(), y.min(), x.max(), y.max()))) + for j in candidates: + minx, miny, maxx, maxy = bboxes[j] + cand = (x >= minx) & (x <= maxx) & (y >= miny) & (y <= maxy) + if assume_non_overlapping: + cand &= assigned == -1 + if not cand.any(): + continue + + idx = np.flatnonzero(cand) + inside = shapely.contains_xy(geoms[j], x[idx], y[idx]) + if inside.any(): + assigned[idx[inside]] = j + + if assume_non_overlapping and (assigned != -1).all(): + break + + keep = assigned != -1 + if not keep.any(): + continue + + chunk = pd.DataFrame({id_col: ids[assigned[keep]], gene_col: gene[keep]}) + for (eid, g), c in chunk.value_counts().items(): + counts[(eid, g)] += int(c) + + if not counts: + return pd.DataFrame(index=pd.Index([], name=id_col)) + + df_long = pd.DataFrame( + [(eid, g, c) for (eid, g), c in counts.items()], + columns=[id_col, gene_col, "count"], + ) + return ( + df_long.pivot_table(index=id_col, columns=gene_col, values="count", fill_value=0, aggfunc="sum") + .rename_axis(None, axis=1) + .astype(int) + ) diff --git a/tests/unit/test_nbhd/test_radial_expansion.py b/tests/unit/test_nbhd/test_radial_expansion.py new file mode 100644 index 00000000..dc887fef --- /dev/null +++ b/tests/unit/test_nbhd/test_radial_expansion.py @@ -0,0 +1,314 @@ +import geopandas as gpd +import numpy as np +import pandas as pd +import pytest +from shapely.geometry import Point, Polygon + +from celldega.nbhd import NeighborhoodCollection +from celldega.nbhd.radial_expansion import _calc_radial_expansion + + +def _synthetic_nucleus_cell_inputs(): + # cell 1: 10x10 square at origin; nucleus 1: centered 2x2 square (area 4) + # cell 2: 10x10 square offset far away; nucleus 2: centered 2x2 square (area 4) + gdf_nuclei = gpd.GeoDataFrame( + { + "cell_id": ["c1", "c2"], + "geometry": [ + Polygon([(4, 4), (6, 4), (6, 6), (4, 6)]), + Polygon([(24, 24), (26, 24), (26, 26), (24, 26)]), + ], + } + ) + gdf_cells = gpd.GeoDataFrame( + { + "cell_id": ["c1", "c2"], + "geometry": [ + Polygon([(0, 0), (10, 0), (10, 10), (0, 10)]), + Polygon([(20, 20), (30, 20), (30, 30), (20, 30)]), + ], + } + ) + return gdf_nuclei, gdf_cells + + +def test_calc_radial_expansion_grows_and_clips_to_bound(): + gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() + + series = _calc_radial_expansion(gdf_nuclei, gdf_cells, radii_um=[0, 1, 5], id_col="cell_id") + + assert list(series.keys()) == [0.0, 1.0, 5.0] + + # radius 0: original 2x2 source polygon, area 4 + gdf_0 = series[0.0] + assert set(gdf_0["cell_id"]) == {"c1", "c2"} + np.testing.assert_allclose(sorted(gdf_0["area_um2"]), [4.0, 4.0]) + + # radius 1: buffered 1 unit on each side -> 4x4 square, area 16, still inside the bound + gdf_1 = series[1.0] + np.testing.assert_allclose(sorted(gdf_1["area_um2"]), [16.0, 16.0]) + + # radius 5: buffer would overshoot the bound -> clipped to the full 10x10 bound + gdf_5 = series[5.0] + np.testing.assert_allclose(sorted(gdf_5["area_um2"]), [100.0, 100.0]) + + +def test_calc_radial_expansion_pixels_per_micron_matches_scale_um_per_pixel(): + gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() + high_res_scale = 2.0 # pixels per micron, e.g. a notebook's own scale variable + scaling_factor = 1.0 / high_res_scale # microns per pixel + + via_pixels_per_micron = _calc_radial_expansion( + gdf_nuclei, + gdf_cells, + radii_um=[1], + id_col="cell_id", + is_pixel_space=True, + pixels_per_micron=high_res_scale, + ) + via_scale_um_per_pixel = _calc_radial_expansion( + gdf_nuclei, + gdf_cells, + radii_um=[1], + id_col="cell_id", + is_pixel_space=True, + scale_um_per_pixel=scaling_factor, + ) + + pd.testing.assert_frame_equal( + via_pixels_per_micron[1.0].drop(columns="color"), + via_scale_um_per_pixel[1.0].drop(columns="color"), + ) + + # matches `buffer_dist = expand_um * high_res_scale`: a 2x2 nucleus buffered by + # 1um * 2px/um = 2px on each side -> 6x6 = 36 px^2, well inside the 10x10 bound + gdf_1 = via_pixels_per_micron[1.0] + np.testing.assert_allclose(sorted(gdf_1["area_px2"]), [36.0, 36.0]) + # area_um2 = area_px2 * scale_um_per_pixel**2 = 36 * 0.25 = 9 + np.testing.assert_allclose(sorted(gdf_1["area_um2"]), [9.0, 9.0]) + + +def test_calc_radial_expansion_scale_um_per_pixel_takes_precedence(): + gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() + + result = _calc_radial_expansion( + gdf_nuclei, + gdf_cells, + radii_um=[1], + id_col="cell_id", + is_pixel_space=True, + scale_um_per_pixel=0.5, + pixels_per_micron=999, # should be ignored since scale_um_per_pixel is given + ) + np.testing.assert_allclose(sorted(result[1.0]["area_px2"]), [36.0, 36.0]) + + +def test_calc_radial_expansion_raises_when_pixel_space_scale_missing(): + gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() + + with pytest.raises(ValueError, match="scale_um_per_pixel, pixels_per_micron, or technology"): + _calc_radial_expansion( + gdf_nuclei, gdf_cells, radii_um=[1], id_col="cell_id", is_pixel_space=True + ) + + +def test_neighborhood_collection_calc_radial_expansion_accepts_pixels_per_micron(): + gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() + nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") + + series = nbhd_nuclei.calc_radial_expansion( + gdf_cells, radii_um=[1], is_pixel_space=True, pixels_per_micron=2.0 + ) + + np.testing.assert_allclose(sorted(series[1.0].gdf["area_px2"]), [36.0, 36.0]) + + +def test_calc_radial_expansion_works_for_non_nucleus_entities(): + # Demonstrates this isn't nucleus/cell-specific: any pair of per-entity + # source/bound geometries with a shared id column works, e.g. a small "core" + # region expanding into a larger parent "zone". + gdf_core = gpd.GeoDataFrame( + { + "region_id": ["r1", "r2"], + "geometry": [ + Polygon([(1, 1), (2, 1), (2, 2), (1, 2)]), + Polygon([(11, 1), (12, 1), (12, 2), (11, 2)]), + ], + } + ) + gdf_zone = gpd.GeoDataFrame( + { + "region_id": ["r1", "r2"], + "geometry": [ + Polygon([(0, 0), (5, 0), (5, 5), (0, 5)]), + Polygon([(10, 0), (15, 0), (15, 5), (10, 5)]), + ], + } + ) + + series = _calc_radial_expansion(gdf_core, gdf_zone, radii_um=[0, 10], id_col="region_id") + + assert list(series.keys()) == [0.0, 10.0] + assert set(series[0.0]["region_id"]) == {"r1", "r2"} + # radius 10 overshoots every zone -> clipped to each 5x5 zone, area 25 + np.testing.assert_allclose(sorted(series[10.0]["area_um2"]), [25.0, 25.0]) + + +def test_calc_radial_expansion_add_colors(): + gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() + + with_colors = _calc_radial_expansion(gdf_nuclei, gdf_cells, radii_um=[0, 1, 2], id_col="cell_id") + assert all("color" in gdf.columns for gdf in with_colors.values()) + # one shade per radius, shared across entities within that radius + assert with_colors[0.0]["color"].nunique() == 1 + assert len({gdf["color"].iloc[0] for gdf in with_colors.values()}) == 3 + + without_colors = _calc_radial_expansion( + gdf_nuclei, gdf_cells, radii_um=[0, 1], id_col="cell_id", add_colors=False + ) + assert all("color" not in gdf.columns for gdf in without_colors.values()) + + +def test_calc_radial_expansion_raises_on_duplicate_ids(): + gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() + gdf_cells_dup = pd.concat([gdf_cells, gdf_cells.iloc[[0]]], ignore_index=True) + gdf_cells_dup = gpd.GeoDataFrame(gdf_cells_dup, geometry="geometry") + + with pytest.raises(ValueError, match="duplicate"): + _calc_radial_expansion(gdf_nuclei, gdf_cells_dup, radii_um=[0, 1], id_col="cell_id") + + +def test_calc_radial_expansion_raises_on_missing_bound_match(): + gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() + gdf_cells_missing = gdf_cells.iloc[[0]].reset_index(drop=True) + + with pytest.raises(ValueError, match="no matching row"): + _calc_radial_expansion(gdf_nuclei, gdf_cells_missing, radii_um=[0, 1], id_col="cell_id") + + +def test_neighborhood_collection_calc_radial_expansion_returns_series(): + gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() + nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") + + series = nbhd_nuclei.calc_radial_expansion(gdf_cells, radii_um=[0, 1, 5]) + + assert list(series.keys()) == [0.0, 1.0, 5.0] + for nbhd in series.values(): + assert isinstance(nbhd, NeighborhoodCollection) + assert nbhd.nbhd_col == "cell_id" + assert set(nbhd.obs.index) == {"c1", "c2"} + assert nbhd.nbhd_type == "radial_expansion" + + +def test_calc_signature_cell_free_accepts_custom_gdf_trx(): + gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() + nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") + series = nbhd_nuclei.calc_radial_expansion(gdf_cells, radii_um=[0, 5]) + + # Custom transcript format: "name" for gene, arbitrary x/y columns already + # converted to points -- exercises the feature_col override end to end. + gdf_trx = gpd.GeoDataFrame( + {"name": ["GeneA", "GeneB", "GeneA"]}, + geometry=[Point(5, 5), Point(1, 1), Point(25, 25)], + ) + + nbhd_r0 = series[0.0] + nbhd_r0.calc_signature(by="cell-free", gdf_trx=gdf_trx, feature_col="name", drop_missing=False) + modality_r0 = nbhd_r0.mod["gene_cell_free"] + df_r0 = pd.DataFrame(modality_r0.X, index=modality_r0.obs_names, columns=modality_r0.var_names) + # at radius 0 the source polygon doesn't reach (1, 1); only the point inside it counts + # ("GeneB" never falls inside any neighborhood at this radius, so it has no column) + assert df_r0.loc["c1", "GeneA"] == 1 + assert "GeneB" not in df_r0.columns + assert df_r0.loc["c2", "GeneA"] == 1 + + nbhd_r5 = series[5.0] + nbhd_r5.calc_signature(by="cell-free", gdf_trx=gdf_trx, feature_col="name", drop_missing=False) + modality_r5 = nbhd_r5.mod["gene_cell_free"] + df_r5 = pd.DataFrame(modality_r5.X, index=modality_r5.obs_names, columns=modality_r5.var_names) + # at radius 5 the source polygon has expanded to the full bound, now capturing (1, 1) too + assert df_r5.loc["c1", "GeneA"] == 1 + assert df_r5.loc["c1", "GeneB"] == 1 + + +def test_calc_signature_cell_free_requires_data_dir_or_gdf_trx(): + gdf_nuclei, _gdf_cells = _synthetic_nucleus_cell_inputs() + nbhd = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") + + with pytest.raises(ValueError, match="data_dir, gdf_trx, or trx_parquet_path"): + nbhd.calc_signature(by="cell-free") + + +def test_calc_signature_cell_free_streams_from_parquet_across_radii(tmp_path): + gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() + nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") + series = nbhd_nuclei.calc_radial_expansion(gdf_cells, radii_um=[0, 5]) + + trx_path = tmp_path / "transcripts.parquet" + pd.DataFrame( + { + "x": [5, 1, 25], + "y": [5, 1, 25], + "name": ["GeneA", "GeneB", "GeneA"], + } + ).to_parquet(trx_path) + + nbhd_r0 = series[0.0] + nbhd_r0.calc_signature( + by="cell-free", + trx_parquet_path=str(trx_path), + feature_col="name", + drop_missing=False, + ) + df_r0 = pd.DataFrame( + nbhd_r0.mod["gene_cell_free"].X, + index=nbhd_r0.mod["gene_cell_free"].obs_names, + columns=nbhd_r0.mod["gene_cell_free"].var_names, + ) + assert df_r0.loc["c1", "GeneA"] == 1 + assert "GeneB" not in df_r0.columns + + nbhd_r5 = series[5.0] + nbhd_r5.calc_signature( + by="cell-free", + trx_parquet_path=str(trx_path), + feature_col="name", + drop_missing=False, + ) + df_r5 = pd.DataFrame( + nbhd_r5.mod["gene_cell_free"].X, + index=nbhd_r5.mod["gene_cell_free"].obs_names, + columns=nbhd_r5.mod["gene_cell_free"].var_names, + ) + assert df_r5.loc["c1", "GeneA"] == 1 + assert df_r5.loc["c1", "GeneB"] == 1 + + +def test_calc_transcript_assignment_streaming_mode_computes_totals(tmp_path): + gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() + nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") + series = nbhd_nuclei.calc_radial_expansion(gdf_cells, radii_um=[5]) + + trx_path = tmp_path / "transcripts.parquet" + pd.DataFrame( + { + "x": [5, 1, 25], + "y": [5, 1, 25], + "name": ["GeneA", "GeneB", "GeneA"], + } + ).to_parquet(trx_path) + + nbhd_r5 = series[5.0] + nbhd_r5.calc_transcript_assignment(trx_parquet_path=str(trx_path), gene_col="name") + + assert nbhd_r5.obs.loc["c1", "total_transcripts"] == 2 + assert nbhd_r5.obs.loc["c2", "total_transcripts"] == 1 + assert "unassigned_transcripts" not in nbhd_r5.obs.columns + + +def test_calc_transcript_assignment_requires_data_dir_or_trx_parquet_path(): + gdf_nuclei, _gdf_cells = _synthetic_nucleus_cell_inputs() + nbhd = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") + + with pytest.raises(ValueError, match="data_dir or trx_parquet_path"): + nbhd.calc_transcript_assignment() diff --git a/tests/unit/test_nbhd/test_trx_streaming.py b/tests/unit/test_nbhd/test_trx_streaming.py new file mode 100644 index 00000000..a5dd1549 --- /dev/null +++ b/tests/unit/test_nbhd/test_trx_streaming.py @@ -0,0 +1,88 @@ +import geopandas as gpd +import pandas as pd +import pytest +from shapely.geometry import Polygon + +from celldega.nbhd.trx_streaming import _assign_trx_to_entity_streaming_parquet + + +def _synthetic_entities(): + return gpd.GeoDataFrame( + { + "cell_id": ["c1", "c2"], + "geometry": [ + Polygon([(0, 0), (10, 0), (10, 10), (0, 10)]), + Polygon([(20, 20), (30, 20), (30, 30), (20, 30)]), + ], + } + ) + + +def _write_trx_parquet(tmp_path, rows): + path = tmp_path / "transcripts.parquet" + pd.DataFrame(rows, columns=["x", "y", "gene"]).to_parquet(path) + return str(path) + + +def test_streaming_assignment_counts_points_per_entity_and_gene(tmp_path): + gdf_entity = _synthetic_entities() + trx_path = _write_trx_parquet( + tmp_path, + [ + (1, 1, "GeneA"), + (2, 2, "GeneA"), + (3, 3, "GeneB"), + (25, 25, "GeneA"), + (100, 100, "GeneA"), # outside every entity -> dropped + ], + ) + + counts = _assign_trx_to_entity_streaming_parquet(trx_path, gdf_entity, id_col="cell_id") + + assert counts.loc["c1", "GeneA"] == 2 + assert counts.loc["c1", "GeneB"] == 1 + assert counts.loc["c2", "GeneA"] == 1 + assert "c2" not in counts.index or counts.loc["c2"].get("GeneB", 0) == 0 + + +def test_streaming_assignment_batches_across_multiple_reads(tmp_path): + gdf_entity = _synthetic_entities() + rows = [(1, 1, "GeneA") for _ in range(5)] + [(25, 25, "GeneB") for _ in range(3)] + trx_path = _write_trx_parquet(tmp_path, rows) + + counts = _assign_trx_to_entity_streaming_parquet( + trx_path, gdf_entity, id_col="cell_id", batch_size=2 + ) + + assert counts.loc["c1", "GeneA"] == 5 + assert counts.loc["c2", "GeneB"] == 3 + + +def test_streaming_assignment_custom_column_names(tmp_path): + gdf_entity = _synthetic_entities() + path = tmp_path / "custom_trx.parquet" + pd.DataFrame( + {"xx": [1, 2], "yy": [1, 2], "name": ["GeneA", "GeneA"]} + ).to_parquet(path) + + counts = _assign_trx_to_entity_streaming_parquet( + str(path), gdf_entity, id_col="cell_id", x_col="xx", y_col="yy", gene_col="name" + ) + + assert counts.loc["c1", "GeneA"] == 2 + + +def test_streaming_assignment_raises_on_missing_id_col(tmp_path): + gdf_entity = _synthetic_entities() + trx_path = _write_trx_parquet(tmp_path, [(1, 1, "GeneA")]) + + with pytest.raises(KeyError): + _assign_trx_to_entity_streaming_parquet(trx_path, gdf_entity, id_col="not_a_column") + + +def test_streaming_assignment_no_matches_returns_empty_frame(tmp_path): + gdf_entity = _synthetic_entities() + trx_path = _write_trx_parquet(tmp_path, [(1000, 1000, "GeneA")]) + + counts = _assign_trx_to_entity_streaming_parquet(trx_path, gdf_entity, id_col="cell_id") + assert counts.empty From 0b72117f841ca8afa35e0e5dac1105f36714e20e Mon Sep 17 00:00:00 2001 From: Jaspreet Ishar Date: Wed, 15 Jul 2026 09:34:14 -0400 Subject: [PATCH 02/14] updated notebook --- .../Nuclear_Expansion_Radial_Buffering.ipynb | 152 +++++------------- 1 file changed, 43 insertions(+), 109 deletions(-) diff --git a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb index d7a7f9bb..a0f74b1b 100644 --- a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb +++ b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb @@ -44,14 +44,7 @@ "cell_type": "code", "execution_count": 1, "id": "4d0f46b0", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-14T20:59:26.316776Z", - "iopub.status.busy": "2026-07-14T20:59:26.316514Z", - "iopub.status.idle": "2026-07-14T20:59:29.288981Z", - "shell.execute_reply": "2026-07-14T20:59:29.287996Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -97,14 +90,7 @@ "cell_type": "code", "execution_count": 2, "id": "5f2394c8", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-14T20:59:29.291486Z", - "iopub.status.busy": "2026-07-14T20:59:29.291013Z", - "iopub.status.idle": "2026-07-14T20:59:29.304093Z", - "shell.execute_reply": "2026-07-14T20:59:29.303573Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -172,14 +158,7 @@ "cell_type": "code", "execution_count": 3, "id": "85a6f217", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-14T20:59:29.305897Z", - "iopub.status.busy": "2026-07-14T20:59:29.305763Z", - "iopub.status.idle": "2026-07-14T20:59:29.317657Z", - "shell.execute_reply": "2026-07-14T20:59:29.317158Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -273,14 +252,7 @@ "cell_type": "code", "execution_count": 4, "id": "658414fd", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-14T20:59:29.319060Z", - "iopub.status.busy": "2026-07-14T20:59:29.318957Z", - "iopub.status.idle": "2026-07-14T20:59:29.410156Z", - "shell.execute_reply": "2026-07-14T20:59:29.409631Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -308,15 +280,19 @@ "cell_type": "code", "execution_count": 5, "id": "140c06c5", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-14T20:59:29.411802Z", - "iopub.status.busy": "2026-07-14T20:59:29.411669Z", - "iopub.status.idle": "2026-07-14T20:59:30.241487Z", - "shell.execute_reply": "2026-07-14T20:59:30.240806Z" + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAB/gAAAErCAYAAADaN1u9AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQWcVOX3xp+Z7aW7u7tBQRFFTAQVFLC7u7vjZ6HY+rcDCxMVA6QUEQRppLub7ZiZ/+d517suK2xO3Hvn+fqZz+6Oy8zdmXvPvO95znmOJxAIBCCEEEIIIYQQQgghhBBCCCGEEEIIW+ON9AEIIYQQQgghhBBCCCGEEEIIIYQQongk8AshhBBCCCGEEEIIIYQQQgghhBAOQAK/EEIIIYQQQgghhBBCCCGEEEII4QAk8AshhBBCCCGEEEIIIYQQQgghhBAOQAK/EEIIIYQQQgghhBBCCCGEEEII4QAk8AshhBBCCCGEEEIIIYQQQgghhBAOQAK/EEIIIYQQQgghhBBCCCGEEEII4QAk8AshhBBCCCGEEEIIIYQQQgghhBAOQAK/EEIIIYQQQgghhBBCCCGEEEII4QAk8AshhBBCCCGEEDZl3rx58Hg8GDduXJH3lfWxDsXOnTvN7z799NNlOm4hhBBCCCGEEEKEBgn8QgghhBBCCCGEKBOvvvqqKQQ41O3WW2/VKyuEEEIIIYQQQgQRCfxCCCGEEEIIIUQU0LVrVwQCAQwfPjxoj3nFFVeYxyx8GzVqlPn/Q4YMCdpzCSGEEEIIIYQQQgK/EEIIIYQQQgghgsjevXvx5Zdfol27djjyyCP12gohhBBCCCGEEEFEHfxCCCGEEEIIIUSQSUtLw9133402bdogMTERzZo1ww033IDdu3cf8Dt33nknWrZsifj4eNSpUwcXX3wxduzYEZL3Y968ecY2f9y4cQfcv3r1agwdOhQVK1ZEzZo1cd111yErK6vMz/Phhx8iMzMTl156aRCOWgghhBBCCCGEEAWRwC+EEEIIIYQQQgSR9PR09O/fH++88w4ef/xxbNmyBVOmTEHz5s2N+E0yMjJw9NFH46OPPsILL7yAXbt2YeLEiVi8eDEGDBhgHiMc8HnZZb9+/XpMnz4dq1atQo8ePXDLLbeU+THfeustJCQk4LzzzgvqsQohhBBCCCGEEAKI1YsghBBCCCGEEEIEDwr2c+fOxdSpU43QT6pVq2Y64y1eeeUVzJ49G7///jsOO+wwc1+nTp3wySefmI5+iuTXXHNNyN+WMWPGYOvWrZg8eTJat25t7jv//POxcuXKMj3e/Pnzzd9+1llnoUaNGkE+WiGEEEIIIYQQQqiDXwghhBBCCCGECCLff/89GjZsmC/uH4zx48eb37HEfYsmTZoYgZ/FAeFg0qRJZoyAJe5bnHrqqWV6vDfffNN8lT2/EEIIIYQQQggRGtTBL4QQQgghhBBCBJHt27ejQYMGRf4Ou+Y3btyI2Ni8bXkgEMi/kXr16oXNov9gz1WnTp1SP1ZWVpYZQcBiAY4ZEEIIIYQQQgghRPCRwC+EEEIIIYQQQgSRWrVqYc2aNUX+Ts2aNdG2bVssXbo0oq89bfS3bdv2n/sPdl9xfPXVV9i9ezfuvPPOIB2dEEIIIYQQQgghCiOLfiGEEEIIIYQQIogMHjzYdOdPmzbtkL9zyimnYNmyZWZmfSQ55phjzHGsWLHigPu//vrrMtnzx8fH44ILLgjiEQohhBBCCCGEEKIgEviFEEIIIYQQQoggcs0116B79+4YNWoUvvzyS+zZswfr16/HCy+8YG7k2muvRe/evc2s+y+++AI7d+7E3r17MXPmTFx99dV47733wvKeXHfddcaOf8SIEZg3bx727duH999/H6tWrSrV4/DvmzRpEk477TTjTiCEEEIIIYQQQojQIIFfCCGEEEIIIYQIIsnJyZg6dSrOPfdc3Hrrrahbt66ZSb969WqcffbZ5neSkpIwZcoUXHTRRbjvvvvQqFEjtGjRAjfffDM6deqEM844I2zjBOg00KBBA/Tr1w/Nmzc3RQZPPvlkqR7n7bffht/vx2WXXRayYxVCCCGEEEIIIQTgCQQCAb0QQgghhBBCCCGEEEIIIYQQQgghhL1RB78QQgghhBBCCCGEEEIIIYQQQgjhACTwCyGEEEIIIYQQQgghhBBCCCGEEA5AAr8QQgghhBBCCOFgEhMT4fF4Dnlr2rRppA9RCCGEEEIIIYQQQcITCAQCwXowIYQQQgghhBBCCCGEEEIIIYQQQoQGdfALIYQQQgghhBBCCCGEEEIIIYQQDkACvxBCCCGEEEIIIYQQQgghhBBCCOEAJPALIYQQQgghhBBCCCGEEEIIIYQQDkACvxBCCCGEEEIIIYQQQgghhBBCCOEAJPALIYQQQgghhBBCCCGEEEIIIYQQDkACvxBCCCGEEEIIIYQQQgghhBBCCOEAJPALIYQQQgghhBBCCCGEEEIIIYQQDiA20gcgiuaGG27AkCFDcMwxxxT5e4FAAN9++y2mT59uvj/ssMNw2mmnwetVDYcQouzs378ft912G66++mp06tSpyN/NycnBp59+irlz5yI+Ph4DBw7EscceW6LnefXVVzFv3rz/3F+lShU88cQTZT5+IYRYtWoVnnrqKTz44IOoU6dOsTHvm2++wYwZM1CzZk089NBDegGFEOXm999/x7vvvouXX3652P3Zjh078Pnnn2P+/Plo3749rr322hI/D3+X67HCHH744Tj//PPLdOxCCEG4Pvrjjz/w6KOPFvmC7Nmzx+SmlixZgri4OHTo0AGnn366+V4IIcrDm2++idTUVFx//fVF/t7mzZvx3XffYfny5ahcuTK6d++Ok046CR6Pp9jn4L8ZPXr0Qf/fJZdcgp49e5b5+IUQ4vHHH0eTJk1w1llnFfli7N6926y9uJ5KSEhAmzZtMGzYMCQlJelFFAcg9dfmvPHGG1iwYEGRv8MkDosALrzwQnORUxBjcue4445DZmZm2I5VCOE+0tPT8dprr2HdunVF/t7evXtN8viee+5BrVq1zMaJCw/GJRYdFccPP/yAL774Al27dj3gxoSQEEKUhy1btpg4xoRzcUWVLVu2NPHo66+/xtixY/XCCyGCwrJly0wc8vv9Rf7eqaeeii5dupiix7ffftskp0vD//3f/5nnKryeaty4cTn/AiFEtDNr1ix8+OGHRf7OmDFjUL9+fTz77LNGVGNB0+2334527dph8eLFYTtWIYQ7+fnnnzF+/Pgif+emm24y656PPvoItWvXRlpamily7N27N7Zu3Vrsc7A4gGu2mJiY/6ynqlWrFsS/RggRjbCQe9q0aUX+zltvvYU+ffqYxhM2qTCvznx706ZNzXpMiIKog98FPPfccyb5wwvcqiQcPny46bZlVRA71oQQIpQwccOE8tKlS9GwYUNz31FHHYUTTjjBOJCce+65xT4Gk0BXXHGF3ighREQYNWqUcQxhdTQTOOwOEUKIcHLrrbcaJzYmlT/44IMyPQaLI7WeEkJEAnaZscP/xhtvzO+UZadtx44dcd5552HOnDl6Y4QQIYV5KRYjjRgx4oDO+86dO5t49Mknn5TocU488UQMHjw4hEcqhBAH54gjjjD59djYf6Vbrq1at26Na665RiK/OAB18LsAWluzc7agTVDbtm1NB39JOkVY3XiwLrXXX38d99133wH3Pfzww8Za0ufz4eOPPzb/llXarIgkvJ+LpZtvvtkUF9BiUgjh/i7/999/31gvWuI+Of74483igzEjlDD+MJE9ceLE//w/JpheeOGFA+6jw8lnn31mHE7Y6cY4Rqs3y9KW9/NnLp4KxjchhLthhTTF/bKwZs0aE4doqX0wZ4CCiSQ6nvB3p0yZYlwFWKjJddO4cePyHU/4O4w//Les3s7NzS3HXyaEcAr9+vUz4n4kYLE4YxM71wqPLuH9v/zyywH2tbyPYt6mTZvMvo/FCQXXYnyc//3vf2Y9RZcmIYT74Wgj7q0K2mCz45Vj2zjGrTg3JVr7M7YUXvdw3BLvX7hwYf59v/32m7mPOae///4b999/P+68884Diggo9LHhheusyZMnB/VvFULYE+6dCor7hC5t3bp1O2jOKNjQgYmx6GDjmhiztm3bln/fV199lV+UyREo/HfMwzPmFVyf3X333bjjjjvw119/hfz4hRCRh7n0guI+qVGjhtH71q9fX+y/f/LJJw86aoSW/4w5BbXCgvof3Sy5p3vssccOiFU//fSTGd/LtVbB+CTsgQR+h0N7odWrV6NXr14HTVTzYly5cmWxi5+DWYPw4i0s/DNB/f333+Oiiy7Cr7/+aqy4mYBmpy5FMXa/TZ061dxPgYzHQPFPCOFemKzJyMg4ZBz6888/kZ2dXezj7Nu3z2xcrrvuOpMQLpjAKQo+N4uZaGdbGAr5he1tKeozwcOCBMbHqlWrmoUKN4EU80855RSTJKpevToeeeQRU6gghBBFwfUW4xCF/oONW5o+fXr+z3QG4O9S4OcoEya7OZf2nHPOMbGIohjj0M6dO5GcnIyrr77adJ0IIURJYPKXYhaF9VdeeaXEBdcU7RmbOO/xYOOaCo6Ns+xruV88++yzTZKIsc0qMGex05lnnmlEOq4B6S7HNZUQwt3QRvZgMBnN4qXiCim5b2QMKSzwW+OWCo6NY2cb76NAxgJurpmYG+P+k7GJSWomsfmc/Pd0laNltxAi+uIQi6g3btxo4kRJ+fTTT01uisI6C7FLktMikyZNMg0whxrXVLDQaebMmea+9957zwhqLIhiIQCLERYtWmSENxYpcRQv13eWZbcQIvrgGof7MbqLFAeLqynmF4YFQ4WbgS3974EHHjDuJ9T0+O/ZSMw8Fx173333XdSsWRMTJkxAjx49sHbt2qD/faLsyKLfRlA8L1xVnJWVZQQqik0F4UyzpKQks0AhdevW/c/j1atXz3zdsGGDqfwJFiwGeOedd4w4RpiE5jgAWhdddtllJplDhg4divbt25vqRSanhRD2h93uBecjUjwn7MJnR4VFxYoV8fTTT5vvi4tDTNAwqdKkSZNDPi+7PGjdyApFbsh+/PFHU73MBLX1PMGEixeKa7ThJrRrO+2008zsW3ahWY4o3FgxxvF4JPQL4QxYfbx9+/b8n61Zi9ywsKDHonnz5kZQjxQU/pnItmInN0yMe0xY0yWpQYMG5n7OjmQ3HAugWrVqFbHjFUKUnMIW+UzqEu6JCna2MlF74YUXBu2lTUxMRKNGjcxaiglkrqEY55ho5hon2PBxuTesUKGC+dmaD0lbSYprXC8S/s3sJKE1bqVKlYJ+HEKI4MLCoHvvvfeA+2bPno1du3b9J74xD1SUjTXdP7jvGjJkSKnEtZLCPSrjjeV+QrcArps4roTzuq0OOBYvcY3IphQhhP2hS9Dzzz9/wH3cO7G5rHAcYhNa7969D/lYbPJgoRFjQ0ng/oxrGOawKKpdcMEFZm9GcYt7yFA0zXz99dfme+bA2rRpg8svv9zkyKyGlVtuucV079JZl8chhLA/XP8wt1MQxiLm2gvHMQrpzZo1O+A+7p8Ygyi0s9GWe0nmtYINc/bUGa3iJMYfxryzzjoLAwYMMMI/ufLKK1G/fn0888wz/3HLFZFDAr+NYHcXq2gKw+q8whV67G7lhceFDYmPj//Pv7Oqoy2BLliwq9US9wkXHBTxmLiyxH3Srl07k2DiRlAI4Qy4eaCYXZjCGwhaA1nCezDiEIuWmjZtmv8zhSwubriY6d69u1lUBBMK+Ja4T9hxRmjTX3DcyaBBg8xXxjEJ/EI4AxbwHMw2rPC8RQprkRT4mQwvWBjFOEQ7NN5nifvW/RTNaDkrgV8IZ3CwPR1hJ1ZB2PUeTIGfbkYF11MUs44++mizjmKHfsFRSsGAQpkl7hOrg5/x1RL3rftfeukls18suM4SQtgTOqsdKo4Vvp/rlkMJ/Gw2ocsHu085kigUMIYWHG3CeMN9JBPgBe1teT+FM45BKljwKYSwJxTBShqHWFh4KIGf4jnHnlE4KzyG9mAwx02nx4LrGxYosmt15MiRIZl9XdCtjfGMjiMsSuDaycLr9ZoCJjoLCCGcAZ04DhbHWEjJIqaCsJCosMDP/A/3VByJRhcPFjUyDhXMZwcD5vWvueaa/J+5bmNMZSMynZIsWKjNMeHS+uyFBH4bwQuUC4mCcBHCSmd+uBfEqny2FhwHE88sa/yCyZVgwNlFhWHXGYX/g93PKiAhhDOgBVnBDi/OXWWC5KqrrjJOHRYsMLIIRhwqmIy2YFKGVYG0Ugy2wF84jjGm8m8qfD8LFLiAURwTwjmwq4GJaQuK/SxIYkwpaNl4KBvZcFE43nDNVNT9ikNCOAda4xeEdqu0X2Wilglai2C6rB1sPcW1DYsmuZ9kZ1iwXdUUx4RwJ3QPKhzHaPXKGdGPPvroAfcfqmiHbkosluZ+kh32hZPWkYxDEviFsD904SgchzgKlsWRFNwLwsLCg0E33BNOOAGVK1c2TSsUrYrDihUF4XrtvPPOM86W3Fu2aNECkYpjdFJhYwpHvAkh7A0LrQvHMbrG0h2kcJ77YO4gdJq1uOuuu8yai47ZK1asOGiTXVlh427BoiYr3nA9WNh9jfdb7nTCHkjgtxGsOOStILTg6du3739sOyysTRIrowtj3VecfRADQuEZZ4QbsUNZPxaGiapD3e/z+Yp8fiGEfTjppJMO+JnW1hT4OePnUJ0ZVow5VBxibLBGhpQGJqU5+6eg1fbBsBY1h4pjBxsdoDgmhHspbL1KKzMK/CNGjDC2hqHgUHGIyRfL5aS4OGSJfoe6X+spIZxD4b0br2sK/BxnVrCjNBw0btzYfC3reupQe0KiOCaEO6EYVjiOcSwbu80OlZsqCAUodpqyA5fdZkceeWSJnldxSAhhQUfYwvGGdtc7d+4sURyiED9w4EAzJoijQmh7H6z1VFECf2lz7GVdT0ngF8IZhUq8FR7VyJHWJYljBaEAf8YZZ5iGFhYvcdTsoZDWF1382z4gHAkrj2nLQXv/wkydOtUsOqxFyKGgDSytPgrCxULBOdxCCHEounTpYhw8KKIVxO/3m/uOOuqoA2wTSwo3bpwzxMrG4hJQrCgsHMc4e/ZgRQdCCBFsLEv9wnGIlmwS5oUQkYRxiBS3njpUHJs/f34Ij04I4TbookQ7fFpcjx8//j9ulEWhOCSECAbr1q0zsYfF1hT3KaaFcz3FXFZ2dvYB92s9JYQoLykpKeZr4W77g8Whwns6xSH3IoHfBXCOGCupP/vss/z7fv75Z/z222/m/xUHKxo5U4PV1RbsdCuLICeEiD7YiXbttdfiu+++O2AOD+fMbt68+T9xiLZmrFTMysrK7wZhJXZBaPd/5ZVXmu8vv/zyYo+Bm7cvv/wyvyqaxQW0465WrVpQ/kYhhCgK2v1zzNLYsWNNIomwc3/MmDFBtU4TQggL2u1zz2YxY8YMrFmz5oAXiPu7e++919grnn766UW+eCwar1GjBt599938+3bv3m2cB4QQoiTQOpt22EuXLjWW/sw1lQYWhnNvWTAOrV279oD5r0IIURTMQTE/xJwSxf3C3bMFYRcsc1O077fgSCPGsoJwzAhHR3LkUf369Yt8fsY9Fnh/8MEH+ff9+eef/2mIEUKIQ/Hpp5/m55UsFi5ciHfeeQeHHXZYsWNCGIe4fpo2bVr+fVxLsfhJuA9Z9LuAc845x3Tb8+uHH35oNkQU2ii4lcTu47bbbjMXea9evfIDAK24e/fujXnz5oXlbxBCOJt77rnHdGkMGDAAp5xyiqkqnDRpkkk8c/ZiQb7//nsTo/j/OOOe1mKcQXTVVVeZymrajjFJnZ6ebhYvJUkMPfbYYyYhRDeBfv36maQSCwvoZCKEECXh888/NwWSVuERN1TWOqp///7/mZFWmOeee87Ev+7duxu7NK7NKPCPGzdOb4AQokS8+uqr+fsvFkIWtMMePny4sby2eO2110yChyPdCGMWE88VK1Y0M1spzrOAsmnTpvjiiy+KnTnNTpCnnnoKl156KQ4//HDToca1HddrtNgWQojiuOGGGzBz5kxTMMT1T+E10H333VekOMZ4deeddxr7WQpidGmjHTZHxg0bNkxvgBCiWLhnW716tckPvfjii//5/7zPGpfEPR/XUw0bNjRjKQn/7Y033mhGUbILllb/zE9x7jXzU8XBnBhHxrFRhYVOFPsDgYB5TKuJRQghiuL333/HXXfdhdatW5tCbRZtU6xnfrxgEeShOP/88028Ovnkk01so8MtHb7PPvtskz8X7sIT4KeMsC1vvvmmEdo7depU7O+yY4OLDr6lffr0QatWrUr8POwy++mnn8wFz+dr166dSXLTVqjgLFtWEHGTZS18LLhxS05O/s/8biaT2Ll2qNndQgh7w6pnLh54bRc37sOyLZs7d6657jlr0bJZLAiro1k1eMkllxwwh5YbKSa1aevI5+rbty+SkpJKfKx79+7FxIkTTTzjZo4z2w4Wm6x5R3z8wvGWc9mOOOKIA+5/++23TaK8pLMjhRD2YuvWraaQceTIkUUKXExIH6qwkZ0fJYkBfC52irBQicVN7IYtHFvS0tLw/vvvm8cr2FFixVsWKRVc9zGmcXNGwY1FTEII57Fs2TLjmMZkL2fBHooff/zxP134FoVjAJ2S6B7ChLMF94Fch7Ejjd9zT8eio6KeszBcj7HLjIUCxx9/vIlnhWMTu+OYtGbSiOutwvG28LqRAh33hezspYAnhHAedGpbvny5SQ6XJYaRESNGlMhhbcGCBSaWManN9dSuXbv+E1sY51jERDGPI9sKx9vC674VK1aYAvSSHoMQwn5Y+Z6icszMW7PI8VCwkNFyrKWFNUeJMA/O9ZIFm01mzZpl4hnXQ2yIK+36hfl5xiP+O4r+jJ+FY9Mff/yBv/766z/NeYy3c+bM+c+6kYVPvBX8G4QQzoJ7olq1ahWbX2KOm7GAo2e5zmGMYuFRSaGzLXNT/PfMOzHOHSy2HEz/s+Itx+YWXvfxMbkXZKOxsAcS+IUQQgghhBBCCCGEEEIIIYQQQggH4I30AQghhBBCCCGEEEIIIYQQQgghhBCieCTwCyGEEEIIIYQQQgghhBBCCCGEEA5AAr8QQgghhBBCCCGEEEIIIYQQQgjhACTwCyGEEEIIIYQQQgghhBBCCCGEEA5AAr8QQgghhBBCCCGEEEIIIYQQQgjhACTwCyGEEEIIIYQQQgghhBBCCCGEEA5AAr8QQgghhBBCCCGEEEIIIYQQQgjhACTwCyGEEEIIIYQQQgghhBBCCCGEEA5AAr8QQgghhBBCCCGEEEIIIYQQQgjhACTwCyGEEEIIIYQQQgghhBBCCCGEEA5AAr8QQgghhBBCCCGEEEIIIYQQQgjhACTwCyGEEEIIIYQQQgghhBBCCCGEEA5AAr8QQgghhBBCCCGEEEIIIYQQQgjhACTwCyGEEEIIIYQQQgghhBBCCCGEEA5AAr8QQgghhBBCCCGEEEIIIYQQQgjhACTwCyGEEEIIIYQQQgghhBBCCCGEEA4gNtIHIIJHIBBAeno69uzZk3/bu3fvQX/ev38/kpOTUbVqVVSrVi3/drCfK1euDK9XtSBCiODEqZSUlEPGpoI/p6amomLFikXGJ+t7/p7H49FbJIQoN36/36yTiltL8ZaRkWHWScWtpfiV6y7FKSFEMPD5fNi3b1+Raynrvuzs7Pw4VNzeLzExUW+QECIo5OTk5Mel4vZ+3CMWjEdFxar4+Hi9Q0KIoMA1UknWUvwaExNTorUUf46NldwihAgOzDmVZC3FvSHXSIeKTQXvq1Kliolpwh3oE8eByZxly5Zhzpw5mDt3Lv766y9s2bIl/8LmJirYUNznhc8AUKNGDXTq1Ak9evQwt86dOyMpKSnozymEcPYmafHixSZO8TZ//nzs2LEjP04xjgUbLkyshUrt2rXRpUuX/DjVoUMHxMXFBf05hRDO3iQxNllxatGiRdi5c6eJUbwx0RxsGIesTVX9+vXRrVu3/DjVunVrFVMKIQ6AhUbc61lxaunSpdi9e3d+sXYoSEhIyE8ANWrUCN27d8+PU02bNlWRkhDiALh2smIUbytXrsxPNLNYOxSwYNJaTzVv3vyAOMX1lRBCWHBPt3nz5gPi1Nq1aw8o1g4FBRtVWrVqlR+jeGNeXQghCsapNWvW5Mco6n0bN27Mj1NZWVkhebGo9XEtxZjUrl27/BjFPFWlSpX0BjkITyAUGUwRFCiC/f333wcsRObNm4e0tLQi/x0rBYur1GG3mVUBVFT1T2ZmZrGiGsWzgosVCmsS/YWIHjGfwljBOLVgwQJzf1EUrCo8VLzipojd/sVVUhf3XExWsxipYJxi3FL3hxDRAd2NuH6yNkv8umTJkmKLjbiWKWotxRt/p2C3/6HiVXHPxXjHjVTBJHWbNm1UVS1ElMCOCys+WbcVK1YU++8qVKhQbJcG1ztW8dKh1lL8SveSoqhevfoBMYq3Zs2aSfQXIkpgwXbBGMXb+vXri/13TBIXtZbijQ5HBWPUweIV42Rx1K1b94AYZYn+clASwv1Q3ti0adN/4tS2bduK/HeMD1ZTW1F7P+7nilpL8cb8VXE0adLkP3GqZs2aQXwlhBB2jlOrVq06IEZxD8g4UlzzbUncQ1gMUJwjSXG6ImMiG1AKxijmqqglCnsigd8mcKHArozCYj6T0gerWC7Y9cVuioIXNRM9wdrAUOAvGBC2bt16QCfJ9u3bDyr6t2/fPv/4mAji8Ur0F8LZUEhfuHDhAXGKPx9MYGdMKhgDGjRocMCig/EgGHGKi6OCxUqMVxs2bMhPkvPrwZJBTHYXFv3pTqJOfyGcDddNBdcpVtfrwYSrOnXqHLBhYVK44HqKxUHBgHGKm6iCGyt2jhS33uN6rmvXrgfEKVZWa2ySEM6G65LCyWd2vR6Mxo0bH1BEXatWrfy1lCXeBwPGyMJFlSwwKFi8eTCnOB5DQdG/Z8+epqNWYpoQzhfz//zzzwPiFPdYB8NKAjMWdOzY0XSCWWspimbBsqpmzqxgUSUdTQrm0Eqy3rPiFPemQghnw5hUME4x91OSHHXbtm1N0WLBBrhgWVXn5uYeUFRJl5OCDTElWe9ZcUqivxDOhnkgXvOFxfyS5Khbtmz5nwa4gnmg3bsB1i7RLMm6Ube3vk9JCSA1DdjPr6l0sKSeyBwTUCE5B7Exe+H10rlyD3Jzd2Dr1vlYs4YxikVRB1/vFXYj4U2ivz2QwB9BuPmYMWMGPvnkE4wbN86I54fq6CoolNmlo6s01ZEU8wYPHowRI0bgpJNOktgvhENgMnfixIkmTn311VcHXYhwsVH4Q94uHV1WdWThrriDVUfy7zjttNNw5pln4phjjpHYL4RDoDj+3XffmTjFrwdzH7JzR9fBHJtYpHAw0b9evXo444wzzHrqsMMOk9gvhENgkvfLL780cWrSpEkHdfVg0XbBPZ+dOrpK49jEhBTXUoxTLJ60Q5wVQhQPbayZl2KcYp7KaR1dLKZkXCoYpw7l2MQCSsYoxioWJQkhnAHFMsaoTz/91FzvJXGZpWjGRjk7wDyUVYxu5aiWL19+0N894ogjTJwaPny42csKIewPc9AcBWnFqdWrV//nd9hIwsLtgkXSh3KZpe86xXzWBuXdAli2IoCduwNgTaMfAfM7sXEBJFUIICEpgMTkABKS/eBEbd7HW3xCANmZHqSneZDBW7oHWRkeZKbn3fizP9cDbttys3YgNXUu/Ll/ITtrLnbsmIOdO//r2MQCzkGDBpk4deqpp5qiThEZJPBH4EL/448/zIX+2WefGYG8oJhf2PaQ1TF2EPPLM9+It4LFC/w7hwwZYgLA8ccfH7QOOSEEglZ1PGXKFBOnvvjiC9MdYcFK58IimdNmshaeb2TdmHy3YOfJsGHDTJw66qijHBWHhYgGKOJPmDDBxKnx48cfIIZTBGfXQ8E4xfucBJPRy5YtO6A4id8XtFPjfGxLROPf66Q4LEQ0wE7Tr7/+2sSpn3766YAOeBZCFoxR3AM6bSYrxf3FixcfkKRmQqvgnEh2yTFG8UYHEiGEvWC3K0V9JqGnTZtm9kmEawo2lhQW8502k5Xrw8KiP+NWQdG/V69eZj3FG7tohRD2gs5njFFcT3G9YcEcDV1DCov5TnOP5XqxsAMd94EW7NplToprqdNPP924OQkh7AULoa04VbBoh5pXYVdGOooczD2WS7Bdu4BVq/LE/BUr8sT8XXsCyPUHkFTRj7qNfWjQhDc/atXzIzk5T8CPK6epG587NwdG/GcRwLbNXmxax1sMtq6LReq+XUhLoeg/DznZeaL/jh1r8/89ixOo8TFOUfNz2nrR6UjgDwPcJHERYlXvrFu3Lv//sdqZHaO8AI499lhXdoxaf78V6Ar//azysf5+zcQWIjIwyTF9+nRzjX7++efGlrGgrSGrhnmd9uvXz5Udo/z7f/3113xHlWj7+4VwiphEkYzXKUWzgjMOKZZZIhKrod0odhf391tiPzeQbvz7hXACqamppuiI+x4WIRUUu9nNbnWMsojbrX//t99+a+LUwf5+K0659e8Xwgns2rXLFHHzOp08efIBtvZ9+/bN7xil05Fb/37LUeWXX3454O8//PDDzd9PtyS3/v1COIGNGzeapjhep2ySKyjqDxw40FynzKXThTHa/n66TVp/PxtwhBCRgYU4vEZ5o2OQRWJiIk4++WSz7+FXjl4sSlinoD99OjBlmh9bth0o5jds6kODpvzqR5VqAdNhH254jHt2erBxbQw2rs0T/betj8XuHcuxc9s47N75GfbsWXzA30/3bsap4v5+ERwk8IdQ1OZsautCp0W0RTR3sPN1mTVrVn6xQ0EHAy7MWI3I1+Xoo48O2qw2IcTBYTLj999/zxe1t2zZkv//aAlrdbD3798/qjrYi3IwYKKnoD22RDQhQgs7XmlnzTUDk7EFx2tEcwc7HQx++OEHE6e++eabAxwMKJxZxQ7sahFChBZef99//33+mJAMDjn8h2juYC/KwYCdwFaxAwuUhBChhesnjlvj9cjxa9zvFOxgt0TtaOtgp4MBi9v5uhR2MDjyyCPN68I9MQu+hRChhc6vlqj922+/5d8f7R3sdDCwXhd291uwQdCyxx46dKjssYUIA7Tct7Q+OpdZsGH1hBNOMNfjKaecUmQHO5ca7H01ov5UP9ZvCiAu2Yf23XPQpnOu6c6PlJhfUvg37N3lwYY1Mfh7QQz+nLoCm9fnif379v3rYMDxKHw9+Lrw9XGaw4pTkMAfZDif+pVXXsG7775r5qla8ATmCc0khmbQ/ysucrabJS4WtPGnuMiL/6abbtJMNCGCDK+15557Dh9++KGpDLaoWrXqAUU2bnQUKau4yDhFcZEx3oIJsHPOOQfXX389ateuHdHjFMJtrFixAqNHjzbJDHZaFS6y4XpKM+j/FRcpKlriIsV/C9q/XXDBBbjiiitkkyZEkGGSlXGKInbB8RmcQV+wyCaaio8OBccgFRQXC9pj9+7dG5dccgnOP/98ubkJEUQoVvN6e+GFF0xRYOEiG8uWXjPo8+CoSealGKeYpyooLnJvfOWVV5qOWbm5CRE8uB7gdffqq69i6tSpBxTZWDPoWWSjGfR5rFy5Mt8dl+NHCoqLJ554Iq677joTr7T2FCJ40JHs7bffxptvvok///zzoDPoWWTDnHpRbNgATJsGTJ0WwJr1fsQm+tG2Wza69MlFi7Y+OLmvjnWjKxbFYN4fsfhz+hJspdi/axz271+d/zsseqCLN7U+uk6K4CGBP4gV0c8//zyeffbZ/O4yduZblhSDBw+WJUUJ7cG5uNu5c6e5n13D5557Lu666y5ZOQoRhKTFk08+iddeey1fALI+YBmnuDDRmIyiF3UF7bFpQ2sVcDHhc+utt2rjKUQQbM4effRRU4BkWaaygMYak8FEjxKrh4a2/bQHZ5xiMp+2/oT2jdxIXXPNNeruEKKc0I3soYceMgU1Fk2bNs13FKFwpsTqoeE+z7IHp2OSFevpynLnnXfioosuiiqHOyGCDQWyH3/80cQpurVZsODIcs5o3bq1Xvgi2LBhQ37HLGN+wdfw3nvvNYJjNDncCRGKHDCvr0ceeQRLly7Nv58F3JajSIMGDWz9wrMWgWk1Gqlx2UIX6nDWdLKp0OokLvgacr983333mTG4Wo8KUXaYN3/jjTfwv//9L9+BuuCYDObSa9SoUeRjUN6aNIn2+wGsXO1HTLwfrbtmo0vvXLTq4IMbzatzsoFlC2Mx748YzJm+ENs2fYbdO8chJWV9/u/Q2ZxxqkePHhE9Vrcggb+c0LqZnbBjxowxNoSWFePtt99uOmE5Y16UDtrFcRYaiyWYnCZM5p999tm4++670aZNG72kQpQCdulzQcKFiTULlRsnCtIsQuJ8HFE6aL/LxD4LJmbPnm3u4+t4+eWX47bbbtPMRiFKCWeWMcHz8ccf53ducF7XDTfcgAEDBmhsTxmg4wiLJhmnli/Ps0ljVfmNN95oujuKqzAXQhwIhbIHH3zQCGcF9ydXX3216UJXErX0bNu2zRR0Pf300/mjopjQv+OOO0xXv9aoQpQcrp+4P6GwX3B/ctlll5k9Cl19ROlZs2YN3nrrLeOEYLm5ceTKPffcYxL8EvqFKF2+d+zYsaagu+D+hK6IF154IZo0aRLRl5Pb0B072CkPcFnCng7eaNSUkhLA/hQgJTWAlBQgNY3OtAHzb+ABYjweJFcAKlXkzYOK5iubavK+ZwEApwu0aAE0bMh1ZLCOOYDFixcbF4SCOb/DDz/cCGgcDaw1qhClc0h8/fXXTR6l4P7klltuMXu/kowJ2b4d+PTTACb8FEAOfGjVOQdd++SgdQcf4uKj593IygT+XhCL+bO8mDP9L2xe/wq2bPoEgYA/P+fHOMW9tCg7EvjL0XlAAZqLfHZLkQ4dOpiTUtW8oeuQ4aJk5MiRZjOlDaoQRbNu3Toj7DMhYXVxspr3/vvvx8CBA7XID2KHDBP+M2fONPex64xJaSanG3LnJoQ4JAsXLjTCPrukLGGf9mbsjlI1b3A7ZB5++OH88VEsQGUijQUU7O4XQhwauoxxP0Kra0Ix57zzzjMOY7TjF6HpkKlXr54pmqQ4yfmNQoiDw/XTN998Y+LU3Llz8x3GrrrqKpOMlrV16Fw76YTA3NSoUaNUjCpEEXBEyAcffGCE/VWrVpn7uAe5+eabjcNYJJrjuPWkCEcxn7flKwJYvjKAvfsC8AUCSEgMILFCAAlJASQm+5GYHEBShQCSkvgV5vvk5Lzfy872ICPNg4wM5H3lLd2DzPyb13zl/bFeD5ITPWjV0oPWrTxG8Odykqmj8hqDHMy1s1evXkaroJAmoV+IQ8ORayyUeeqpp0wRsjWalQ5jLEAqicMY6wEo7P84MQBPQi76HpeFvkfnIEGj55GeBvz2czwmfrkWa5Y/gc2bxuYL/SxEolbBwiRReiTwl5IdO3aYDoOXXnopf9Zi586dzYel5nGFdsYlE9O0xSZclNCyiZupTp06hfCZhXBml8Fjjz2Gd955x1RIE3bAMk7xqxb1oUmsTZo0yQj9v/76q7mP4w5oM0uhP9KV6ELYjfnz55tENG2aLeh8RGFf87hCJ/R//vnn5nVnl4c1puXaa681Xf01a9YM0TML4czPdc6C5ec6beStOYsXXHCBSfJoZnVoZ1w+/vjjWL8+z8axTp06xnXqiiuu0Mg7IQrA8RZfffWV+VznuopUqFDBuIpQNOOIIxF86Nz54osv4plnnjGOnqRFixbGbfKcc85BXFycXnYh/oGNJu+++67JT61du9bcxz0Hi49YhMS9SLhgz8tffwF0szdi/ooA9qXkifkVq/hRt0kuGjbxo0ETHxo09aNy1bzi82CSkQ5sXheDjWu92LguBtvWx2DXthgj+icl/Cv6c4pKz57cq5XtebZu3Wq0i5dfftm4T5Lu3bubnCCtsZUTFOJfOH6V1wqvGep+1vg1FnOff/75JRplu3kz8MknAfw0yQ9vkg9HHp+FPgNykCDD3IPGwd8mUujfgDXLnsTmTe/D7/eZ/8fRIoxTRx55pE7RUiCBv4SwcocVPK+88oqx6iCcr2h9OGoebHiYN2+eEfoLCgJ0TKAg0KVLlzAdhRD2ZOXKlWbj9N577xkhh7BTn3Gqf//+kT68qBEEKAQw0VZYEODisFmzZpE+RCEiCjvLeH2oYC+ygsCXX35p3ocFCxbkCwLsnqEgUBLLOSHcXrDH64Od+4RiDQv2KOyrYC9yggBjkyUIVKTXrRBR/DnOgj3mReiERFSwF37o5GkJAnT4JNzrcc9Hl5eSCAJCRFPBHouOWLB35ZVXhq1gj/0uFPWnTQvg198D2J/qR8WqftRplIuGTf1o0NRnvlaqEnwxv6RkZhQQ/dfGYMv6GOzZEYPEWC969/Cgf38P+vTJs/gvLdu3bzfFSAWbFJk7Z46Q88OlZYhoL9jjtcFrZNeuXWUq2Nu4MU/Y//kXP+Iq+HDECVk4bEBOVNnwlyf2/f5LHH76YhPW/P00Nm18F37/v02K7Og/6qijVJBUAiTwF8OePXtMgocWHZa9Tc+ePc1JJnsb+1n6Mgkk634RbXDDxCIXzjC1hH3a2/C+fv36RfrwopZp06aZzw8KBQUtfZmM4/wmIaLtc5sJz2+//faAkTvcPHHEkYiMQGBZ+v7FzBdgbLCZdOPnR5UqVfS2iKiCHfuMUzNmzDA/U5y59NJLcfvtt6NRo0aRPryo5GCWvjVq1DDFSDfddFOJrDKFcAvMe7DRgcLMkiVLzH0auRN5KJqxEYgNQRTTLEtfuk1efPHFEtBEVMF81P/93/+Zz+2NVL4AMyaEa6lwjdyhqE9Tk+nTA5g+I4C9+wOoVjcXnXvloHPvHNSuFzkxv6Ts3+vBwj9jsWB2HDatikVSvBeH9coT+zmqOimp/GOGO3bsaPLqzKULEU1Q32Nx3ujRo43uR1q1amU+t88666wSjdzZsAH46KMAJk31I6GSD/1PzEKvIyXsl4WsTOD3yXGY+MVWrFzyNDZvehs+X475f+zkZ6GYtI2ikcBfBExCcwGyhQM0APTp08cI+yeccIKqR2wCLWa5cPz444/NhpeJOFppsrujJAFZCCfDc57zSpnktBbpJ510kkn6MF4Je/Dbb78ZUf/HH380P1M0e+6554zVk6zRRDSIM5ypzGuA37NL4OyzzzYiWtu2bSN9eOKfz5LvvvvOrJ/+/PNP85o0bNjQfL6wWEyIaLBlZOKZnZgkMTHR7AE5/10FefaAI6fGjh1rEtErVqzIT0xzHFWPHj0ifXhChMVRku4VlpNh1apVzXid6667znwvIg+dPl9//XU88cQTxh6bsPPsrbfe0lgXERXw85lzqpn/IPXr1zfjCi+55BIklVaRLiXsc1m0KK9Tf/pvAezaG0CVWrno1CsHXXrnom7DvDnPTmTvbg8Wzs4T+7esjUWFRC8O750n9vfqBZSm1pFjRZiLGjNmjOleJmeeeabpYta4NhEN/PHHH8Zh9e+//zY/MyfF5oYRI0aYpqySFBB9/jnw3od+xFbIQf+TstHriBzEajpPUIT+P6bE4acvt2PN0tHYuOEN5OZmm7w5x0qyqTdc7i9OQwL/QWD1zg033GBsrkmbNm3w/PPPY9CgQRJjbAoDM0V9JqhJ7969jR2UuvmFW9mwYYPpKrNE48MPP9zEKTqMCPsuJJmEmzVrlvmZLjCvvfaaxAPh6q59bp5oy0/YHcDuJlZHC3sK/T/88IOJUxz5Qth5Rss6dfMLt8JxOrTfX7NmjfmZwv4DDzyAevXqRfrQxCE6Ayn0c9/HTlkm4igeMDGnbn7h1s/mTz/9FFdffbWxj2UTA895XgNu/Gxm4pwu0qmpeTd+T4dcTuXgjXld6oQeD2wL513TAZRxid39TEZT9KdDkuywhVtdwZiLYgE3z3+O0WEjFtdULJoMJTk5wM8/Ax994seWbQFUrJGLjj3zRP36jf22jhVlYc9OD+bPjsXCWXHYtiEWVSt5cdoQL049laNaSv44e/fuxZNPPmluXFtxDBKdSDgCVwi3du2zaZed+4xZdBZhBz8LXEoi7JN164BnRgewaLkP/Y7PxKCh2RL2QyT0TxiXgN9+2ImU3Q9i4cK388cnUOtjV784EAn8haBAzEXI5s2bjZjPzlhal4a62lAEZ/P7/vvv4/rrrzeLFSZ52I3G91Dd/MJN5zm7AGhLyopbbpi4eeJ5X9JFiYhsBxrFMroscL4sO25YQU3rfnXzCzed50xk8jOYXfvVq1c3doCjRo3See6QDjQm6Jio42cOu/nffPNNHHfccZE+NCGC2rVPkYwdS6RJkybmPB84cKBeZQdAq9lrrrkGn3zySX43/7vvvovu3btH+tCECBosYqEobHXtd+3a1bhWcH6yE+Fkxc2bAdYQ8rZ5cwApqcD+lIAR82lIl5kFBPhfIO/3+T3gMSIddTqvh2PPPKiQnCdmVaroQaWKQPXqHjRrxuRv3s0ODV6rV682hZIsJLPmyXIf34wHKoRLYFEwu/Z//fVX8/Oxxx5rXMC4rgol2dkAe10++cyPLTv8aNcjG0ccl41Gzdwn6h+Knds8mDk5Dn9OTUByfEy+0F+a2q85c+aYgvxFtD8ATBfziy++qG5+4SrYZMXzfOnSpebnc845x7hYME9VUocQdu2/+4EfSdVzcMbFGSbWiNCyamkMPn87EdvW/oKVKy7Dzp0bTT6R+gd1kHCMfHEKEvj/gYIwLc64YSKtW7c237MrVjiLTZs24fLLL8/v5qdVOd9LWQELp8MZZuzaZ4clYXxi9RpdRoSz4NxMLjBnz55tfh48eLDp5qeNnRBOhskBnttMFlhd++xiYoW0cBbTp083CTtr7jXtNVmgxHm/QjiZqVOnmnPb6trnvoHuIpVK0/okbMHnn39uBNAdO3aYQtc777zTdM1ybJsQToZd+7Tkt7r2OReWxXdxbGd3ABTnN236V8xfsTKA5SsDSE0LwBcIoEoNP2rUzUUyO/IrBJCYHEBycsB8b25J/96fmwNkpHuQkfbPLYNfYb5PT/cgM92DlL1ebN8YA1+OF7FeoEF9D9q08qBVKw9atoyc6M8uQY5/4RgYFlCym58ds1dccYW6+YWj4bnNAm5+7lpd++yMZcNcKBsXsrIApsMo7G/d5UfH3lkYODgbteqxGCg6Sd3vwbQf4zBrcgKSYmIwZLAHw4Z5UNLpLVlZWWacHsfqsZu/du3appv/9NNPD/WhCxFSeG7TmY2fu1bXPvOuQ4YMKfFjrF8PjH42gAV/+9D3uLyu/ThtM8Lazf/9Zwn4Y2Im9u68DQsXvGXupyso9ZB+/fqF72BsjAR+ABMmTDCiGYVhLkTYGcsPN3XtOxd2nLGLg6MW9u3bZ7r5+Z7yvVWXs3Di+cwPLhYhsWuf5zNnkPJnnc/O7nLmJpg2UVY3PztmWU2qbn7hxPOZGyd27fN8rlatmkn6nHXWWTqfHQytZa1uftKoUSPT5cyxVUI48Xxm1z47k0jjxo3N+cxuM+FcKO6zm5+CKOnUqZMp7lY3v3Bq1z7t+MeNG2d+Zrc+z2d279udffsAjt6e/msAS5cFkJaeJ+ZXreFH3Sa5aNDEhwZN/eZrhYrBf36/H9i+xYtNa73YuDYGm9bFYPuGA0X/nt3z5lZ36BBem38WS3IczLRp08zPRx99tOnmb9q0afgOQogQnc90P2LXfijP50xaNk/IE/Z37PGj02FZOGZwNmrWiV5hvzBpqcCvP8Xjj0kJiPfE4JST84T+EjYp488//zSF+osXLzY/jxw50qyZa9SoEdoDFyIEsJmK5zObq8jZZ59tchql6dqngdI77+d17Q+/KAONm6trP1KszO/mn4iVyy/Hrl15Gi51v0ceeSTqu/mjWuBn1z4FXwpnVtc+v+/bt2+kD00ECRZtsHiDRRzksMMOM++xuvmFk7r2WQWtc9i9cAPFhSc3VOSUU04xVaWa/yuceg6zIppd+zqH3QMTeOx4pt0s4ecSO57VzS+cgs5h90NBlN38tO9nxzOLk+6++2518wvH8Nlnn5mufesc5vnL89jOjhS01Z8xA5g6LYC58/zIDQTQpE0OmrfLRcN/xHx26UcKiv47tlLw92LD6hj8PS8O6ftiUKemBwP6e8ExrjTDC4fYz+5BjoVhoZnVzc+1FF1kvF5v6A9AiBCcw2xY4DkcqgYFWvF/8w3w2ed+7NrnR+e+WTjm5GxUrxW1UkaxpKf9K/THBmIw+CQPRo70lMi6nx3PHFPMcXtWNz/39aeddlo4Dl2IcsNzmE0nbD7hOVynTh1zDp/K+RWl7Npf+LcPh6tr317d/J8mYOakDOzbcSsWLnwnv5v/nXfeiWo9N2oFflpc02rU6tpnJywrPtS17z54ivNCZ1WPup+F085bxia5UERP9zPtoziznN3PrC5llam6+YWdz1smJnneWl37Om/d3f1MG046MxB1PwsnIBeK6OvmZ/czhVKndT+L6KXwedu5c2dz3nbr1g12JC0NmDmThVMBzJ4bQGaO34j6nXvlomPPnJB05wcLZj/XrfRi/qw4LJkTh4yUGNSv86/YTzv/UIv97H5m0SRHIVndz3STCfXMciHKA4t82bXPMUfkmGOOMedtKLv2ly0Dnnk2gDUbfOjSNwtHn5yNajWjUsIoExnpwG8T4/H7zwmolBCDa6/24ogjShbjWLh//vnn53c/05WP+3x18ws7U9iFYtSoUSZ3UZrzdtIkYPQYP5Kq5WDYRRlo0kJd+3bt5t++7mfTzb9z5+ao13ajTuBnAvr666831TtEMxuid345K3vY6aEOQ2E3KOife+65GD9+vPm5T58+xnmiXbt2kT40Eeb55ayU5rgRzQUWdvxMHTZsGGbNmmV+lvNE9DBlyhST4LPml1977bUYPXq06TYUwk4sWLDAzA+lmEK4D2CnmZwn3A/t+imYWp3Qjz76KG699VYVTQrbMXHiRCOcUOTn6DV27N9zzz227NpfupROGQHMnB1ARo4fjVrkoFPvXHTqkYtKVZyXVmR3/9rlMZg/KxZL5sYhOy0Gjep7cOIJXpx8MpCcHMrn9hvra3ZCW/PLX3/9dSNGCGE33nvvPeOQY3XtszHhiiuuCJnzBLv2P/wwgI/H+VGjQQ6GX5yJug0kspWV1P0efPVBApb/lYBjjvTi6qtL3s3PTmh28zNmsRP6448/xoABA8p8LEKEAkqbjz32mBl/WlbnCaqjH38cwFvv+dHx8Eycek4W4uy3FBP/kJUBfPpWIpbNyYDXfwsmTXon3539iy++QAfOYooiokrgZ/c2k9HcRGlOQ3RSeJY5u89ofd6+fftIH5oQ+aLZSSedhIULFyIhIcHYY3GUiIST6IEd/NYsc37P7p3vvvtOxUjCVqIZ4xRdkKpWrWqq+c855xwJJ1FEamqq6ea3ZpmfeOKJRlBjgloIO/Dzzz+bfV9KSgoaNWpkZsMed9xxiDa40+fc2tTUA2/swOXXmBigQgWAl651s36mvhjOGdWhmGVOu/PPP/88f7QIrYW1phZ2gV36LDyiI1KnTp3Mz927d4fdWLQIGPsRu/X9qFY3Bz3756Bzz1xUruaeVCJn7a5eFoN5M2Ox8I94VKsYg+GnezF4cF5MDBUrV640RZNWNz8FCor+cnATdsmfMifBG6Gw+9Zbb6FZs2Yhe87ly/O69letz8XRQzLR/4Qcs1YR5YfFTOM/TETFuFhcd01eN39pZ5nHxcWZzyoWpglhB5gz5Rqf5yUZOXKk6dqvWbNmiR8jNxd46aUAvpngx4ChGThmcLaj90DRtM/99pN4zJ6UhA6tJ2DcuMuxefNmVKlSBV999VVUFSNFjcDPJDST0UxKs+KQSUj+LKLXXorJ6OXLl0flhS/sL5rVrVvXiLp2TPKI8MDO6MGDB5uOHlo2fv/99ypGErYSzVgcx/NSlqLRy9dff226zdh9xs8rfm7x80sIu4hmXN+zip8jRNwMxakNGygW5d2Wrwhgw8YAUtPYKRqAPwBw08+df4D/BYC4hAACfiA3x2OSWB544DVf84T9uFgPKlcBmjb2oHUrj7GubtEC4CXupKQXC5Ho4MfuM66zP/nkExUjiYjCFByLuDniiFAooWjG4m67wBixcCHw4dgA5s73o3r9HBxzSjY69sh11PVfFvbu9mDqhHjMnR6PyskxGHaqF0OG5BU+hQLGpttvv904zBDOM2fcUjGSiLRoxnORDVKE7iIPP/xwSLv2x44N4OPP/Kiurv2QdvN/+X4CVsxLwMD+Xlx1Vcm6+TMzM41lP7UUomIkYQfYuDl8+HCTo6IL0ssvv2zE/tKQng489ngAM+f4MPSCdPTomxuy4xWh4def4/Djp0no23MvfvnlVMyY8ZtxwuLnV7QUI0WFwM9OWG7m2Rkr0UxY7Nq1C0OHDsVvv0XfhS/sB51FKJpxgUIrfjpLSDQTtBVmMdKKFStMpzSLkY466ii9MCLiohnPwy+//NL1opkonj/++MOMaLCKkfj5pZEyIhJwW8vkM+0Z7SqaBQPu3tevz+tyo5i/YmUAK1cFkJEVgC8QQLXaPtRr7EOdBn4kVwwgKSmApAr/3JIDSK4QQGJyXvc+yc0B0tM8yEj3ICONM1ut7z1ITfFgy3ovtm2IRcpeL2I8HlSu5EHrlnmiPwV/GqGVokkmIqgYSdhVNKMbDkdI2KVjm/Fl/vy8jv2/FuTZYw8cmoX2XX2uF/YLs3+PB1N+iMecqfGolBSD04d6MXQoUKlSaJ6Pov51111nPstUjCTsIppR0H/llVdKLZqVhhUrgKdH53XtHzU4CwNOylbXfhi6+b/5IBGVE2Jx7dUl6+ZnMdJtt92GZ555xvysYiTh9Ebe3buB++4PYOX6XIy6Oh2t2vtCdrwitCyaE4vP/i8JHVrlYt3a8/DVV+PM/Y8//rgporTLOjtUuF7gnzRpkpm9aIlm7DRr2rRppA9L2AR2nJ133nkYNy66LnxhLzhj/ZJLLpFoJg4K58eyGGnGjBmmGIkiq+YzikiKZjz/mJh2m2gmgleMRDGtf//+eklFWEUzzoOloE9ocUzRLFSdZuGGO/Z16wC6OE+d5se6jXlifo26eWJ+gyY+NGjqR4PGPiQkha7ra+NaLzaujcGmtV5sWR+L1L1exHo96NjOi6P6e0yCuEYN2BIVIwm7iWbsNKNAYhfYsf/OuwHMX+xH7UY5GDgkC227RJ+wX5j9ez2Y9kMc/pyagOT4PKH/jDOApBDEWhZzc53NbtkePXrg22+/lTOSCLtodvLJJ2P+/PlITk42ohl/DgV+P/DBBwGM/cSPavVzcMbFmajb0B+S5xJFd/Mfe5QX117rKdFIEtqf0xlJxUjCDo28derUMS6C/MwsDdxX3XOfH/uycnD+9Rmo10ixx+msW+XF+88no36NGMR6b8Nrr4029zNHwLjlZmckVwv87733Hi6++GKJZqLYKsRbb70Vo0dHz4Uv7AHD7yOPPIL77rsvf1YQxVuJZuJgxUjnnntu/hzZ//3vf6Z6WsVIItS4XTQToStGYvEaP9eECIdodsYZZ+Cnn34ysYlz1hm33MDGjXmi/pSpAaxe50dsgh9tumWjc69cNGvtQ0Ji5JPDyxfHYMGsWKxeEodYeNG5oxf9j/SgXz/AbiYvKkYS0SCalZaMDOCttwL46ls/ajXOwbFDs9Cmk4T9g8W7aT/GYdYvCahfMwY33ehF587Bfz9mzpxpnJG4rpIzkoikaMYCk549e4bkubKygKeeCmDybz4MGJKprv1IurbMisX495PQvGEsHnzAUyJXJhUjCTs08rZt29a4B5a2kXfBAuDBR/yIqZiNC2/MQJVqrpVGo46d2zx4+9lkJPjj0KrFi3j00RuM9sI198cff+zaMW2uFPj5JzH5fO+995qfJZqJkvD888/jhhvyLnzOveaFT5sXIUIlml155ZV48803zc90juAcK4lmoqhipFtuuQXPPvus+ZnnD+OWipFEqEhJSTGi2Y8//ug60UyEpxjpiSeeMEWUKkYSoWLz5s0mGW2JZpyvznW8k9m3D/jpJ2Dy1ABWrPLDG+9Hmy456NI7B606+mDXGuSMdGDx3FgsmBWHtX/HItbjRbcuXhw9wIMBA4D4eNgCimZDhgzB77//rmIkERYWLVpkXG7CIZqVFia5Rz/rx+adPhw3PBOHH5MT9R37JUkef/52Irasisepp3hx0UUeJAa52GrlypXmnOFXjsOimCZnJBFKfvnlF5x22mn5ohndb5s1axaydc6DDwWwaHkuRlyejnZdZYsdabZu8uLd55JQOS4ODz/kRUn00oLFSBRYKbTy3BEiVLz//vu46KKLTCMvPxP52VjakZFTpwJPPuNH7eZZOPfqDCSGyPlMRLYg893nk5C6LR79Dv8a999/luudkVwn8FM0u+qqq/DGG2+YnyWaidLAecKc18kLn5tuXvjchAsRStGM8/Yo1gpREsaMGYMbb7xRxUgi5KIZq1znzZvnGtFMhAcVI4lwimYU9zds2IDatWsbe0a7iGZlYc8e4IsvAvjm2wAycn1o1Zmifi7adMpFnE3E8ZKSlpo3C3HB7DisXxaHOjW8GHGGFyecANhhuguLkc455xx88cUX5ucnn3zSFFGqGEmEQjRjp9m+fftCLpqVhszMvK79L8f7Ub9FNoZflIkatV2VGgwpzKL+NjEOE79IRINaed38nToF9zlUjCTCKZrR/Zb59COPPNKIZtWrVw/Jc23eDNx7nx9b9+bivOvT0aiZbLHtwv49Hrw9JgnZe+Nx/z1edO1a+mIkjmnjOSREMKF0yYa4e+65p1yNvLNnA/c+4EPrnpkYfmGWbYumRfnJyQY+fDURm5cl4uyRs3Ddde4uRnKVwE/R7Mwzz8QPP/wg0UyUGVUhilAi0UwEAyakzz77bBUjiZCwePFis1F3i2gWCnJygO3bgdTUf29paQf+zBU2HcB4oyGQ9b11q13bPh2toS5GYnfHRx99JGckERLRrE2bNmajbgfRrCzs3g2MGxfA+O8DyAn40OfYLBwxKBsVKrqn2/WXb+OxcGYCalXLE/pPPBFB73gtLT6fz4j6zz33nPmZTQJ0RoqJiYnsgQnX8MEHH5hOs3CIZqVh4cK8rv1NO3wYNCwTfQeqa7888W3cW0nYujoOpw/14oILgtvNz2Ik7vnYiEJUjCRCKZqNGDHCiGaJIfqA/vtv4P4H/ciNy8GFN6ajei3XyBGuISsD+PCVJGxekYCbb/Bi4MDSFyNxXDLPJSHs1Mi7YgVwy21+1GuTiXOuyoQmTrqf3BzgzdFJyNiRgOuuWY0LL3RvMZJrBP4dO3bg+OOPx19//aVOM1FuClchUtw4/PDD9cqKcrFs2TIMGjQoXzSjQ0SvXr30qooywQ0URbNdu3aZKsSff/4ZLVu21KspysX06dPNeeUG0SxYZGcD69ZxbZB3W7YigDVrA8jOCRgRP2D+AzzeAJKSA0hMDiAhKWAsbjPTPchI9yArwwN/rgfwAF54zP+LjfGgWVMPWrcEWrb0gJcvX2o7dLeGohiJn3c8n2rUqBHpwxIOh2O0zjvvPJPwOeKII8wG3Q6iWWnZuTNP2P92QgC5Hh8OPzYL/QZlI9mlE8J2bffgl+/isfD3BNSo4sUZw7zgCPKkCFtjUuC/6aab8ouRPvvss1J3BAlRGI6oueOOO8IimpWma//ttwP48hs/6rXIxrALM1GzjivSgbbo5v/580Q0qpPXzd+xY3CLkW6++WZTOEmuueYaU4wkxxFRXsctuki+/vrr5ufbbrsNjz/+eMhGRv7+O/DYE35UrZ+N865Ld00RoxvJzQW+fD8Bi2Yk4qLzvBg5Mm/vWppipNGjR5tCbyHKA8+rYcOGmRwCY9MLL7xgxP7Ssm0bcP2NfsRUzsalt6YjXsv8qCEjHXjl0WRUionH3XftwrnnDjGNvSxGGjt2rDm/3IArBP60tDQcc8wxmDVrlkQzEdSiEVYh8sKnyD9jxgzXWXiI8LFlyxZTJLJu3TqJZiJorFixwhQjrVq1Ci1atDBxisUjQpTV7rpfv35m9qKTRbNgJDXmzaOjD7B02T9ifm4AfvhRq54f9ZrkomFTP+rU9yO5YgBJFfKEfW4UD5X84GqbNmEU+zPSPEhP9WD7Fi82rvNiy7pY7NjsBXxexMV60LSxB21aA4cd5kH37s7v8i9YjMTzi8VISZFW9IRj+emnn8z4EM5epHPbu+++G3HRrLSkpNAON4DvfgjAH5uLvoOy0XdgNpKSERXs2enB5O/iMW9GPKpXisGZw7049VRE1Cbz888/N5b9LEai7eeHH34YMpFDuB8KZpdffnlYRLOSsmMHcO/9AazekItjT89Ev2PVtR+qbv5ta+Nw5aUxGDr00OvC8hYjseP64YcfDt6Di6iDsempp54ysYkFI1dffXXInmv8eODFV31o0SULIy7JdNzYoWiEe1e6L035OglDTvTi6qs9xa7TChcjsbDt/PPPD88BC9fB84l7PTYMcGQkC7yZUyjLvuumWwLYmZaNK+9KR8XKjpdBRSnZs8uDVx+tgBYN4nDfvRm45JJzTDFSXFycGZ189NFHO/41dbzAzwue9ozffPONSUJT3GDHmRDBID09HQMHDjQiPztk+bVOnTp6cUWpSE1NxVFHHYW5c+eaDmvGqVq1aulVFEFh69atpnhk7dq16NOnj7Et5gJYiNKwadMmHHbYYdi4caOxqqKI5jTRrDz4fMCCBcC0aQFMnxHAnn0BVK2di8Ytc9GgqR8NmvhQv5E/ZAkp2odt3ejFxrUx2LTOi/UrY7F7awwqV/TiiMM96N/fg27dIiuAlXfsA8V9OkMMHz4cn3zyScTFDuE85s2bZ+IT11VnnXWWmRnrtPPojz+AMS/4sSfVhyNOzETfY3KQEKX1Lnt35wn9c6cloH2rGNx8kwdNm0bueCZOnGiKJlk8QvvP//3vf5E7GOFYvv/+e9MkwDzVfffdhwcffDDSh4TVqynu+5Hqy8EFN2SYAkURGphdnTAuHjN/TMIZp3lx6aWeoNoA06L40ksvNd//3//9Hy655JLgPbiIGl566SXjBEFYKElXpFBdD3QNGfuZH70HZuDkEdlBLXoRoWfOjFh8/U4y+vaKwT13e0pUeE73GrrYxMbGms7rY489Vm+VKDV0gGBhGzutKcIOGDCgTE6Md98TwOJVObjirjS5FkUxm9Z58X9PVEC/HrG4804/zj57JMaNG4cqVargt99+Q4cOHeBkHC3w89CvvfZaszihjd6kSZNM8lCIYHfy9+3b19j1cwbxlClTNENWlBgmCYcOHWqSPTVr1jSdjLJRF8Hm77//NnFqz5495nxjJ5pmyIqSwo79/v37Y/78+caphgvcaOjc9/vpWvCPqP9bALv2BFC5Zi469spBl965qNvQH9Ek1LbNXsz/IxaL/ozDnm2xqFrZgyP75on9XboAThsTzfUTx2llZ2ebDrRnnnkm0ockHATHG7EIafPmzSbB88MPPzjKRp3dI6+/HsAPE/1o2iELw87PQuVqjt2GB5WNa7wY91Yi0nbF49yzvBg+PHLFTBQ6LrjgAvP9yy+/bOyLhSgpc+bMMUXddJjkefTWW29F3EZ97lzgoUf9SK6RjfOvz0ClKoo74eD3yXH4bmwSjukXg1tv9QR1/NK9996LRx55xOz1xo8fbwqThCgpbI477bTTjEU/XSDoBhEqxo0DXnnDh+POSMeRx+foTXIoK5bE4IPnkzHwiFjcfnvxdv08t+iK9NFHH6FSpUr49ddf0blz53AdrnABFPatEQ88j+iuVVqodj7xRACTfs3FRbekoUlLFTdGO38viMGHL1TAsFNicOGFWRg06FiT+2zUqJFp6K1fvz6ciqMF/qeffhq33nqr2TRxVp5b5iYI+0Fxnx2yO3fuxODBg42VB6sRhSgKhlfaM7K6nnbEkydPNh3WQoQCbpxYHZ2VlaXZjKLEcIY1P9fYsU+HGhYhNeMgeJd360+bBoz9KIA16/2oWD0XHXrkifrs1rdbZwlX6uzunz8rFotmx2Hfzlg0qufBqJFeDBzorK5+zjnjfEZC+8brrrsu0ockHMDevXvN2BA6QbRv395sxKtWrQqnMGtWXtf+rhQfThqZgR79cm0XZyINXUwmfhOP335IRIfWnGEduW5+Ch7svKY7xFdffVUmO1ARfdBJi/kCOmsNGjQI3333nbH+jCQ//wyMHuNDw7ZZOOuKTCREjzGTLVg6LwafvJaMjq1jcf99HlSpErwcA22v6WJToUIFTJs2Dd0500mIYuBYWxZJcq413R84TiRURUjcaz38uA99T8rA8adl671xOIv/isHHL1fAWcNjcPHFxZ8zzEmxsHvq1Klo0KCBEc8aNmwYlmMVzobNSmeccYb5rKMTBMeJlIU33wxg7DgfRlyRjo49coN+nMKZzJoWi/HvVcCVl8Tg6KN3mUa55cuXo2vXrmY9xaIkJ+JYgZ/WnlYFz+jRo/Mre4QIFVyQcC4HZzNeccUVpqsj0hX5wt489thjuPvuu815wrlBp3LAqBAh5NNPP8WIESPyi+A4A02IQ8El4MUXX4y3337bjHXgBpxONW4lNxeYOpXCvh9rN/rRonM2BpyYbaq5nfJxzlX7xrVeTJ0Qj2V/xaNBHS9GjfCCzocR1hFKDG2v77zzTvPZyA08u4iEOBR0fDjhhBNMkWS9evXMerxx48aOeMFSU/O69if87EeT9lkYdkEWqqhrv0g2sJv/zUSk747HeWd7wfr9cBcx8bORFthvvvmm+Wyk+0ivXr3CexDCUdBBi06SS5cuNV2K06dPR+XKlSO6VvjwwwDe/dCPLkdkYug5WY5z/XFTTHt3TDLqVY3Fww95EazmMH42nnTSScbFtG7duuazsUmTJsF5cOFKVq1aZYqQ6FDKdRU7+UNVhESHtNvv8qNF10yMuDTTMfssUTS/TYzDj58k4/qrYlCS2kd+NrJAd8mSJejUqZP5bKQdthCHguNsOSaZugtdtOjYXRbd5dtvgede8uG4M9NxxCC5h4gD+fHLeMz4Pgn33BGDRo1Wm8/G7du3m6IkOiNFukA3agR+fiiwS5GL2uuvv95YdwgRDti5T6cIXjZMUHM+oxAH44MPPsC5555rvn/hhRfyZ5yJ4snMBNas4UzwvOR4wVtKSsB8zfUBFSsCFSsAlSp58r6vCFSoANSsCbRoAUSBw/hBoe31Lbfcki/4s/pViIPx0EMP4f777zddikzynHzyya4V9n/5BfjoYz/WbfajdddsDDwlGw2aONumjRb+k76Jx9I58ahfy4sRZ3px3HEo0WzESMI11FVXXYVXX30ViYmJRril9boQBztXOBeWa6qKFSuaqvpu3bo54oVicvvxJ9S1X95u/o5tYnD3XR7Uro2wu9uwc58zP2vXrm3cbZo3bx7egxCOgF2Kxx13nIlP7E6k0MpuxUiueZ5/PoDvfvLhmNMyMOCkHIlrEWb3Dg/efjYZMdlxeOgBL9q2Dc7j7tu3z4hnixYtQrt27Yy7TbVq1YLz4MJV0ImUXYorVqww6ygWdYeqS3HDBuCGm/2oXC8LF96Y4SinMVE8334cjzmTk/DgvTEoyfZt3bp1Zp9HdxvqOHS34Ux1IQrDLmrGqV27dpk1OJvkyuKc/NdfwB33+NBtQCaGjMrSCy3+A5XwT95IwKq/kvDs017s2zfbjNiiuw0boOjC7LSGXscJ/AXnDLPjh9b8mjMswsnzzz9vCkssq9lRo0bpDRAHQLGClV9MDrKDmp3U4tBi/urVHIMBrFgRwPIVAazbQAE/AF8ggLiEAJKSA0g0N7/5mlQhYLpQMtI95paV4UFmmheZ//zMj+FYrwe1anjQuqUHLc0N5kbR32Gf06WGH+u0vX7xxRfNfOKJEyea5I8Qh5ozTKGV40TcBle4tId86x0/Nm71o023PGG/XiNnC/uF2bHFg0njE7Bodjzq1fTivHPyhH47x7rc3Fyzjv/2229Rs2ZNI561ZJAW4hBzhpkQ5NrKCTDuPPG0HzWbZGHkZZnq2i9H5+tHryQh2RuHhx/0muLNcJKSkoL+/ftj3rx5aNOmjRHPatSoEd6DELaGc4Y5dubjjz82Hfscl8UuxUiRkwM89HAAv8/JxekXZqDrYbKktQtpqcB7zydj7+Z4PHifF8Fy1N+wYYPpPNu0aZOxXv/hhx/M/k8ICwoWFFbZGUsHJBYh0REpFOzeDdxwkx+Znmxcfmc6kpL1PrgN4xDzSiI2LEnE00940aZN8f9m7ty5Zj2VlpZmxovQPdBp4pkILeye5mfZ6tWrjWsWc+ocQVNa0tKAK67yI7ZaFi65OcPW+RARWXJzgVcfS0ZFbwJefN6DH38cb1yXubbnuLZ77rnHUW+RowR+Vnzxgud8M1aA/fLLL2autRDhhqItR0Ow8pBzi1npIwRhBT3FVFbUs3OaCR92x4p/SUnhyAtgytQA5s4LICc3AE+sH7Xq+1C/iQ8NmvrQsKkfder7EVtKZxx+ou3d5cHGtTHYtM6LTWtjsHV9LDLSPEb0b9LQgwFHeXHkkYBDHH7LhM/nM24jX3/9NapXr2429ExOC0F+/vlnY+tJkZVW6Rwn4jb27AFefDGAqb/50apbFgadmo26Ddwl7Bdm5zYPJn6dgMWzEnBYTy+uvy78Xa+lgUkerp/mzJljxH3GqVq1akX6sIRNYOX8ZZddZr5/4403TDW93eEa5IsvgNfe8KFtrywMvyhTnWvlJGWfB++OSUL6rnjce5cXPXogrGzevNnkHSii0YKdRZN0HhGC3HHHHWY+LDvMKKzSVjaS8efppwP4aWouzrkuHa3a+/Qm2YycbOD9lxKxc20iRj/lRbBMQebPn48jjzzSFCWdddZZeP/995V/EAYKFRzfN27cOGONzrV2+/btQ9a4cettAazdloMr705D1eqOkRpEGWLZ/z2VjJy98XhutBclqReZMGGC6cpmnuq+++7Dgw8+qNddGNLT08045FmzZqFZs2am8L9OnTplenXGjAng+19ycd1DqahWQzFIFO+I+dKDFXDWsFhcdJHHjOK++uqr8xui6CToFBwj8CsJKOy6UK5atarp6AjVQlk4h4JJQIr8FNGUBPy3kvKPPzj/OoDZcwPIzPWjcascdOyRiyYtfajTwB+yJLgR/Xd7sHFNDJbMizFzq33ZXrRo5sWA/h4j9kfQSTOkC+VjjjkGf/zxR7kXysI9LFiwwMQntyYBeb1PnQq89Iof6b5cDD0308SZaGLZwhh8+W4iYnLjcPklXrDp2a7V6yreFcUlAdnFz3EidsfnA157LYAvvvGj30kZOO60bNted04jKxP46LVEbFiagBuvizEOJeFk8eLFRtxX8a4oyCuvvGLGzdglCfjuuwG8+5EPZ1yWji69o2vd47R49n9PJsOTkSeMBauuMRqKd0X5GpM4coYuD6FaAz30UAAz5+Xi0tvTUL+xu4uqRZ4ryauPVUDV+Dg8O9qLypWLf1VYsHvppZea7998801cdNFFeimjnGA2Js2Zk2fNf9I5aehzlNZBomRM/i4O075JxvOjY4wjCUdxP/nkk7Yo3nWdwM9FKm0SaM0oG09hFzIzM43VFcX9UFtdCftT2MaTCxMuUKKdNWs4Bz6Aab8FkJHtR4MWuejcKwedeuaictVAxGa7LlsUg/l/xGH5gjggx4u2rb0YPswDOtm7SOvEjh07jPPNqlWr0LNnT0yZMqVMVlfCHWzcuNEUIbnVxpNd+y+9FMCUX/1o2zMLQ8/ORIXQjJe0PRnpnJGYgAUzEk03/w3Xe4KWRA42Gr8lDmXjScHsnXfesb2NJ7vWnnwygKm/+zD47Az0GZAT6UNyHX4/8PUHCZg3PRHnneXFOed4wlpAofFboiDjx9vLxvOHH4BnxvhwzOnpOOpExR8nOJO8/Ggy6laJxzNPeVCxYnAel5+XF154oavHb4myjRb98MMPTWF3qHj55QC++NaHc65PQ+sOcg+JFnZt9xiRv23TODzxP0+JGnacOn5L2Hu0KBvKLr/Cj4SaWbjoJlnzi9IVqNGqPxkJeOkFxjF7jd9ylcB/9913mwpU2vHTlp/JaSHswK5du9C3b18sX77cfJ02bZpZqIjo48wzz8Rnn32G2rVrm2IPdkxHM6tWAR99FMC0GX4kV8vFYUdno3PvXNtZtdFe7O8FsZg9LQ5rlsSheeMYnDXKg/79AbdcyitWrDAiP+MVFyoffPBBpA9JRKhYkp9Ts2fPNo4zLE6jA41b4MzrF1/2Iy03F0POyTRFRILxjd38SYj1xeLKy7wYNMie3fzTp0/HoEGDkJWVhQceeAD3339/pA9JRIC9e/eiY8eOpgiJRbRM/LHrzM7s3Qs88GAAS1blYuQV6WjbWYntUMGsxZQJcfjliyScNCgG119fsmRysKBAcs4555jvuZbimkpEHytXrkSXLl2MU9Yll1yC119/PaJFSLNnA/c+4EPnIzMx9OwsW37Gi/+yfYsHrz1WAV3axuHhhzyIK+VYukNB22uuo+jOxaQ094Ai+pg6daqxvGa6//HHHzfjRELFn38Cd97rw/Gj0tH3GBUYRRvrVnnxxv8q4pLzYjFqVPG/z3Py/PPPNy6ClSpVMu6CTZs2DcehCpvx9ttvGxcHrqE++eQTM+K2rDz7bAA/TsnFdQ+n2i7nLJxj1T/q9FhcfLHH5KSOO+44o/E1adIECxcuNPHKzthe4GcimoI+q6N5wVNEE8JOrF69Gt26dcP+/fvx9NNPGxssEV18+umnZmQDLVy4ke7Tpw+ilRUrgLFjA/h1ph8Va+Ti6MFZ6HpYriNm0G5Y48Wkb+KxcmE8mjX04qxRXhx1FBxx7MXB85KzrvlZ+tVXX2Ho0KGRPiQRZlgoyYLJatWq4a+//jILVTfAVew77wQw9lM/WnXLwqnnZKFiZVsvbSPWzb9wRiJOO8WLK67w2LKAiYLZueeeaz5Luf7v2rVrpA9JhBl2HrIDsVWrVuYc4LxYu4v7N9/ix7Z9uTjv+nQ0bCpL2nAwb2Ysvng7CUf0isU994RX5GfxEUdG8LOU1v1yb4suuI6mAxKL0vj1p59+QlywlNky7rtuuc2POq0ycd41ma5yIYsG1iz34p3RFXDcUbG45ZbguJIwvctCpLFjx6J169bGXZCNUiJ6SE1NNUVIzFNecMEFeOutt0JWhMSu2cuu8CNRXbNRzY9fxGP2z8l4cYwXzZsX//vZ2dlmlCQbDmh/zREjdnfrEsGFY21Z1E0dhY4OzFOVp9Dxrvt8OPncNPTuryYPUT6r/jHPxKBtW7qD7kGPHj2wZs0a44hEZyQ7Y2uBnxbo3bt3x9KlS42dEKvmRfkXYOysXbmSVr20FQ8gJZWLQCAlNe/77CwguQJQqSJvnryvlTxgox+bklu2BBo1cofoFSw4P4gV/LSV4SaqLaOBiAq2b9+ODh06YOfOnbjvvvtM1Xw0sn07Z1HmCfuVa+ViAIX9Prm2FJGKY9M6LyaNj8fyefFoUt+LKy73wg01G6zcf+KJJ1CnTh2TlK5Ro0akD0mECVaccnGak5NjquWtDkSnk5PzT7X2ZB+OG56BI49X10hRzJoWi/HvJ6P/YTG4/XYPEhNhK7glYeX+559/js6dOxuB1+7d2yJ4sFt/8ODBJsFH8Ywzz+1uy3/HnQGs3JiDK+5KQ/Vatt1Su5Lli2LwwfMVcMrxMbjuuvDZ9fNzlM0HHCUxZMgQUzSppHT0MGbMGNxwww2oWLGiWVtFsuuQe6/rb/TDUzEbl92Wjnj3TFyKKubPisVnryfj/FExOP/84AQyJqUpnGzevBk33XQTnnnmmaA8rnAG11xzDV566SUzRpRxihbDoUJds4Lk5gIvPpSM2hUS8NyzJSu8pBsO93sZGRl45ZVXcMUVV+jFjBK45z/xxBPx448/mjU1m5HK6oRMLevyK/1IqpWFC2+UNb8on1X/K48lo0IgAS+96AHTUBxxSzccwqJeOk7aFVsL/BIjys+GDXnVTMuXB7B8ZQCbNgeQ6wdi4vyoWc+HpIoBJCYHkJwcQFKFvO9ZhJ6Z4UFGGru+POaWme5B6l4vdm+PQYzHg8R4D1o296B1aw/atAF690bQZoc5EV5GJ510kplnXN4PKOEcCooRrJKeNWtW1IkR/ASZMAF4/U0//HE5OH5YFrr0yXVFB8mWDV5MGBePdUsScPxALy6/3AObu/IUWzRHkXfJkiUqmosi3CpGcDP38CMBzF2Ui+GXZMiSv4QsWxiDj15JRrvmsXjgfg+qVYOtUNFcdEIxgsWSW7ZscYQYwQTAo48G8OufubjktjR17keIP3+NxdfvVMBlF8ZgxIjwPa9bi+ZE8SOvuN+zgxjBpo0bbw5ge0o2rro7Xc5FDmeqGT2SjJuvj8EJJwTnMb///nucfPLJjimaE8Fh8uTJpjOasCua445ChbpmRUE2rvXitUcr4uJzY3HWWc4rmhPObJBUkZEItlX/yw9VwIhTY3HJJZ4DiuYaNWqERYsWhbRozpUC/x9//GFmxcpOuPRs2kQ7ZmDKtABWrvbDE+tHncY+NGjiQ4OmPpOEqlXXXyYBLisD2LQ+BpvWerFpXQy2rI/Brm0xSIrzoncPzq32mE7X5GREHRs3bjSV0vv27cOTTz6JW2+9NdKHJEIMx4aMHDkyau2E2Tny3JgA/pjjQ5cjsjB4RBYSXeYAyE/IuTNi8d1HSaheMQbXX+vsbn6ep5zF6PP58OWXX+LUU0+N9CGJEEPLs3vvvRfVq1c3zg1169Z1Rey59/4A1m/LwbnXpqNpK9lil9al5L0xyahRIRaPPOxFw4awFZ999pkZycXPVhbOcQyScDecxfnee+85wk6Y6wI6Fn0+3oezr01D286+SB9SVDPx63hM/zYJd94ag380jbCPvZFVv/thToqjrljET8GMXTyRLJYcPTqAn6bm4sp7UlGrni3TeaKUnytfvpeAZbOS8MpLwVuXFRx7w8/W5GhM0kWZNX+nTp2wdu3akNsJq2tWHIwfv4zH7J9KbtVfcOwNC1NYlOJ1Q6eQKJE1f3lHHKvISISCyd/HYdrXyXju6Ri0a3fg2JtLL70Ur7/+ui1feFsK/OwyZDLv77//NhXxrIwXxVdx//gjMHlKAMtW+IE4P1p3zkGXPjlo3cGHuBA2Fe/f48GCP2OxYHYcNq+ORYUEL/r08uC44zzo1Qths0y0A2+//TYuuugiU4nGGcftGA2EK9m2bZvpNtu1axceeOABM5MzWuCnBuPNq/+X17V/+gWZaN3R3QluxrnP303A2sUJOOFYLy67zLnd/HfddRcef/xxWfVHAQsWLEDPnj1NlyHHHHHckdPhiKH7HvAjAzm44IZ01Kpru2WsI9izy4N3nk0CMuLxwH1edOgQ6SM6EAr8FPpl1e9+xo8fb9xFmNCjeMYiNDvzxRfAy6/7cPI56egzQGNB7LAmHfd2ApbNTsLjj3jRpUt4njc3N9ecq3/++SdOOeUUfP31165wxxEH57nnnsONN96ISpUqmS7DJk2aROylUkLbnXBM5vMPVEDT2vF4+ilPUNzw9u7da4SUTZs2mfN39OjRwThUYVOuvvpqvPzyyyY+MU4xXoW6yOi6h1NRtbr2YuJAq/5ayQkY81zJrPpXrVpl9nvp6enm/L3yyiv1ckaBNT8beqdNm1Zm52O6qV12uR+Bilm4+GZZ84vg4fcDLz2SjDoVEvDs6LwxcFOnTjXFSITn73HHHQe7YUuB//bbbzcd0OwyY0U8u87EoSsnx48Hxn3px/50H1pR1O+di7adc0Mq6heVMF44OxYLZsVh+/o4tGvtxaiRHjBXFw05D15OnB9KS7Q+ffrgt99+k1W/S9/nYcOGmQ5odu2zwzCOsy2igIwM4MknA5j2ux+d+2Warv2kKGkG4KflnN9i8f3HSahRKQb33+tF69ZwHFlZWcZalp+vo0aNwtixYyN9SCIEUNTn5xCLzejU8MUXXzhefFi9Grj5Nj+Sa2bj/OsyZElbTjLSgfdfTMKudQl44nEv2reHbdixY4cpouNXOlA89NBDkT4kEWJr/ltuuQVPPfWUrV/nadOAhx/34fATMnDCsOxIH44okFB+d0wS9mxMwOinvAiXwyvXUd27d0d2drZxoDj33HP1nriQ5cuXm/0erflfe+01XHbZZRE7FnXNupu1K7x488mKuOayWJx2WnAec8KECWaUJPcAFFOOOOKI4DywsBW//PILBg4caL6fOHFi/vehYNYs4O77fTj53DT07p8bsucRznWKo1X/hWfH4uyzS/ZvXnjhBVx33XWoUKGCKU5p1qxZqA9TRIA33njDdEAnJiZi/vz5xrmtrEyeDDzyRC4uvydVo9JE0Fm+OAYfPFcRTzwSgx498u5jjGKsolU/41SVKlVgJ2wn8M+cOdPMh6JVyzfffGMq4sV/SUkBvv4a+OJrP1IyfOhxVDYGnJCNytXs83au/jsGE7+Jx4bl8WjT0ouzRnrA0V8O1xeKhRXSTFbSqv+JJ57AbbfdFulDEkHmo48+Mp2wtA9m5w7tWqKB3buB+x8IYMW6XJxxWTradXF31/6h2LfHgw9fTsL+LfG4+05nWvbzvOVcdlr1f/755zj99NMjfUgiyDz88MO47777XGPNv2MHcMNNfvgTs3HZ7elISIz0EbmD3BzgzWeSkLEzAc8+40WDBrAN48aNwxlnnGEKJVlIRyFNuIvzzjvPOLW1adPGFCPZ2Zp/0SLg9rv8aNE1EyMuzXT9fsZpcIzcq08kIz4nHs+N9qJGjfA8Lx2R6IxUtWpV81lbv3798DyxCAtcJ/fv3x8zZszAoEGDTNdOxK35p+XiuofUNetWxn8cj4XTk/FqEK366TBJp8mWLVsaUUVW/e615r/iiivwyiuvhPC5gMuv9COpVhYuvFFdsyJ4Vv206Le6ZCdNmiSrfpexfv164yiTkpKCZ555BjfddFO5OqwvvyIAT5UMXHB9ZlCPU4j8kXyPJaN2cgKeeTqviz8tLc1oP3QdueSSS/B///d/sBNeu1nzc04Ugzsr4CXuHzyQ0Rry3Av8eO+THLTtk46b/5eKIaOybCXuk+ZtfbjstgxcdFsKMmIzcf8jPlx5dQBLl8LVNGjQwNj4EYorS93+B0cZW7duxTXXXGO+Z1dhtIj769YB19/ox7rt2bj0jrSoFfdJlWoBXHprOhq0y8R9D/nw/fdwHLRtp1sOoQ3azp07I31IIsjW/BT4yYsvvuh4cZ9jiO69P4BUXw7Ovz5D4n4QiY0Dzr02A/7EHNxzrx9798I2DB8+3Fj1U2C54IILTJescJc1P8V9WvNzRrCdxX0mtB9/wo+aTbIw/CKJ+3YkIQm48PoM7MvKwdPPBExiJhzceuut6NWrl7HCZme3zXonRDkZM2aMEfdpdc3Os0iK++yanfCzHyeNzJAltos54fRsJFTJwehnAyb3Fwxozc8c1cqVK3H33XcH50GFbWBDEcV9WvPTCTeUvPNOALtTfGZEowodxaEYeEo2KtXOxrPPlWw9xr3AW2+9ZYqPpkyZEtIiFRF+uDamIEpxnw29119/fbke79dfgdXrfRg4RLkBERo8HuCYU7KwYIkf8+fn3UeHEcYpwj0Bi37thK0Efoqhf//9N+rVq2c2U+JANm4Ebrk1gJf+Lxdt+2TglidSMXhkNipXtXcioVlrPy69JQOX3JGCFH8WbrjFhzffDMDNedrzzz8fJ598srHCZlKacxqFOxYmFEN3796Nbt264c4770Q0sGABcNOtfmTFZOPKu9NRr1GQsg0OhiNQzr4yE92OysToF3x4++3wJZOD+ZnLKtrt27fnF60Id1jz83OHX0877TSMHDkSTiYnB3jk0QDWbcnBhTem237N40SSKwAX3pCOHSm5eODBADJtVAjPApVatWoZGzSraEU4H66jLJvrm2++2TjK2JnXXgtgV4oPIy/LLNE8UREZWOx++oWZmDXXhwkTwvOcdPNigUp8fDy+++47Y9Uv3MGyZcvyxVB2mzVu3DiiRUZjXvCjaYcs9OinvILb95jDLszA/CU+fPVVcB6TDiNWpxnzrNOnTw/OAwtbWPNbYiiFBxYjhYrt24Hvfwyg/8mZKjISRcK18ilnZWHpcr8pTisJzZs3Nw64VtHKas7mE66Anz8///yzseZnnKI7X1lhzvXDjwJo1j4HjZopLy1CR5tOPtRulIMPPvw3109XL1r1Exat0LnbLnjtZM3PjRN5/fXXUa1atUgfku269q+82o91O7Jxye2pGHJWluNmzzZp6ceVd6XjqFPT8fGXubj6mgD+/huuhNX9nNHHmRy0lbXObeF8a/6vvvoKcXFxJpnHr25nyhTgznv8qFw/C1fcmW6610UeXi9MLB40PB0ffOrDk08GjBjpFBISEsx5zAX2J598Yqz6hfOhXTCtrmvUqGESPpHsNisvXEiPGRPAnwtycfY1GahdT/EnVFSrGcB516djyapcE8uC1TVWXijuW4lLnttz5syJ9CGJIMDODToitW3bFg899JCtX1MmJn+YmNc1qzWQ/WndwYeuR2Th9Tf92LYtPM/Zvn17PPjgg/nnNse1CWdD5xg6S9Jh8rjjjjNJPDsUGZ1+fpa6ZqOApq386DMwE2+968eGDcF5zBNPPBEXX3yxaVigZX96enpwHlhEDHbD8r0kV111lbE4DyWffhqAJyEXhx3toISHiBjN2/jQsFX2AeJYcfA8pkU/4xPPbbo7C2ezbt06U8xNHnvsMbRu3bpcj/fbb8DKNX4MHJoVpCMU4uAwjTpwSBbmL/Jj4cJ/7+d53KJFC2zcuDH/3LYDthD4uXFitxmDN2cxDh48ONKHZBu2bAFuvS2va7/Tkem47oE0I5Q7WRAbcGIOrrovDeneLFx/c143vxsb3GmDZjlRsFN2yZIlkT4kUQ62bduGa6+9Nt+av3Pnzq5/PWfMAB5/yoeW3TNw4Q0ZSLSve25EOfL4HJx5eTomTs/FM2G0hQ0GPXr0wB133GG+l1W/+6z569SpAyfz/vsBfD/Rh9MvyjBJAhFaGjb1Y+QV6Zj6uw+vvmqfWDZs2DCMGDFCVv0u4ZtvvsEHH3yQb83Pbg67kpICPPe8umadxuARWQgk5OC5MeGLY7fccgt69+5tOjkuv/xyWfU7HO7hf//9d9MNy86zSBZLzp6tIqNo5Ph/rPppcR0sjYtNJw0bNjRW/XfddVdwHlREDI7bo3jWrFmz/M7nULFjBzDhpwD6HpelUWmixNBCnV38f/5Zst/n3uDNN980VthTp06VVb9LrPlTU1ONNb/V+Vze7v0mbbPRpIVzdTHhHNp28aFGgxx8OPbfDSXj09tvv232BoxXP/zwA+yALQR+bppogUZrfmt2uYDpbr/hJj9Wb83Gxbfl2fHTsssN1KnvN93A/Yem4+MvfLj/gQDcWETMghVa9XNurOadOZtHH30035rfEkTdzNKlefNmW3XLwpkXZ8mSthg69czFGZdm4OepPrz1lk1UsRLCghVa9e/YsSPkyQERWhibOBKG1vwURJ0Mu2bf/8iPY4dloEtvF1YB2pS2nX0YfE46vhjvNw4udrPqX7RokRGFhXO7YjmznLDivU+fPrAzr78ewO5Udc06jYQkmPnA4bbqZ7LHsuqfPHlyeJ5YBJ29e/fmOzJE2pqfwu4bbwXQqE22rPmj1ap/sd90LAYDuktybqy1rpIFtnPhaNtXX33VfE+BoWLFiiF9vs8+C8Afm4u+x6h7X5Sc5m19qN8iTxwracFlQat+NsrRqUI4EwqfEydONMXcXCOXx5qf/P47sHyVH8eqe1+Es4t/aBbmzvdj0aJ/7z/yyCPzC1aY27CD24jXDt37//vf/8z3999/v6z5CwSuW+/wI75aNq66J83YdLkNxvajT8rBuTekYc7CXNx2ewC7dsFVsKLn6aefNl9p7T5//vxIH5IoA1u2bDGjQ8hTTz3lemt+Oove/6Af1RtR3M+UFWQJ6dgjF8efmYGPxvnx7bdwlFW/tYl6+eWXjdAvnMfs2bMxYcIEs3GyPnecSsGu2aNOUCIp3PQ5KhftembhxVf82L0btqBmzZq455578m3Rcpw0D0Xk8+mnn2L58uWoXr26KS6zM3/8oa5ZJ9OqvQ/djszC62+E16r/sssuM9/bffSEODTPP/889u/fb4pfaWkeaTc1WtEed7qs+aMR5gCbtc82HYvBciM5/vjjccIJJ5iCO44+Es6Ea2F2xw4dOhRHH310SJ9r507gux8C6DsoW937olQwHXHMkCws+tuPuXNL/u+uuOIKY+XOBivmp4TzYHyyiiWvvvpqtGrVqpyPB4z9KIDGbbJdqY8J+9K+qw/V6x/YxW9p2JUrVzYNKNT7EO0C/1tvvYXNmzejUaNGxqZfAOPHAw884kOj9pm45JZ0VAhtMWbEadnOh8vuTMP6HdnGsWDdOrgKzhcdOXKk+d6yThbO4sknn0RWVpaxFQr1bLNIs28fcO99fvgTc3DutRmIdXctQ9A5YlAOeh6TiRde8RlxwClwLmPPnj3NvDN2KwnnYYkJ5557rql8dzJW1+wwzZqNGEPOzkRWIBcvvGAfq/5LL70UdevWNXak7733XqQPR5QSignWOvimm24y1td2LjIa84Ks+Z3OyWdmIZCYZ3EdrjhGy2R28dNaljfhLDhi4dlnnzXfswiJdsGRgufsB2MDRuBt3FzJ7GiF819XrPabBqBgwa5YQkektWvXBu+BRVhYsWIFPvzwQ/N9OIolP/88AH+MD/2OzQ75cwl3FlzWbVq6Ln42LFiF3WxcoMW7cBY///wz/vjjD9O9b7m3ldfd8e8Vfgw8RXFIRKBQ6ZRs/PmXHwUnb1erVg3XX399fi420l38ERX4KZhZVaO0lWUXYTTDD7s33ghgzMs+9Dg6A2dfmekaS/7iqNvQjyvvTkd2bDZuusWPhQvhKmjPz27Kzz//3FT3COewdevWfPszboad3BVbHJmZMOMytu/PxYU3pCO5QqSPyJmcMjILzTtn4dHH/Vi2DI6A57WV7KFl406W6gvHMHfuXHz77bcmEe30mZpW1+zJozJQuZpNlOUohMWlQ8/LwPTf/bCL03RSUhJuu+22/LE56uJ3FlwDL126FFWrVsU111wDO/P++wHsUZGRK6z6h12Yidl/hS+Ocb611fWtLn7nwTUwLfrbtWuHYcOGRfRYKOhS2KXAK6KXJi39aNw22xR7BKtQ6fDDD8egQYPMWC/LTVU4q3ufQsLgwYPRo0ePkD4Xnby+/T6Aw4/NQmJSSJ9KuNniekgWFizxozSGtqNGjUKLFi1MXsrKxwrnde/TjaFOnTrlfsxxnwfQoGW2GfsgRCTceqvVzTEFbwW54YYbzIgcunWPZ7d2tAr87777LjZu3Ij69evjoosuQrQzdmzAWDsfd2Y6Bo/Mjjpb7CrVArj8jnRUrp+Fex/wY/VquIYOHTpg+PDh5vtHHnkk0ocjSgG7mTlKhHNiuRF2My+9FMCSVbk47/p0VKspYa2sMHaPvDQTletnm1EH+/fDETBJ0LVrV6SlpeG5556L9OGIUmB1xZ511lnltj+zS9ds9765kT6cqKdDNx/a987CS6/ax6r/8ssvR+3atbFmzRqMHTs20ocjSggT0Vac4kaYc4DtimVFe8SJmSoycolTXIvOWcbWM1yNFWxc4DivX375Bb/++mt4nlSUG875HT16tPmenYPlnRVbHijkstuRwi4FXhHdsGNx2Up/UN3hrMJuOqpu2LAheA8sQsrq1avx/vvvh7V7P9fjQ79B6poVZad1Rx/qNM7BBx+WvFApNjbWNMpZY1LpNCmcweTJkzFjxgzTxBuM7n3uzeYv8qNnf43oE5HL8fc4IgczZweQlvbv/Rw7eO211+YXdrO4JeoE/uzsbFN5aFnZ0bYjmpk4EXjnAz8GDM0wFs/RCqtCz7s2A0nVs3Hv/X64aRS0tQDn/NElBX09hG3hLHJr5pPbu/etrtlTzs5Aw6ZKJJUXuq+cc1UG9mXm4pVXAo7r4uf80T179kT6kEQJYLUoZz7x/bM2wU7ltddkzW83TjnLXlb9ycnJuOWWW/ILJtl9JuwPYxQdrDin7rrrroOdGTcuAH9sLvoeE737Mbdx7CnZWLPBh+nTw/N8jRs3zh89qPFszoF7Ps775dzfESNGRHxfRkFXVrSCNG/jQ8NW2aWyuC6OI444wsxupxuSuvidA3PoHHl0wgknoHfv3iF9rr17gfHfBdBnYBaSkkP6VCIqLK6zjEhbGrfec845B82aNcP27dvx+uuvh/IQRRCxHKw4Xo8NveWFtbIBrx8dumnfLyJHp165yMj+b7ElRw9WqFDBuKp+//330Sfws+qQMzQ5S5MXfTTz11/A6DF+dO6XiWMGqzIyIRE4//oMpPpycO/9B1bHOJlOnTrh9NNPNxU9tJYV9oddHKwU5Wxyzih3K+qaDQ2VqwYweFQmfp7ix4wZcARDhw5F586dTRfTmDFjIn04ogRY4sHIkSPRtm1bx75ms2cDP07y4+SzZM1vN6v+U8/LwLTf/ZgyBbbgyiuvRM2aNbFy5Up8/PHHkT4cUQxc91qJHs6p47w6u2KsaCcE0HdQtrF3F+6gYTM/mnfMxodh7OLnuBx2n/3000+YOXNmeJ5UlBm6V3HOr5269xu2zjbCrhDk2CHZWLrcjz//DN7rYRV2v/HGG9i0aZNeaJuzdu1a44Jb8L0LJRxtk5Gr7n0RHNp28RmL6wkTSl6lRDcka/zgE088gYyMDL0dNmfq1KnmFh8fb5p5g/KY0wJo3iFHY0JERKlaPYAGLXIxbdqBMYx5qauvvjriXfwREfhZJWoJnJylyZma0Qpt6B98xI/6rTNx6rlZUWfLX5QwduGN6Vi3JQcPPxJATo67uviZkF7mlOHcUcquXbvMHMZo6N5X12zo6HpYLlp2ycLzL/qxbx9sD2e4W3GKNv2cQyrsCztiOdfa6d37XAO//W4ADVplo/vhqsy2G+27+dC6Wxbefc8POzTMc87ZzTffnN/Fz04mYV+++eYb4zTC9432/HbGsqLtO1AF127jmFOysWqtH7/9Fp7na9q0Kc477zzzvVXgIuzLK6+8Yub8ct4v5/5GEgq4FHLVvS8KwrnD9VvkBLWL/6ijjsKRRx5p3FWffPJJveA2h04LdK469thjcfjhh4f8+SiqteiYY4p9hSgvTKd27pODGTMDyMws+b/jWorOSFu3bjXFSMLeWGveiy++GA0bNiz3423bBiz+248uvWyQhBBRT+deOZg1J2CaJAvC3BS17VmzZuHHH3+MHoH/ww8/NLMzOUOTszSjFZ4Q9z/gN3b0Z1+ZiQgWituS2vUCOPuaDMxZmItXX7WBL2wQ4HzrIUOGmFmk6uK3N88++yxSU1PNe8bZ5G6F9jLqmg3tRua0c7McZdVPp5H27dtj3759eOGFFyJ9OKIE3fvDhw9Hhw4dHPtasbmRVrSDTlWho507x9ZvsU8XP6ukOfOMxZIcfSTs373P+XR8z+wKp9J8810Ahx8rK1o30qSFH03b5XXxh6uxgl1n7ASfMGECZtOmRtgSurVxvi9hsSSdFyLJx58EjJBLQVeIAyyuh2Rh0VI/5s8P/ng22l9v2bJFL7hNWb9+Pd56662wde9v3QosWeZHZ4lqIoh06Z2LlIzSOZGwE/zOO+/ML3LJLE11gAgrv/76K3755RfjvHDHHXcE5TE5Xov2/O26SuAXkadTz1xk5vpN/rIg1LfpMkkefPDBiHTxh13gZ8WhJWxyhiZnaUYrFK137PfhvOsyjC29+C+0pTtxRCa++d6POXPc8QpZC3IWutBeVtgPzh7nDHK3d++zyOi55/1o1jFLXbMhpFKVgJljPXGq38yPclIXPwtd9u/fH+lDEgdhyZIl+Oyzz8z31vvlRLj2HftRAI1aZ6NZ6zB5J4tSU6+RH226ZeOjj/2wQ8N8pUqVcOONN+YXurBwUtgPzqHjPDrOpeN8OjvzxRcB5AR8OOI4de+7lWOHZmHFaj9+/z08z8du8LPPPvuAgjxhPyhscr4v5/xy3m8kob66cIkfhx2TLWdH8R9atfehSu1cTJ4cvMTxwIED0bdvXyOaWYUuwn7QnpxOuEcffbRxXQg11szrdl0kqongUaN2AHUb/9fiujguvPBC0w2+efNmvP3223pLbIq11r3ggguM60KwnERadsqRZiZs4zbeuGUOpkz9bwy79dZbkZiYaEazTZo0yf0CP63JKWpyRoFV3RCNsNrjp1/yZs1WqeaMrs5I0WdADhq1ycZzY/xIS4Pj6dGjB04++WSTjH7ssccifTjiIHD2OGeQcxY5Z5K7lbFjA9ib5sPp56lrNtR06ZNn1f/a635HjBw544wzzDx3Fru89NJLkT4ccRBYLMnKUDoudOrUybGv0axZeVa07BAX9uaYwdlYs9GPqVNhC9gRXrVqVSxdutSMqhD27d6n4wL3fnaFI3S++TaAPuredzVNWvrRuG02PgiixXVxsCOchZPjx4/HX3/9FZ4nFSWG83wpnFmOC+w6iySmEDhGopo4OOw56NgrB7/+HrwRlgW7+F999VVsox+ysBWbNm3KtyYPR/c+mTItgFadJaqJ4MMY9vusADIySv5vEhIS8jvCH3/8cTNWRNgLipo//fSTcUHieioYbN4MLFvhN84PQtiFTr1zMXde4D8jeOvWrZvvUh+JLv6wCvyckclZmdZ8As5ijEbYNTvmBT+adVLXbEk3MsMvysSOfT783/+5oxjC6rZ87733sHr16kgfjigAZ45z9rj1PjEp50Z27wa+nRDA4YOyUFlFRmGJYycOy8LmHX5MnAjbQ0vZe+65x3z/zDPPmHEVwj7QlpwFk27p3m/QMltWtA6gQRM/WnbONu+ZHRrmq1Spkj/TnUKyuvjtBefPcQ4d59Fx32dnfvoJyMj14YhBShi6nWNOzsbylX4sXBie52vdunX+THer4EXYB4pmnOvLTjPO+Y00FNXUqSaKgkLH3v0BzJ0bvNfpuOOOQ+/evU3By9NPP603wGawCImCJjv3jzrqqJA/36ZNwHKJaiJEcJZ6WqbfjAotDZzpXq9ePWzYsAHvvPNOqA5PlBFrjcu1VNOmTYNmz484P9p2lsAv7EOnHrnI9vkxY8Z//99tt91mCpI4rmJKmGdbhlW5+vrrr01SmvMX2ckRrXAO8950H04/V12zJaVq9QBOGJGB734s3bweu9KnTx8cf/zxpuhl9OjRkT4cUcimkbPHOYOcnbFuhVa0ufChn5LZYaNWvQDa9sjGR5/4keuANeqIESPQqlUr7Nq1K79rQNgDJt8oZg4ZMgRdu3aFU+HoncV/+3GMuvcdw7GnZGPNBl/ehtsGXHfddahcuTIWLVpk5lwL+2B1xdKxjXPp7MzkqXmdahWis/Y8quBc84rVS28PW94ufnbJfvXVVyYXIuwB11GWJTnn+3LObyShqLZipTrVRNHUbeBH9brBjWEFu/hffvlljWezEbt37zb5qXCOjjROIhLVRIioVjOAek1zMX166WIYra9vv/128/2TTz4ZkRnX4uAsXLjQ7MPZJBSs7v2CTiLxCXrlhX2oWDmAxm1yzPiIwtSvXx+XXHKJ+f5///ufewX+sWPHmq/8Yzk7MxqhOP3z5DxrfnXNlo5eR+aiSbtsjHnej6wsOB5rduynn36KXCeofVHChx9+aL6yK9Ct3ft79+ZZ0fYemIWk5EgfTXQx8JRsbNrmRwRG8pQa2mtRPCv4+S0iDzs4xo0bd8DniFNhJ3jd5jlo2c4GQ91FiWjYzI/mHbPx4Ufhs7guimrVqpm5jERxyj5s3Lgxv2r9+uuvh53ZuBFYsUqiWrRAbaRDjxxM/y0AX5g+etq1a4cTTzzRfP/RRx+F50lFsbC7hp2AdIPhvNhIo041UVI69crBbzMDCKZL9UknnWQcR9LT0/HNN9/ozbAJX375JbKystCxY0cMHDgwLM9JUa115xzERbbmSbiYzr1yMHN2oNQjeC+99FJUqFABq1atMi5hwh5Ye3A2n7Ro0SIoj7lhA7BytR9d+zhgvqmIOrr0zsG8BX7jjFwYK0c7ceLEsI49Cpt6RXvf7777znw/cuRIRCNMhL73fgD1W2Sj22ESdMuSkBl6TqaxuP7hBzgeLtA5j3THjh1ht+4QB+fvv//GggULjLA5bNgwV3fvZwVkRRupros23bLx0cfO6OI/44wzTKHL7NmzsWbNmkgfjgDw888/m1EitKijVaNT4aZt4RI/jjwu23y+C+dw5PE5WL3Oj+XLYQusfQUT0rSXFZHHKkLq16+fsb62M+xU88b70aaTAz6URdAsrnfuCWDBgvDHqU8++URdZzaB7wU57bTTTGdgpKGo1qaLRDVRssTy/rTgOluyM5zubVYDirAH1nvBz5BwdO9boloXiWoihHTunYvMHD9mzizdv0tOTjYicsHPcBFZ6KRgvRfB1PrM51uMH607qBFE2I8O3XORnRvAX3/99/+xyKVnz57GKeyLL75wn8A/fvx4ZGZmGrtfJ9vJljdALVnmx8ChSmaXlRq1A+h0WBY++cwf1IrlSFBQRNbixF4bqEGDBplRIm5k3z7g6/EB9DkmS1a0EeziX7/FDyfU9dSpUwcDBgww3yvZYw+szwsWX9AGzalQVItJ0Ew1J9K8jQ+JFe1j08+xR02aNDHFxLLpt1ecssQCu9vzS1SLLho09aNKzfDa9A8dOtTMZGQxMUeKiMjCMXlWIZId4tT69cCqNXQSUaeaKNnYt9oNgx/DrGvhhx9+MMXEIrKwEWjSP7Z/4YpT06YBsQl+tOkoUU2EjirVAmjQvGwxzLoWPvvsMyOgicgyZ84c0wjE4ouTTz45aI+7YkUAdRv75CQibEmFikD1Oj6sXFl0nAqn1ueNRKInHJWHduzepxVtvRY5aNFWi6XycMzgbGzd5cdPP8HxWBc9q3pycrShjzROSkiXFY4ozvT5TNesiAz1GvnRums2Pv3MHhbXxRGJxYk4OCyU5Axfp8cpnvdTpsr+0alwek2HnjmYMs1vixjGfcWZZ55pvlecijzr1q3DzJkzzfsyfPhw2Jl164DVayWqRRtMRXTslYNpvwXC5qZUuXLlfJt+xanIM3XqVGzfvt0UdIfL9rooWDBHUa21RDVRCpv+3/8IIDMzeC9Zhw4dzI15KWu/ISIHc4QsRurevTtatmwZluecNz+AZu1zEBsXlqcTUUy7rrS4DqC0Gv3xxx9v1lQcB/b777+H6vBECbHWtKeccooZnxAslq0IoH4TaWfCvtRp7MPyFQdPhrEZi0ybNg2bN292j8C/b9++/I4aKwEXbcydCyxc6sfAIVmyoi0nNesE0LFXNj7+1A+na+L9+/c3HbK7d+828zlE5GA3zZIlSxAfH2+6bNwIhZhfJgeMRXyFSpE+muimd/8crFnvhxNc708//XTTKf7XX39hxYoVkT6cqIYdNSkpKWjYsCEOO+wwOBUjqq2TqOZk2GW4dUcAS5bAFlj7i2+//RZppR3oKIKK5fbCNS5HidgZS1RrJVEtKm369+4/uLViqChYiERLUxH5hDTXuHFxkVeypk7LK/6VqCZKSudeuUjJCK5NP1HBZPQ2n1BoXbEygIbNJKqJ0NOwqR/pmQFs3Fi6f8eROla+VgWTkYVrWWvfF0ytj1v5jZuABhL4hY1p2MRnPjN9B/nIpLsk87W8RizHMFcI/F9//TWys7PRrl07dOzYEdHavV+nSQ5atddiKRgMPCULW3b48fPPcDQUzazuJi1OIov1+rMitGrVqnAjFNUoKjOpKSJLy/Y+xCX5bWNxXRQ1a9bM725SnIos1uvPDZSXbdQORaKa82nS0o/kKr6wWlwXRY8ePdC8eXOkp6cbkV9EDqe4IeU5ifhN0WNsbKSPRoSbug39qFYnF9Onhy+GsbspKSkJK1euNEWTIjKwO/nzzz+3TZxKSQHWbQjIEluUenRltVq+oBdaWtcEm0927dqldyVCbN261TiNhLNJbtMmIC0jYIRXIUINu7Nz/YFDWlyX1KafLhciMtCxbf369ahYsWK+S1UwWL0a5txQLBJ2pmFTPzKyDl2kFG4n3LBkh6Pdnn/tWmDBYj8GnKzu/WDOHWNC7tvv7ZFYLg/WRU8btKysrEgfTlTCqiqnJKTLLaol+tGqgxbBkYZiQtvu2Zg81R4W18Uhm/7IQ+Fy/Pjxjo9TEtXcAZfzHXpmY9qvpbdWDM3xeBSnbACFS85iZAHSsGHDYGc2bADWbQyYLkgRrTEsB7/+Hr4YxgSoNZ9UBZOR45dffjHCZa1atTBgwABEGoobuX51qonSU7fJoe1hy0qbNm3QpUsX5ObmGot4ERnY8cf54n369EHTpk3DFot8gYC6ZkVYSEoGqtc+9Azrohg0aBCqVatmCmGmO6FjxqVYa1k6KrCANVjwnPDG+lGrng2SDEKUsUiJNv3MUc2YMQMbmHhwusBP6/Gf/hmW7uSEdDBEtTadJKoFk26H52DFKr9J0DmZfv36oUGDBmaUxY8//hjpw4lK5s2bZ6zHafc0ZMgQuBFLVGurTjXbQCeFTVvKVrUcbk477TRjYWqNshDh57vvvjPW482aNUOvXr0c+xawInv9poCcRFwSw3bsCmDRItgCa5/x/fffY//+/ZE+nKjEsmk85phjULt2bdiZZcvyEtnNWmt/Fq20aOtDSmrAdC2GO07xWpFNf2QT0nTRi7WBfQf3ARwVUrOuAyp+hS3tYYNdpKTC7sgTieaTVauAqjX9RngVws5FShyryvwUUcFkZGABEh0UQhGnVqwIoE4jH2JigvqwQoSkSImfnQeDOt8RRxxxQI7E0QI/u5JZ/dm5c2e0bdsW0YZEtdDRuoMPMQnOsLguCnY5sbInXBe9+C/W637SSSehUiV3DqeXqGY/mrfxIb6CzxExjBXSxx13nPlecSoyFJxv5mQ3pNmz8xLZLdpJVHM6jZr5UaGaD7NmwRZwr8HOM7ohWW4XIjJxyglF3RTVatT1ISEx0kciIgVne7LII5yFltxrVKhQAWvXrsUsuwTPKIJjI7/88ktbxSkmsus2yjWuEkKUhgb/zLAOdpGSdW1MnjwZ27dv15sSZjZt2oRff/3VfG/lCcMBhda6jeVqJJxRpGTFKY7coeYkwgtj1ObNm1GlSpX8PGGwWL4yYLqjhXB6kdKIAoXdjhf4o8H2uiiYMNiwOYAuffSBE2zi4oHWnXMwZWrAERbXRWFdH19//TUyMjIifThRRTTZ88cl+ySq2QhWpLbvnuNIm351nYWX1NRU08Ff8H1wKsuXB1C3aa5mXrsAihENmuUG3R62rMimP7IsW7YM8+fPNx2xp59+OuwOE4r1Git5FO2dF+xWPFTnRShITk7OdwtT11n4obPk3r17Ua9evfyumkizbEUA9ZsqFokyFimVcYZ1UTRv3hw9e/Y0HZoUz0R4sbpiGaMaNmwYludkLoKiWgPFIuGQIiW6hdWsWRM7duwwxUgivFhrWDopJCQkBO1x09OBDRs531zrIuH8IqXhw4ebpl4Wda9Zs8a5Aj8D7aRJk1yRkC4rLLxkhyYtAEXw6dI7B2vW+7FunbNfXc7WatKkiRFxJkyYEOnDiSr+/PNPE2iZcLPmYrqRP+cG0KpTjmyObEaH7rnYuj289rBlhbO1uHj/+++/sXDhwkgfTlTBbmQWf7Vq1Qpdu3aFk2EimwlJ4Q6YCGRC0C5FStZ+44cffjAijgh/oodzMatXr27rl97nA1auUiwSMN2K4S5SKtjNQQFNhD9OsSs2xgberykpwNZtATRsovNAlLFIqdah7WHLg2z6I0ckmk+Yi0hL57pIsUg4o0iJBcXDhg0z36tgMrzQMWHcuHEhiVN0nuU5oVgk3FCkVKdOHQwYMCAsXfwhFfi/+OIL+Hw+9OjRAy1atEBU2vNP86NdN4lqoaJVR5+x+v3HwcqxsOuMtstEi5PwYr3ep5xyirHMdCM5OcCatQE0aq4Nmx3FMdrDhrN7rKxUrlwZJ554ovlecSpyiR4n2/Pv2QMzs71hU8Uit8DNNxOCdilSat++PTp27IicnBwzJkyEDye5IW3YAGRksVNNsSjaiUSR0gknnGDWVLRhnjFjRvieOMrJzMw0bnl2ilNc/+f61akmyk7dxmWbYV0cVm5q2rRpxoZZhId169Zh5syZpuOPnX/hggIrcxIqwhaRKFIqqwuJ9VlO7YkjeER4mDp1qhnfUqNGDQwcODDo6yJPrB+162uPJtxRpDSigBOuYwV+y1rILhuocLNzJ7BlawBtOsueP1TExgJN2uZg4SKbtI6VA+s6+fbbb2XTHyZoMx6qykM7sXYtkJWjDZsdqVARqFLDH9b5r+XBuk6sz3cRego6uzg9TnHDxgWwLNfcN8PaTkVKilPhZ8mSJeYWHx+PU089FXYnP5Eti/6oJxJFSnRDsq4TrafCx48//oiUlBQ0atQIhx12GOwSi9isULOu83MZwl1FSo0bN8bhhx9u8iUUz0R4sHJTRx11FOrWrRvWWMScBHMTQjilSKl///7mOtmzZw9++eWXoB+bODjW2pUj2eLi4oKeu65V3yfnWeGYIqUqNf0oyn2f1wldw/766y+sCmHSLGQCPzv3f//9d/P9SSedhGiEi6TcgDrVQk1Dm9nDlpXu3bsb+4709HTMmzcv0ocTFbBzhlXSrJA+/vjj4Vb4GRKAH/UbqQrSjkTCHrasWB38K1asMGN4RHjGiLAinQlpdiY7fV0UnxRAtZrOON+FM4uUrHE77IxlYlqEnt9++8187devH6pUqWL7l5zna7XaPiQkRfpIhF2KlMIdwwrGKREerNeaa1nu/ezAypUBsw9wsDmTiDB0xQpVkZIVp6zPeBF6rNc63Dn09esDqN1AjWki/NRr5Dduo2WBohldkYjWU+HDeq1DEaf27QsgubLy1sI5JFfym5Fbh6JmzZr5hcWhXE+FbGezfPlyI1TS8rpt27aIRpgo4BtduaqSi6He1KSmBeB05zDaLnOcBZk7d26kDycqsF5nWvomJyfDzbGoZj0/4uIjfSTC6UVKFG44B54oToUH63Xu2bMnnM6KFQHUbaJEttuwW5FShw4dTCf53r17saaocmoRtXGK52s9de+LCBYpWXu+BQsWyFY2TMyZM8d2cWr9hgBq11MiW5Sdeg39pkiJo2eCjXJT0bOe2rcfqFDZPmt5ET1UrBRAWlreiOPyxCnrM16EloyMDOPaFqo4lZIKuDg1L1xIYnIAKSmBiK+nQibwW8G1a9eupqoqGlFFdnhw0gzr4tDiJLxYccp63d3KMopqjVWRbVcaOKxISXEqvLgpTrGQRbMd3YfdipQo7nfu3Nl8r2RPeHBanNqwKYA6DSSqiTxq1MvFpk3hDWDNmzdH1apVjbi/ePFivRUhhm4uVlLNTnFqfwobQmzy4SkcSVKFvPVXamrwH9u6Vti8tX///uA/gTiAXbt2GXdJ0q1bt7C+OimpASQlKxaJyMQw5vMp8pc3NyXnttAzf/5849hdu3ZtNGjQIOiPT6GU54QQTiGJAn9q5HPoIRf47bSBCidcZFNUo3AjQt95Ubm6vexhy4qEs/ASDXEqNxdYs0ajQuyMHWdYF4XiVHhxS5xiLNq+A6hVV+sit1GrbsDYw9op96s4FT5ycnJMF3LB193uezQmEZMrKnkk8kiuEMD+EIhjxTm3cTwbUSFS6KGbC2f0sgDMTuOOaOmZLFFNlAP2UsUlBEIi8NeqVcuMCCOcHStCi/VZQLe8cI87YiySwC8i1f1aniKlLl26mLE727Ztw2andMy4JDfFtWyw4Xqc54QQjhL4U0rWwc+1FAtkQoEE/hCxezewey9FtdC8ceJA2J28YqXzPwSsi56dHLS+EaHFLcJZUezZA2TlBFCjtkQ1OxcpJSQGsH07HIGEs/CRkpJiumYKvu5OxVjvQRXZbt3UWKKpXVCcCh9cs2ZlZZlkdIsWLWB3MjMBny+ApCTn7xtEcEhKZmI5/OeD4lT493ydOnUyIr9dCh8zs/K6F4Uo7zosVGswxSn356YscTWpQlifVggDi9z4KVjWGMZRqxy5SlQw6fw4lWYs+rUuEs4hqUIAqcXEL46uZ6xKS0vLz+86QuD3+/35FZ5OT0iXlV27+DoA1WooMIWDajX92LHT+a81LW5odcOKHqsbSoQGVndu3brVVHtylIhbsRbKSh7Zm8QKoUvMBBur44wWgrQSFKGDaylazbF7hl00ToaJIyaQNFPNfYTSHrasyK4x/IkefjaEopMj2PA89Qe0LhKls1YMBRLOoruoW4WPIliw2zFUazDFKffHKfYV+QOy6BfO3UcqTrkjTqnwUbh1HxkTE5OvO4WqECkkAj+rEVJTU011AqsUohGTyFanWlg7LyKRmAk2TIxqcRIerKDarl07E6vcipXIVhVk9CZmgg27NFu2bGm+V5V09CWkyyvwq9jIpYkZ2CuG0YKZXZq0ZF67dm2kD8fVOC1OWeepYpE4oPMiJfyvh3XNsKiboy5EdMWp/HVRUqSPRDidxGS/BH4XEKk4lZ8vkpuIcOg+Ujn08ECXYTq3FXzNg4l0NOHUGJaeTofAyMapkAj81sGyOoFVCtFIXmCSqBYuuBhN+2eT7HS0OIneRE8o+HeRFOkjEZFKzIQCxanw4KY4ZcUizVRzr7WinWIYxX1aMRMVIoUWp8Wp/A5+WfSLAvvIrGwg3Bo7R1qwaJIjLqyEqQg+dEKyY5xS4aMIFglJxc9/LSvWNcMmLo4OE6GBrnhWQWq3bt0ikrvWHk1EgsSkf8dElBXlpsIDC1LpNkxnyYYNGwb98VX4KJzacBxA8Y68jhb47bSBCjfmw8kTQHxipI8keiwxcnIDyMqC49HiJDxES5yyFknasNkbvj+hSsyEAsWp8OCmOJVnRavCRzdi1roee3XwFxwnIoE/dLDreP78+Y6KUyp8FAfbR0bChYTObVacmjt3rt6YEMGRUnRziYuLM+4udkGdaiKY3WOh0t45PpJCDgtlrDGsIvhYnwEs/KpatWpYX+J8UU1zr0UE8Hop8pdvDcbmUo5e5QjWLVu2BPPwxEHiFPd8oRjLpsJH4eYxIz3+yZVwLcXR9sFGAn8IE9msRHPAKEpXYMf5r2XFuujZyZGZmRnpw3EtbhLOiotFcQkBxMZG+khEsYkZB8UvCfyhh10yy5YtO+D1djIqfHQvXOuycrm4quVwozgVepYsWWK6jytXrmyS0o4pNlLhozjIPjISMUxxKnx7Prq6JCQkwG6FjxLVRHmhU19KWugKxRWn3J2byotFAVn0i4iRkFx892tRcOQqR68SFXY7N07xHPBr1LVwYqF4oPh9JEfYJyUlmZH2dEWyvcDPKgSrstMNCenyJLLVMRvuuT3uEPhZIU3Lm9zcXGOBI4IPqzp5Y5Unqz1dH4tkQ+uIRUFKqnM6+K2OM1oJ0lJQBJ958+aZbhl+JrB7xh2xSIWPbsWOY0YKJqR5LYnQJXr4mcA1lRPgearCR1FYHItUobiEs+gt6ub55vEGEG+fmgPh4FFJoSwUV5xyd5z61/Ex7E8thIHaSXnXYIpTzo9T1jmgwkfhtFFvgRI4wcXGxubrT6EoRAp6JmbFihWm64xVCaxOiFZiYljsEOmjiB78vn9fd6dDqxstTkKLFUwZoypUcPdwel4T0jXsDz8vnBS/aB1odWvKVja6EtLlikVaF7kWv99juxjGbk1aMu/evdtYNIvg48Q4pVgk7LSPtK4djrpgcbeInjjFmqiAX3aPovz4QryPVG7K3XHKOne0TxORIhCEGKY4FVroLrxo0aIDXutgY50D0tKEk/CZfWTJcmGhjFNBF/itg2RVAqsTohVqhlkZ2rCFi4w0j7GIrVgRrkCLk+hM9IQqFmWkKxY5IYZVquCs90lxKrS4LU6ZdVGmRwVHLiUzzWPeYztBK2Zr3rLsGkODE+MUz9PcHA9ysiN9JMJu+8hIxDAWS3LEBROnHHkhggvdW+wap6y8RWZGpI9EOJ3MdO4jQ/f41rXD0WFs5hLBhYWoa9asOcAlL5zws4+fgelpzspFCHfFsPKuwZSbCi0LFy40hag1a9ZEo0aNQheL/jkfhHAKGekl30c6SuDnRU+6deuGaIYbNgr86pwNDxkZHvA/uyWXy4p1/VjXkwguVuVhNMQpxiKfEtnOEPgrwVEoToUWt62nlMh2L1zrsnjDjkWWilOhxYnrKZ6n3ITzc1eIgomZSMSwguPCtO8LPlu3bjWjpPg609XFdrEIHsUiEaR9ZOg+0+rUqYN69eqZghkVIgWfxYsXm69NmzZFtWrVELFYJFFNRAiee+Vdg1lrqc2bN5uiGRG63BRdh0O3R/Oo2Eg4bx+Jku0jQ5mbCrrAb83irVu3LqIZ643NSI/0kUTPpiYhHoiPhyuwrh/Ntg4N0RSnlMh2BiwIC2ViJhRY1482UKHBbXFKiWz3Yq117Sjwaz0VOthxnJaWdsDr7AR4nnqZyJbTmviH9DREtFBccSr0a6nq1asbVxc7YXXNSlQT5SU9HagU4jWY9n3u3fOZdZGHXbMReXoR5XA6UU5W+QV+jl6t9E/HjPLozoxTefkirYuEex3F6/5z/ezduxf+IM+iCLrAv2fPHvM1EpWHdkKJ7PBfUBUd1v1aFNb1Y11PIrhEU5xSItsZZKZ7bSmOFYXiVGhxW5yyio1k/+jSTQ3s2cGvOBU6uDEl7LSgxbjzCh8jfSTCTjEsOSm0M6yLQnEqOtdSSmSLYJGV7g15objilHvjlBWLtEcTkSAziC5KilPOjlNqThNO3UfGeDxITi7+d63rh45I+/btC+pxSOAPdUW27B/Dwv69HlSrCtdgXfShqOoRkd9ERSYWRfpIRKjnjoUbbaBCR05OTn5nrFvilDVTTZ1q7iOS86uLQ3Eq9GupqlWrGvtrx8Ui7dFEEK1hy4PiVHTu+ZTIFsHcR4Y6hilOuTdO5cciWfSLCMA8ZbAKxRWnnB2nKJAalzW5iQgHkZH+r+5SHPHx8Uj+pxIg2A293lAme6KZOnWAGA+wY6tzEl5OZu8uL+rWdpa9dVFY1w/F/ZSUlEgfjuuIpjiV3zWb6p7rw43zq1P2eWDD3GORWNePnEaCT8HXtEqVKnBTLGISUrgLWp2XdO5YuFGiJ3Q4dS1lzXeURb+wi8Cv9VR0xikmA5XIFk4pFFeccm+c4pjTuFiPCh9FREj/p4M/GDFMccrZcYpOWknJKsIW7t5HVg1RHt0bKrtGO1ZJhxOOfqlX14ON6yTwh0Mc27o+Fi1auEc0SEpKyp8TaF1TIjj4fD7s378/auIU/8TkJA+2bVYssiv79ngQ8HtQqxYc6zRCiyERPKy4T9vrmEh5BgcZbtppXZWW4p7PavGvi1JsbN7a185xSgQXp+758hLZSh6Jf6GbQ+UQ21sXheJUdMYpGp8kV1AsEuVHHfzOJtId/EZcragOfhFBi/4gFYprPeX89VQlxSLhwH1kpVLsI0MVp2TRH0LatPJg81p3JObtzN7dedWmLVrAVajrLDQUnHNix2RPKDZsrVt6sGmdYpFd2bjWi1ivBy1bwlFY1w/t5NPT5aPlpkRPqBLZDRsAWzep2Mht7NzqRdXKJZs7Fm7UyRE6nBqnuC6qXAVIVbGRKFBoWaN65F4O7flCh93jlBLZorzk5vAmi34nY4c4lReLIvb0IophLt/rCa7AL4dJ58YpE4s0Rk04rIO/UsXIx6mgZllpJ25VINjRBi3ctGrlwdYNsabDXISOTWtjHCmOFYcWJ6HBCqIVKlRAXFwcooHWjEXrYiN9GKKIGFajmgfVI5hcLgu8hmLZtqtNlCsTPaGKRZtVbOQ6Nq6NMUWtJZk7Fm60lgodTo5TTRt7sGW9io1EnhPc7m0xqF8/8h38SkhHX5yqUtljxnQJUVZ4/nD9Fep9pDpj3e00UrmiLPpF5Cz6vV4PEhPL/1haT7lA4K/kMeeEEE4hw40CP22vLZteu26iwgkF59wsL3ZuVXAKdferE8Wx4tDiJDoTPaGA7hZ7d3mRnhbpIxFOE8eKgjOMFadCg1vjFAsft22Igc8X6SMRwR2TFGPeWztiXUNZWVnIyMiI9OG4CifHKRYbbdugwkeR172fkeqNaKG41lLRG6eaNc37DBWirGze4EWsx4OGDUP7GipOuTtO8alT9qrwUYSfPTvyRlUGIxemOOWODn6ObRDCKWSll82i39YCv1V5mJiYaG7RDkW1WC+wfo02baFk45oYY0HuNHGsOCwXDM2NDS7R6DLCpCVnX8um337YXRwrDsWp0ODWOMVYFMj1YscWJZDcgh3EsaKoVKkSvJwPofVU0HFynOL5ykR26n5nfvaK4LFpXZ44FskYprVU9MYprv93bIlBbm6kj0Q4uVC8ejUPatQI7fNo5FHosJL8kYxTzZvTfTZG7rMi7Gzf4kWzxsFZj2s9FRrYyBuu9VT16h7s361ckXAOu7d7Ubt25OOU122Vh3aiUiXOvvZi6Tx1iIQKzolavyIW3bu7L0Gn6sPQEI1xqkEDoEKyx7hdCHthd3GsOBSnQoNb41Tz5kCMV7HIdeKY12OKWu0IxX0lpUODk+MUz1cWPmpdJMIljhWFdQ2lpaUhJydHb0oUxSmz/vd5sXWj9miibGxe5w2LE5z2fO6OU4xFzEkwNyFEOOEo0ZYtg3PeKU6FBq5Pc/+pRAx1nGrWDNi1NQbZWSF9GiGCwv49HmRnekvlouSIDn47VB7ajaP6e7BiQRyyMiN9JO5kyV+x8Aa86NcPrkOLE/duoMINmxfpcrF+ldxE7AbfEzuLY8WhOBUa3BqnkpOBRg3zuo2Ei8SxqpEVx4pDcSo0ODlO1a0LVK5EgV+xKNrZtDY84lhRVKlSJf/7YCd7oh27xykmsuNiPNikWCRsII4VhdZSoeuMtUOcynOfpeOjio1EeMWxtBRv0HJhilOhwYpRcXFxSGZCJ8TFRl6PB1s2KBYJ+7Nxbemd4Bwl8Nt1AxUJjjgC8PjVxR8q5s+KRecOXtSsCdehxUloiNY41ae3B6sXq9jIbiz8MxatWjg3hilOhQY3xykWG21eJ1HNLdhBHCsOdfCHBifHKZ6vjEVKZEc3eWOSwiOOFUVMTEy+yC+BP7riVEIC0LSJ3ERE+cSxcDjBWddQSkpKfienKD8ZGRnIzs4+4DWOBCzUZcGuCh+F3cWxolBuKvRrKU+IN/1NmgAJcYpFwhlsXMs9nAe1arlM4LfmB9h1AxWpDpH2bbyYP1s2/cEmLRVYuzTOuCS4Ec0PCg3RGqeOPFLFRnaDzi50eBng4BimOBUa3Byn2rTxYNuGGGRlRPpIRHlhfnfT6ji0bm3vGGZdR8GecxbtOD1OtW7lMeKuiF5S9nqQHiZxrDi0noreONW6FbBlvQofReTFsaIo6NK6b9++0D9hlMUojpSqxBmvEYKaHQt2WbgrhJ3FsaLQWsr5a6m4OKB5MxVhC2ewaZ0XbUvZ7BKqOBXUT+/09HTzNSkpKZgP63goQLNzNlPJ7KCyeG4sYj3utOcvSHx8fKQPwVVEa5yqXRvo2M6LebOUzLYLfy+INXM3WXzhVHw+X373mQgebo5Thx+eV2y0ZJ5ikdNZuSQGuZle9O0LW8OZ1rGxsSHvOIg2nB6nKIik7PEidb/Oi2glnOJYcWRlZSExMTF/XSWCY33thDhFB4ntm2JM0ZwQZRHHwuEER2tmQhGa8UoEh4IxKtLrVMYiFj7S3UYIu4pjRZFAW5wCX0VwCPdaisVGW9YpVyTsz9b1sWjVqnQBzMqdB1vrC6rAX7lyZfN1//79wXxYx0PxJibgxbyZeYtiERzm/BqPrp29qF7dna+oZX3m9/sjfSiuIprjVP8j84qNMvLWZyLCLJgdi/atvcbpxcnJUxLphITbcHOcsoqN5GzkjjFJTRt50bQpbA3jE9dUKkQKLk6PU+3a5c2bXbFYBWrRyvLFsahTOzziWHEwPmVmZiopHeTY74Q4ZQpMfF5s26TOWVE6Nq8PrjhWnJW8ZdFfoUKF0D9hlGDFqLS0tIgXeDEW0dWG7jZC2FUcKwpeRyTS15LbCPdairFoxxYvcvKmlwhh3zFJ+0vvBGcVSQZb6wvqLkIWmAeHSYMBR3oxdUK8KrODxKqlMdiyOg6nn+bexafdZwY6lWiey3TEEYA3oM5ZO0B78pUL43DUUc6OYYpTocHtccpyNlKxkXPJzQGWz4vHgKPCk1guD4pTocHpcYr7MxUbRS/MqSyZE4ejjvTaIoYpTkVvnGrWDIiN8WDDahUbiZLDGmt2OAZTHCsK6xqKtJW82yiY64v0KCmKFHS1obuNEKFm/96yiWNFobWUO9ZSLVpQrPRi8wbFImFvB5IYj8ecr3aIU0G9Wqw5AnbeQEWKkSM9yNgbi79+l81IMJg0Ph7tWnvRqxdci3UdFZx3JspPNM9lYjK7cwcv5v+hOBRpFs+LNTblLLpwMopTocHtcYqjdUyx0V+KRU5l2aIY5GZ50b8/bI/iVGhwQ5xSsVH0snpZDLJSY2wxJik7Ozvf/lT7vuiLU4mJQId2HiydL4FflByKsBn7Y9C5c/jXUhT5RfBGH1iOCJGOU8wVVa1KgV+xSISeTWvzxLFQCPxaSwUX6/Xct29fWByGmzQB4mM92LROsUjYl03rYlClssc4lNohToWkg18C/3+hfelR/byY8l0C5BZT/oTMhuXxOGuU/bvGyoO1wFcHf3CJ9jh17EAP1iyJx44tLr54HNBx8fvEeHTr7EWtWnA0ilOhwe1xigmkLh29xuJdOJP5f8ShZXMvGjWC7VE3R2hwQ5xikV0svFg8V7Eo2mCxa/26HrRuHekjOVDUqVKlSkSPxW04JU6x2GjN0jik57kLC1GiGFazugedOoU3Tkk4Cz52aZRjbrVda7mJiPCwfk0MqlbxBDUfptxUaNdSFPc5piXUcDR582YeUwQihF3ZuK5sY5JCFadCJvBbc3nFv4wa5UHarljMm6kkUnm799u09OKww9x9dikhHd2JnlBxzDFA3Zpe/PJdfKQPJWpZvigG29bHYdRI5xdZKE6FhmiIU0xmr10ah7TUSB+JKC2ch7d8QRwG9Ld/DMvNzc1PRKhgMri4IU7VqAF07ujFgllxkT4UEUZYbL/0L8Ywe9nzU9yPiVG3UjTGKavYSM5GoiQw1bp4Thz6H+FBuEKG9nzREad69vRg3fJYFRuJkMMYdliv4DbtKU6FhsTERHMr+BqHmtYtPWYMjRB2ZWsZxyQ5wqLfOjifz4e0NJUfF6Z5c+DIvl5M/jYBubnBfOWjhzXLvVj/dzzOdnn3PtHixP0bqEjAasiRZ3qx6I8E7Nzm8ovIpgmZSd8koHN7L7p0geNRnAoN0RCnaNMf6/FiwWwJa05jMUcr5DhjxAitBC3UdRZc3BKnTLHR37EqNooiVi2NQU66Pez5idZSocMpcap6daBLJxUbiZKxfpUXaXti0T+MhZaKU9ERp8z+TM5GIsRs3ejFnq3Bj2GKU+6JU3TY2rE5RvszYUt27/AgdZ8XrVrBnQJ/cnKymSFkl8WJHTn3XA8y98aZLnRR+o6xL99NQqd2XvTt6/5XT4uT0CCnEeD444Ha1b2YrC7+sLNyaQy2ronD2Wc5v0iJFl2WeKbOWPcmekIF/8T+/bz49Yd4jS5yWJHS1O/j0aObFw0awPZY11DFihXz9ygiOLglTnFPwWKjRXPUJRItcDxM4wYetGgBW6A9X+hwUpzKKzaSs5Eonvmz4lCnlgft24fv1VKcio44pWIjEa51WNXKHnTrFtzHVZxyT5zq3RuI83o0Rk3YkvmzY1Ex0VumGOYIgd/j8dhmfpBdadoUOGeUF79NSMSmdZonUhp++ioeGXvicPNNzhfGSoLmnIUGK0ZlZ2cjMzMT0drFP+IMLxbOTDCVZyJ8/PJNPDq286J7d+e/6vv3788fx6PO2OBivZ4F5/K6kZEjPUjbrdFFTmLJvBjs3pxXpOQErP2IYlTwcUuc4t66Wxe5iUQLdNFbOjceA46yhz0/0Z4vdDgpTuUXG/2pYjRRjD3/n3n2/N4wphM12zp0WEl+u8Sp/GKj0I/aFlEawxbOjsORfT2IDXJtrdZT7llPqdhI2JlFs+JwWG8PkpLsE6e8bl+c2JEzzwTatojBZ28myqq/hKxb5cXMnxNx4XleNGoE10PRTNWHoaFSpUr58y2juRDpxBOBmlW9+EVd/GG1hN20Mt4V3fsFr5+kpCQkJCRE+nBchZ06OcI1usjvj/TRiJIkZH75JgHdu3jRsaMzXi+tpUKHm+LU0QM8WL8sTqOLooBFf8bCl+VF//6wDYpTocNJcYp5vm5dPFgwW24i4tCsWRaDjJSYsNrzE8Wp6IlTtOmP83qxUMVGIgRsXu/Fvh2hGTGiOOWuOMVio3XL4pC63wXJU+Eadm7zYNvGsscwR3Tw23FxYkdYpXbTjR6k7oiXVX8Jrfk/fysJndvF4LTTEBWkpqbC5/OZ72V9HVzkNJIH9Vh28c//LQEb18pNJBwdY99+koD2bbzo2ROuQBuo0GHF/fT0dOM24mZGjfIgZWcs5v2hhLbd+Xt+DHZudE73PlGcCh1u2vMNGADUrenFL99qhJrri5S+TUDf3l40aQLboDgVOpwWp6xkdso+53zOivBbW9er7UHbtuF9XjkihQ67ueBWqQL06KZiIxG6GFajqgedOwf/sbWectd6yio20hg1YbcxSZWTvejVq2z/XgK/C7vWzj3Li1+/TzTd6eLQTPg8wVjzsyjin8Zr12Nd8PHx8aY7VkR3sidUnHIK0K5lDMa9JTeRUDPlu3js3xqH6651R/c+0QYqdFSpUsUUIxV8nd1Ky5bAEYd5MUVd/PYXxsYnoEtHLzp1gmNQnAodblpLcXTRmcM1usjtsDN637ZYnGWzIiXFqdDhtDhFm/6EWHbOquhRHLxgfMncOAzoH/4RI4pT0RWn+h/pwfrlKjYSwd9PcgzNkf2Cb89PFKfcFadUbCTsyMLZceh7mMc0TdrJrdvr9upDO3PGGUCX9jH44IVkzcE+BDMnx+HPSYm4/JLosOY/WIW0JfKI4KE4lYfcRMJnQzbtu0SMOtNrxEy3oE6O0OH1elG5cuUDXme3d/Hv2x4rW1obs3xRDLatz+ved9KyRLMYQ7+WoutUTk4OnM4JJwC1q3sxSV38rk0qTx4fjz49vWjTBrZC66nQ4bQ9H5d+RxzuwW8/x+MfMz8h8pk3MxY5aTEYODD8L4qEs+gS+FlslBjnxcI5KjYSwYPOoam7QmPPT7Sect96is5GLDbav9dBCQjhWrZt9mLX5rKPSaJDq5U3sa4p21v0Wwk1UbS4dv99HtStGou3n01GWqperYIsnReDb8cmYfipXtNpHE1Y14/s+UOD4tTB3URk1R+aTovP3kpEq2YxRsR0E4pToSWa4lTr1jCWyZzvzmtG2Au/H/jpywR0bu9F165wFEpIh46Cm9J9+/bB6bAK33Tx/56APTvd9XktYOw992y154gRradChxPXUiNHepC2S6OLxIGw4GPytwno38+Lpk3D/+ooTkVXnKpUCejV3YOFsyTwi+Ax/49Y1KzuQceOoXlVFafcF6cOPzyv2Eg2/cIOLJgViyqVvOjevWz/3rp+YmJiULFiRXsL/PXq1TNf165dG+yHdiW0HHn4IS9ic+Lw7phkM29eABvWePHJa8k4um8MLrvMWd1iwcC6furWrRvpQ3El1uuqOPWvm0j7VrLqDwWTv82z5r/5Rg/i4uAqFKdCS7Stpy64wIP03XGY9I1mYNuN6T/GYfemOFxysfPWY4pToSM2NhY1a9Y84HV2OieeCNSo4sXk7xSH3DdiJB49u3nRrh1sh+JU6Pd8TKjZSTwrihYt2MWv0UXiQOb9EWsKPyJRMO73+7Fu3TrzvfJToc1N0b7XLrBDceOqOOzc5rDFv7AluTnAwlnx6H9EaEbvbt++HRkZGcYBt3bt2sF/gignUrkpq9jo/9s7D/Coqu7rr5lJD7333qQLqCBVLChSVEQFFOyIWFGKqCgC9gKKoICKgDSRXkSUJioI0nvvvUMIqfd91omTN8SglMzcKev3Pvc/Q/g+czgz99xz9tp77dVLAyyYKvwOywLWLAtF3doO097vas98me3WnekC/7XXXmte//rrr8z+TwcshQoBb73pxKkDYRg3LMJ8aYKZ40ccJtmhcrkQdOvmgDPTv6W+j/v+qXGlaUHiX9E6dXGr/p+nKKidWezb5cSvMyPQ9v7AsuZPv0657yeRuQTbOlWy5N9uIrMisHdHED74fZQjBxyYOyXCuClVrAi/Q/spzxJo61REBNC6lRMrfw/DyeMKaAcK61e6cHy/b1bvx8XFYc2aNea9zn2ecRopyQ0GgOXLl8NfoIh7+kiIqRQSgk5K86eHm8QPJoB4m23btuH06dMIDw9HhQoV9IFkMpUrVzbVfEePHsWePXt8Zn7r1UtpXaSkR5EZLFsUivgYF5o398xezH0WKV++PKKjoz3yO4IZ95lv5cqVSPSy5SKTjfZtC8GpE763jxfBw8G9Tpw4eHUtRjwZQ8/0CKr7YLphwwbExMRk9n8+YGEvwJ7dndi2Khxjh0QErUXt4QMODP0gCgVzhJj2BbTLDEYUkPYs7nUqUALSmQFjX4+0d+K3WRGmv5+4OigMjPws0jgjBJo1P2F1gdYpzxKM69QFbiL+39I7IALK338dieIFQ9C+vf+tY6zWZFCaSDjzDIG4TjVrBuTK6lJAO5Cq96eGo0Y1p8csYa+GtWvXml6MtD4tXry43cMJSPxxnSpb9u/WRdPDg774Q6RYwjLhw64zpfveqVq1KkIDzZLOB4iIiEClSpV8LhEptXXRYrUuElcH9Y0FM8PQuIETRYt6ZjYVm/IsZcuWNZbidEnYuHEjvEnt2ik2/Up6FHay6s8Q5MjmwNVo855cpzJd4C9UqJCxGqCN06pVqzL7Px/QsLfIaz1c2L4qAl9/HInYcwgqtm9y4cu3s6BgjjC8+47TtC8IRpKSkkxWHKlZs6bdwwlI3NlSe/fuNVZOIoV77wXuvM2Fid9EYvtGD/hmBQnnY4Hh/SORIyIUb77hMA4JgQbvnSNHjphqg2rVqtk9nIDEvf4z0ONLdo1ecRM5GoafZdXvE9b8R3aH4qUu/plwuWLFCvNK0Sx37tx2Dyeg1yl/Es4upYr//tZOLF8YLjeRAGDJ/FAc3RuKhx70zSQl973DeymzrRqFf69Tbds6cOpQCFYvDcCDhLi8JKXp4Sbhg4kfdq9TIrjWKbYuypODyUZyeRRXzvLfQxB7KgQPPOC5fY7WKc/idDptc26jIQNt0f9cEGYKEITwNgnxwPJFYbipwdXF9z25TjmDaXPiD9SvD7z/jhMxh8LxxdtROHHMETQ9xYZ/HIXq14Tgow8cyJsXQQuz4c6dO2dshcqVK2f3cAKSbNmypc6t1qn/w7jic885cMO1IRg1MAqH9ssm+0qyk0d+Homks2Ho+5YTuXIhIHHfNxUrVkRkZKTdwwlIWMlBK8xTp06lViEHi5tI+3ZO/PZjBPbIqt9WRyW3Nb8v9qy+FBTo8TzuMx8txmk1Hii0bCk3kUDgxFEHfvw+Ai2a+mb1PtE65Xn8NTZFh8cbajkxb3qYqviDGCZ4MNHDTkc4rVPBu065Wxet+iMsaGLTIvPjY/NnhOOm+k540qhI61Rgr1P33ZfSumjVEiU9Cu+zZEEokmJdaNXqyp+DdLmn2z2RwB8k0J3p4w+diHaE4Yt+0aaPcyBnJC+YFYoJQ6NwR+MQ9HnLYbKzgpm0PTlYHSuC6xBlN8xG6/mKA6WKhJgq9NPqc3RZ69kPw8NxeHs43njNiWLFELDoAOV5aIFJK8y08x1MbiLGqv8rWfXbQVIS8P1X/mvN70brlOdhb2tai9NinFbjgbQXonNFzDG5ifjznmzCNxEokMuFxx7z3XVM65T3znxbt241SZP+RLu2Dpw4EIq1fymgHazr2LxpYbi+phMVKtg1BivVNl4V/N6JTfmac9udd6a0Lpo/Q1X84vJh+89zJzxbvU9nyT179nist7WwP4ZepgxQr7YT82aEq4pfeL16/9dZ4bjtZicKFrzy/w5d7ul2nz9/fuN+71cV/L7UP8jfYF+aTz52olShUAx5J9rYpAaaFcnpkw6MGBiBuROj8HBbF7p0CUwr68tFByjvoHXq4jDJ5q03HcgWEorhAyIRF+ulD8XPmTM5DOuXRKBrFyf+1mUDFq1T3iFY1ym3uHb+RBjGfxWhyjUvwpji1O/CcXxvmN9a87uRcOZ5aCnu7iEXaOtUiRLAQ23lJuKvLJ4fir2bw9DlBSeiouCTxMfHG/cLIuHMc7BFC1u1pG3d4i/QQee6Gk7MmRyOxAS7RyO8zfI/QnDiYKhJ9LCL7du3m8SYsLCw1D7xIvNhyzsW97B95L59+3yuiv/ee5xY8VsYTqn4Q1xm0vi86eFocKPTuPR5CvcZhC6tdGsVnsG9V2VLYbYW9jZMEqGjzZplEo6E91i6KBQJMS7jIpFZMXRPtGXzqMC/fv16xMZKGbpScuYE3n/PgdYtQowI/sU7UThy0HcrEC4neMwsvgG9onFqTwR6v+4yFWJqO5iCAtLeQRX8/06ePECft5xIOBWGIe9HmYQccfE1bcb4MCyaGYknH3WhUaPAnilWFWid8g7BvE5RXOve1YnNy8Px4w+qGPEW82eFYuWvEXjxOf+15icMRm/ZssW8l3DmWQJ5naKbSKVychPxR2v+2d9HoOWdTlSvDp9l3bp1RuSnCwbdMITn8Od16sknHIg9Hoqfp2ovFEzQRW/mmEjcepMTFSvaNw73PUNXMYr8wjOw5R1b36Wdc1+iWTMgRxYX5s/Ud0BcXivemGMhaOvhJCXFprwDEyjYSpgthTdt2gQ7WhfVvs6JuVPVukh4h8QEYOHMMNxykxOFC/v2OuURgZ9WA7QcYEYPLQjElcPKqSefdOCj91wIiw/DwDez4NefQv22mu3MKQdGfh6BiV9Fo9ENoRjyhRM33mj3qHwH3jPuygIFpD2L27pp9+7dOHr0qId/m/8KbB+854TzfBgGvx2FQ/sDt13I1dj1jP4iAst+icSzT7nQujUCnv379+PQoUNwOp2m2kB4p4Lf1+wavUG9ekCnJ1z448dILJ4XavdwAh4mX86dGIn2bZ247Tb4Ne69VLFixZCHGWvCY/izcHYpbiJdXnTg3PEwzJmioLY/wEfl91+nWPM/+qhvJ6e67xm6YHiikkMExjolN5HgXMcmjghHjigXOnWyd22QcOY9fHmdohPOvXc7sfzXMLVwFJcEHYjnTw9HvTpOlCrl2UnTOuUd6DLijqPbtU61bePAyUNqXSS8w7JFoYg7E4L777/6vZhfCvw8oPry5sQfqVwZGPS5E/c2D8EvE6KM2LZlvctvhP74OJg2A/1fj8bJ3RHo/ZoL3bs7IPecC9m8eTNiYmJMVlx5pqcJj5E9e3aULVvWvNc6dXG4GR/wiROFcoaZdiHbN7r0rfybmLPA1x9HYve6CLzxqgstWwbH1LjvF1YZRPmq722AQCtMVsucOHECO3bsQDBy111A67udmD46EhtWav3xFFzbJ34Tiaa3uvDgg/4vNCnQ4z3cZ77Vq1ebauRAg+Ja+3ZO/DY7Ant2KNHR1/ljXij2bfFta/6MBH7hWdxz7K9nPrmJBJ81/4614Xj+WSeyZrV3LNpPeQ9fj6E3bw5ki3Jhnqr4xSVW758+EoI2bTx/rtR+Knj2U3QYvL6mE7+oil94mMREYMHMMNzc0GnaqF8NdLeny73fCfz+sDnxR9j7qGNHBz5+34Xc4eEY+XEWDH4nCpvX+q7QH3c+xe71g+5ZMH9SNG5vGIovBztRt67dI/NN3PdL9erVTXac8Cxapy4NFj9++L4D1a8JwfBPokyVZ7BD+9cv341G7NFwvP9OcDmRKNDjPSju0xIz7bwHGyxqfOIJBxrXdWHcl1ES2DwA3VlGDYzCddVC8PzzgdEyKW2PM+FZSpUqhRw5chhxn5bjgUirVkCV8i6MHhRp3MiEb7JrmxOzx/u+Nb8b7ae8h/tZwGT606dPw9+Qm0hwWfPPGB2J2xo7Ubu2vWOhe5j2U/Y4t/ki0dHAA62dWDo/XOcx8Z+FMLPGR6BRPSf+rqnyGMeOHcOuXbvMeyVMBkcMnVX8Jw6EYt0KaSbCc/z1WwhiT4XggQeu/uxPd3s6dufLlw+Fr9br/yJI4PfTav7+nzjwbl8X8kaEY9SALBjUN8pUtvmK0H8+Fpg3I0XYXzQ1Gk0ahOKbYU4TOM6e3e7R+S4K9ATf5sRf4IGuz1sO3NE4BBOGRWH2pDCT0RaM0D1lcL9oZHOF4pOP/LtP9ZWgdcq7aJ0CnE6ga1cHKpcLwbcDonD0kAS2zOLUCQeG949EycIheO1VhxERAgGtU96Dzm12V3N4Gt4Xr/Z0INoVim8HRJoEZuFb8Lkw8tMoVLsmxLS383USEhKM6wVRIpLnyZs3L4r+XX7jbuHib8hNJPBhLO+Hb8ORM9qFp56yfx2jexhdxJhwXJlBSOFR2PqOLfAOHjxoWuL5InffDVQu58L3X0WaVoVCZMSUURGIcoZ4pcWI++xRpkwZ49IqPIt7z8q9FAVLO6hUCahZnVX84T6jgYlArN4Px031nShWLHNjU55qy+ZxgZ+VHLQiEJkLvw+1agEff+TA+/1cKJA1HGM/z4L3umbBtLFh2L3d6fWFjjb8q/4MwcjPI/DOi1nx+4xo3Nk4FMO/cuK55xwoUMC74/FHFJD2LhLOrqB6pIsDT3Rw4c/Zkfi8bxT27w4eu9q4WGDit+EY8XE0qpQNxScfO+Gh5DufRuuUd9E6lUJ4OPBGLwcK5wrFl+9Em32OuDoO7HFicL8oZAsNRZ/eDpPIFQicOXPGVGkSCWfeIRjWqXz5gL5vOXHuWBhGfxEBm2JaIgNizgDD+0ehUK5Q85wIC/P9aWKMJC4uzgSjS5cubfdwgoJAWKfoJiJxLXBZ/nsIdq4LxwvP2W/Nn/ZeqVKlihH5hWdh6zu2wEs7977qJhJ7PBRzpug7If7J2r9CsHFZOJ5+yolcuTw/Q4pNeZcKFSqYtYqthd3nbTto19aB4/tCsXGVqvhF5kPX4nMnMq/FiDfWKY9FR2k5QOsBZvT4qsVQoAj9LJr58AMHBnzkwu0NQrFjeRSGvZ0VH/SIxszvw4x9kqcqbWPPAWuXu/DdFxF4+4WsmDQ0GmHnItHp0VB8+7UTnTs7TEBM/De0NnVXFCgg7R3cFWe0dGKmtLi0NYcPuc/6u5ArPBxf9M2Cn6cEfjU/q/b7vxGNrX9F4qXnQvB2v+B0I9m9e7e5V1hdwFYiwvO4nwfLli1DYqDfaP8B77mPPnSgQolQfPV+tGzZroKtG1wY+m40iuUNQ/+PnaYVS6CwdOlSYyvLak1WbQrvrVNLliwJ6OkuVQp4vacTezeGY+p3qhrxBVhB+O2nUQhLCjVOU74gil0K7nuFZxFPVXKIwFunJK4FuDX/mEg0udmJG26AT+C+VxSb8h7+sE7RTaTDg078/lOEEq7FPxIup4yMQMO6TjRq5J3J0TrlXdhK2B0HtHOdoqlMjWpOzJoQITcRkek658+Tw806xuedv6xTHhP4eVBt3LixeT9p0iRP/RqROt8Akz2fftqB70Y68dF7LtxcOwybl0RhaL+seOuZrPi8T5SpPl2yIAT7dl2+6H8uJkXkmjczFKMGReDDHlnQ77ls+H5wFlgnI/H4QxT1XRgwwIF77knp2y0unZ9//hlnz55FgQIFTFac8DysmnEvsJMnT9aUXwZlygCf9neg/QMu/DErpZqf1aCBXLV/TfEwfDnYiaZNU9bcYMT9PK9du7bJ3BWep2rVqsidOzdOnjyJBQsWBP2UZ8sGvPO2AzfdGIKxg6Lx+9zQoJ+Ty+Wv30Mwon8UalUNwfvvOZA7d2CuU+5ziPA8DRs2NIlfTFTduXNnQE85t40vPufCyl8jMH+W1h87SU4Gxg6NwOkDYXjrTScKFoTfoHXK+7ifCTNnzvRrh0m3uPbHTxHYtEaVa4EA43JjhkQgVxYXOnb0jUMmEyW1Tnkf9zo1ceJE8xn4sptIlfIuTPhaVv3i/0z5LgLRISF45hmHV+JljJ//9NNP5r3Ofd7DF7Q+fr+e7iQ3EZH5TB8XDmdCKJ54InMWsU2bNmH9+vUICQlB/fr14Sk82mnz/vvvx9ixYzF+/Hi8//77JvAjPI/Lxf5NvBym5w1dU7ZudWHLlhBs3mJh9u9AYpKFJMtCeKSFiKi/r8hkhEdZCA0Fzp8H4s45cf6cA+djHTgf40BSogMuhwPRUQ6ULe3AHQ0dRuQrXx4oVEif7NUybtw489q6dWuTFSe8A9cp2qVw/p966ilN+2XAtaJ9ewfq1HHho0+c+KJvCGo0iEOjpvHIntN3D6SXGmj5a1Eo5s8IgyMuFC8958QddwSvsJ9+neJ9I7wDN4KtWrXCkCFDzPzffPPNQT/1dAnt0cOBvHldGDc6CieOxqJp6/igvz//C8YJ504Pw/wpEWh+u8sEX1gNGEjQOWzChAnmvdYp78HkVIr88+bNM+e+bt26IZC57Tbg0CEnhn8XiZy5LFSvHdzuKnYGYLavDsdbvZwoVw5+w9GjR01iN9E65T2YnEpnlz179uDHH3/E3Wwm7adQXNuwwYUxg6PwRPcYFC6ebPeQxFXszSZ8HYGju8Lx/ju+Yc1PGB/Zvn27Sehu1qyZ3cMJGlq2bGnaIWzYsAFr16417RF8EYYradX/9LMpVv08h4ngZs2yFGv+119xImdO7/zO6dOnm4Q9tjpyu7MKz8O9a9++fc1eikUoOXLksGXaixdPSXj84psIVK6ZiGKltBcSVwcTZ1f/FoGuLzgzzY2csRFyyy23mMItT+FRxf32229HtmzZzCFq8eLFnvxV4iIwcMvK/hYtgJdecuDLL5yY/IMTn33iQs+XQ9CxQyha3RGGhjXDUalYJApERCI6MRLFs0eiZrkINKkXjrZ3heG5jqF4s2cIvhnqwsTvnfjgfQeeeAK46SaJ+5nB+fPnUyvIFejxLvfdd595ZWXsgQMHvPzbA4OyZYHPBjjwRIcQbFseiY96ZMGkEeE4ccz/1PDEBJiK4A97ROPHMVGoUy0MXwwK7qr9tPb8f/zxh3Houffee+0eTlDhfi788MMPSEhIsHs4PgFzRplV+2wnF5b9EokxX8qe7b+Sln74NhwLp0bi8Q4uPP984In7ZOHChaaNSK5cucwhSnh/nXInggU6Dz7oQNNbXZj4TSQ2r1VirreZNyMUy+ZG4PnOLp+xs75UWJnJZKRrr70WZbmJFl6BxSbuc5+/r1MU17p3d+CaUiEYMSDKL89cIoXZE8OwcWk4enR1olIl35kV9z1CcT86Otru4QSVw+QdrCrwg3XKLa7RTWTXNhXzBTNnTzswdVQEGtVzokEDe4pP1O7Ie1SuXBkVK1Y0bYanTJkCuxMeq1aQm4jIHGv+Sd9GoHYtJ5o0gd8VyXn0KRwREWEyEP1hcxJMREQA11wD3HorwMT1hx4COnUCunYFevd24L13HXj9dQdeeAF4/HH22waaN4d5UBcpkhJUF5nL7Nmzcfr0aRQpUgR16tTR9HqR4sWLm4oOWqC5q/7ElVXzM2Y24hsnOj4cil2rI/FJzyz4YXg4Thx1+EUP10VzQvFBjyyYMy4K9WuGYdgXLlMlXKCA3aPzDdyZhw0aNEAh2bZ4FVbG5suXD8ePH8cvv/zi3V/u43Cb+carLuxeG4FP34zGrq3apKSHbZkGvhWFjUsi0eNlF9q08Y5toh24zxv33HMPQvlgEl6Dc04HquXLl2Pr1q0BP/O8h5goU++6EIz6NBrLFgVgxoyP2vJPHR2OeZOj8HC7lARMf0NuSPbhDq5NmzYNMTEx8PeYzptvOJA7OgTDP4k0gUnhXyyeF4rfZ0XiqSdc8KBr62XDuIj73KfiE+/jnnN+Br5s059q1V/BhR9k1R/UTB4Vbqz5O3f23hmT8fNZs2aZ91qngjex2+0mEns8xU1EiCtl+thwuBJD8fxzmbeOrVu3zlyMS911113wJB6PgrqzpL///nuTqS6E+Hd7frWy8D6BUs3hC7Ate+vWwLffONHp0VDsW0+hPytGDYowtl0U0n0Fnpf37HBi+tgwfNA9C+ZOiEKj60Px9RAXunZ1oGhRu0foW7jvD/f9IrwHRTO3a4LWqX9y443A5585UTxvGIa9l8Xc07601thZtT97Uhi+7JcFeaPCMXCAE4Hc4SExMdG4XBCtU94nb968qT0Zg2WdogvGa6850LyJC1OGR+PnKWFmbyE8A9f17wZHYMWCCLz4jMu4KPgbhw4dwvz58817rVPep1atWihVqhTOnTuHGTNmwN+hDXLfPk4gNgwjPos0TmTCP9iwyoUZoyPRqqXTFN34EnRfpXNblixZUqvJhfegawKL5bZs2YKVK1f69NRTXHupiwOxJ0JN2xwRfDDBdfOKcDzztPes+Qkrx+Pi4lChQgWfbWURDAL/nDlzcOzYMVvHUqwY8PBDchMRV87G1S6s/j0CHR/PPGv+tDGRJk2aeLyVhccF/ttuu838I2h9vWjRIk//OiH8DgYYpk6dat4r89AemFhBfvvtN9NSRFw9kZEpGd3Dv3bi2Y4hcJ6NxA9fRqPfC1kx+osIrFvhsiUIxcA7q1lnfh9mbPiH9suK7cuj0PSmUHwzzGVamRQu7P1x+Trbtm3DsmXLTAIS+8EL7+N+PkyaNMkcZsWFMCGH7YOefjwEq3+NSqnmD2K7SK5zn/eJwp+zo/BwWxcG9HegVCkENHPnzjW9rSk038QeUiJoqzm8LfI/95wDTz7iwq/TIzHhm3CTXCMyl5gzwNAPo7BvQwTe6uXCnXf65wzTLSw5ORnXX389SpYsafdwgg5a+AZaYjcdFt/s5TQ93L//OkJJRn7A3h1OjPsyCo1udKFjR99zVXLfGy1atEAkD/XCq2TNmhV3/v2Q84d1imewZ592YuXCCPw6W+5ZwcTWDS5MHRmJ5rc7ve5CInt+eylfvjyqVatmEuwZn7Kbe+6Rm4i4MuiANXlE5lvz04HHm65tHo98hoWF4e6/U1L9YXMihLeZOXOmsQgsUaKECfYI78PWCPXq1Ut1GxGZax9JC+2BnzqMgP5Yu1AknYjE+EFZ8PYLWTF2SITpeb97u9MjFbcU9I8ecmDlkhBT1fvxq9H4ok9WbFoShZtuCMOH77rw3Ugnnn7agYIFM//3Bwpum0aKZvnz57d7OEEJ1yi2Rjh16hR++uknu4fjs1UkzD8ZPNCJYnnCMOzd4Kvmp7A4Z3JK1X7uyJSqfVa5UoQMdNznDCYhhQTDP9gH4ZmPc79mzRps2LABwQLFGZ7bX+nqwqalkfh2QCTiYu0eVeDAfdzgt6OReDIMH77vxA03wG+RPb/9uINsPIOfOXMGgQB7t7OH+6Zl4aanu/Bd2Lru20+jUKlMCLp1c/hc+0smILnjISo+8Y2ESV+36Se33w60u9+JnyZEYvVS7cGDgYN7nRg9MAp1anrXmp+cOHEiNR6idco+fCmxO62byE+TtQ8Sl2/N/8LzmbuOrVq1Cps3b0Z4eLhJmPQ0Tm/e9MxYZ3aPECJj22tWFQh78KXNSaDCynhO8+DPHcYGv/39oUg+GYm530dj2DtZ8dYzWfHpG9H4/utwI/pv3+gyB4dTJxyIj0sR6zOCj5Wzpx04csBhEgVWLk4R84e8H4m+z2bFgFezYfJX0di7Ngr1rg3D+/1cGDPKaSruqldP2QyKf0cBafuhe4LbbUTr1H9Xknz4gQOdHgvBqoVR+OS1aPy5MCSgq2rZl3rFHyFmDV38YyQ6tHHh0/4OlC6NoCA+Ph4TJ0407xXosY9cuXIZ97ZgXafYoeCdvk6c2BuOL96LwukT2tdfLdzXfflONHJHhqH/x06UKwe/Zd++famOhu7nufA+rDgrV64czp8/n+qiFwiwerLTky7T033BLFXR+iInjzvw9cdRyJ8tBG++4UC4Dzqac43av38/smfPbixlhT2wgj86Oho7d+7E0qVL/eJj6NDBgSY3ufDDV5HYucXHMldEpsL43PD+kShbPAQ9X/F+IjkrxhMSEow1/zXXXOPdXy5ScZ+56aJ3+PBhn4gBPdLeicVzIoLayVFcvjV/pyedyJsXmYo7FtK0aVNky5YNnsZheSEdkAtvwYIFTV8O9ue45ZZbPP0rhfALzp49i3z58iE2NhZ//fUXatSoYfeQgpaDBw+icOHCJmt9+/btss30IvHxwK5dwNatKdemLRa277CQkGgZUT8ZKa/OEAsRkRYioyw4XUBcrAOx5xxIiEvJtHPAASdfHUDB/A6UL+tAmTK8YESu7Nm9+a8KHDZt2mR6m7Eqk/dJ7ty57R5S0PLHH3/gxhtvND0xeYiSbeZ/w64rI0damL8oGZE5EtHwjnjUqp8QMBXtSUkwSU3zZ4Tj9JEQ1KvtxEMPBb4df3rYS5k9SwsUKIC9e/fCpcwt2xgxYgQ6dOhgnhvr168PyuTVnTuB13sl42RcIlo9GotylZLsHpLfwX3fH/NCMXt8BKpdE4I3ejmQNSv8mv79++PFF19E3bp11brQZnr16oU+ffqgefPmASXy877hnmfkmGTUvOk8mj0Q53MV4sHcOmnEgCjkjg7B2/2cKFQIPknnzp0xaNAg8xwfPny43cMJatq0aYOxY8eiS5cu+Oijj+weziWRkAC89rqF1ZsT8NQrMchb0PfdB8TlcT4W+PLdKIQlhmHAJ07kyuX9GWTyESv4+/bti1dffdX7AxCpXHfddaaVJ58bnTp18onYyMtdLew+Go/Or8cgQl1mxEVgkeBnvaNRvXwo3uqdudX7lNpLly6NHTt2mOe4NwpQvCLwk44dO2LIkCF4/PHHMXToUG/8SiF8njFjxqBt27YoU6aMse4IxiCoL9G4cWPMmzcP7777Lrp37273cIIaHg4PHgRiYpgIc+HFn7ESN0sWIDo65dV98c958rB3nd3/gsDhrbfewhtvvIHbb78ds2bNsns4QQ23bGznsnv3bvzwww+4h83GxCULbuPGWZi7MBnhWRPRoGk8rqfQ76dFblwDWbFPYT/mWAjq3+hEmzYpCU3BSPv27TFy5Eg8++yz+PTTT+0eTlDDNiJMXqWrAq3pqlatimDk2DHgw48s/Lk8CdXrxaHZ/XEIV5Dpki2s2Ut835YwtLzTiSefdCAsANw269Spg8WLF5s1imuVsI9169ahcuXKCA0NNQmTOXLkCKiPg9v1AQOTUKJKHNo8eR6hAXD/+DOb1rgwZnAUrimVUrmfMyd8ErqtsuCB9wRbWNxxxx12DymomTx5sml9xHaSu3btMm5u/gDjNS91tXDoVDw6vXoOWbNL5A8UeP78pn8kTu8PxycfOlGsmPfHcOTIEVNAmpSUhC1btphYurCPDz/8EF27dkXDhg0xf/58n/go9u0DnnsxGdkKxeGRF2IDprBDZB5x54FhH0TBignDp/2dRkPITOi8wxbcUVFRZk9FRx5P47UdgjtbgfaZrOgXQvy/rzXvD4n79uNep9yfi7CP0NAUi6UKFYBatYBGjYBmzYAHHgAee4xJY0C7dsBddwE0haldG6hcGShZUuK+J9cpYS98TrCdC9E6dXmUKAF07+7AsC9cqF8zDD+Pi8KHPbIYG1tapvoLp086sGhOKD7qGY0ZI6NxXcUwfPG5C6+/HrziPm2Wp0yZYt5rnbIf2vq6RYFgXqdodvN2Pwdeei4E21ZE4pNe0di8Tj2BLqVqf0CvLEg+HY4P3nHhmWcCQ9ynOENxn8/xe++91+7hBD2VKlUyF+NS7udHIMEluM+bLhzYFIEh70eZKiVhD2wRNerTaNStGYL33vVdcZ8sXLjQBKLZbkeuq/bD5Hra+tKZii5u/gKLLvr0diDKGYpvB0QaIUUExh5t4rfhOLw9HG+8Zo+477bnp7hP91uJ+/bjbjnF58eBAwfgK61h+R3ld/WH4eEXbfUqgpPkZGDMkAjEHAlDn96ZL+6njYHQYdIb4r5XBX5m8+TPnx/Hjx/HL7/84q1fK4TPcvr06dRqWAWkfYNWrVoZW9/ly5djK73ihQhyWOHEKywsDHcxm0LYjvt5MW3aNMTQzkJcFkwc6trVga+GuNDohlAsmhaND7tlxeB3ovDbz6FGQPc1Ys4Ai+eFYsj7kXj/5ayYPzEadaqGYcggF3r2DD47/vTMnj3b7KlY4cQKWeE76xR7z3nJLM4noTFX06bAkMFOVCoZhpGfRJvgaFys3SPzzar9YR9G4sfRUWhxWwi+GORE9eoIGL7//nvz2qBBA1N5JuzHnTDp7pEZaFx3HfDh+04knQ7D4LejcPSQ7+1vAhk++mZPCsO0EdG4+04XXnvNgYgI+DTue4EOYXS3EPYSERGBli1b+uU6lS8fRX4nzh0Lw5gvI4ygIvybX6aGYd3iCHTt4oSd5lzue8H9DBf2Urx4cdSuXduc9yZMmOAzHwe/o91ecmL9kgjMmRwAmcIi0/ZmU74Lx5714Xj9Vadp5ZvZ8F6wo0jOawI/RTN3tvp3333nrV8rhM9Ce+W4uDhcc801xiJQ2E+ePHlw8803m/dap4T4/33APmeBZl/qr9SsWROlSpXCuXPnArLqzJuZ3V26ODB+jBOvdQtB6bzhmPdDNN7vmtUI6RTU7ax4OxeTUvVFwevdLtnw09hoFM4WgR5dQjButBM9ejiMK4H4/zrFQI+/2JcGOuxrzcA0kyVpURfsMNDtrubf+lck+r8RjS3rVc3vDrQs/rtqP/Hk/6v2o6IQMDDQ416nlNTtO7g/izlz5uDQoUMIRMqWhemRnCc6DF+8HY1d2/SM9JaN9fivwvH7zEh0etyFzp0dcLl83w2J8Smidco3HSbZ+sifoHDyek8n9mwIN9WSiTLy9dt92ryZoVgwLRJPPOIyzpp2sW/fvlQbeAn8vrdOjRo1yqcSuxs2BJ581IVfZ0Ri6a/y6RfAwh9DsXJhBF541oWaNT0zI4sWLTItVbNkyeLVVkcOy4t3359//okbbrgBISEhpt94SXopCxGE0FKIov7GjRvxzjvvoEePHnYPSfzN6NGj0a5dO+TOnRs7d+40i7IQwdpHmRm5fGU2Lh0uhG/w1ltv4Y033jC9rVesWCFRM5M4w0r5xcD8BRaWr7QQl5iM3AWSULBYEgoXT0LhEsnmNTyTK7Di44D9u53Yt8uFvTudOLg7BEcPuBDqdKB6VSca1Hegbl1an2fu7w0EeJ5gomRycrK5F6oHUsmvn/PQQw+ZQA/7x7JFm0iBOuIn/S0sXZGM0lXjcEvzeBQpGXylbYxArF/pwtyp4Ti6NxQtmjrx2GOBJeyndRmh1XJkZKQJ+DChWPgGdH1h64Ru3brhvffeQyDvb97qY2Hl+kTc82gsql2faPeQAha6Lo3+MtJYA7N6kAKDPzBw4EA8++yzKFq0KLZv325itsJ+KOrzPH7w4EEMGTIETzzxBPyNRYuAd95PRp7icWj/bCwiA/A5H6gkJQFTvwvHyl8j0L6tEw8+6DDuVHbxwgsvYMCAAcYNacGCBfYNRFwA1yeuU1yv5s2bh0Z2ZoFkcN74/HMLk2cm4cHnYlCucpLdQxI2sXJJCCYMjcLDbV1o395zC9mdd96JmTNn4rHHHsOwYcMQkAI/ue2220yWNDcm3KAIEYyMHTsWbdq0Qc6cOY2IzN5awjdITEw0YgGrzhjoYcBHiGCkT58+6NWrFypWrIg1a9ZIRPYh2O6oRIkSOHPmjBHOKKCJzOXUKWDZMgrIwJYtFrZutxAbZyHJspArf4ron79wEqKigchoK+WK+vsy71P+O7HngPPnHIiNceDc36/mOgcc2u/EgV0hOHbQBafDgYhQB0qVdKB8OQfKlEmx182VS5/sv9GhQweMGDHC9Ddj2wrhO2zYsMH0uOZRc9WqVSYhSaTA0zcLkEaPsbB9dxJKVY5H4+bxKF46OSj+7Wv/CsG86WE4ti8UNao58dCDDgSqmRm//3Xr1jX9k1988UV8/PHHdg9JpGH69OnGcYT9MXkmD+TkCxb/9u9v4ae5yahQKw4tHzyPaOWxZyprloVg6qgIRIeEGOvXKlXgF9BVsnTp0qY69vPPP8fTTz9t95BEGj755BN06dLFnP2Y2OqP7RPWrQPefCsZiIzHwy/GImdu36nyFRkTdx6mvQIdGFjt2qSJvTPF/u50MaTbyE8//YRbb73V3gGJC+jcuTMGDRpkxH2K/L6WqNK3r4Xf/krEE91jULh44J+3xIVs3+TC8I+jcEfjEOPi6alEJToXXn/99cbFngW9ZRjUC1SB/7fffkO9evXMpmTLli0my0eIYIJVZlWqVMH69etNFebrr79u95BEOr799ls8/PDDyJs3L3bs2GGCPkIEE+xnzSDCiRMnMGbMGDzwwAN2D0mk47XXXkO/fv1MxfLy5cvhsDOdPkjsVvfuBbZuTbk2b7GwZ6+Fs2eBZMtCsgVwQ81dtcX/WSn9t4mD/3PwNeVnLofDJAYULeRA2bIpYj4vbolVMHXpMBGvQoUKxhWJLmHXMSNC+BR8drBXJtu0uXuQi//DnrS//gp8N8bCtp3JKHFNPG5uEYcSZQMv8MQ1cfXSFGH/xIFQ1LrWiXZtA1fYd/Pzzz+bIDRbVrAqtmDBgnYPSaSBobBatWqZfdQrr7yCt99+O6Dnh/chix4/H5yMc8mJaPlQLCrXUDVbZlTtT/kuAhuXhaNRPaex5M+ZE37D4MGDjahfuHBhbNu2DeHh4XYPSaSBbdnofnv48GF89dVXePTRR/1yfvbsAV7vlYxjMYlo//w5iWw+zJlTDnw7IBLnjoWZNguesrK+HF566SWTJEnnHepKin34Fnv27DGJYgkJCcZdgS4LvsT580D3Hha2709Ap9dikCOXkoyChUP7nRjyTjSqXxOCPm85PBpva9GihSk6ad++vdGVvInXBX7CHtdz585Fp06dTIaPEMEEra5bt26N7Nmzm0oB9bX2PbgpoWjAQNxHH31kMqaFCCbYOqRnz54oX7481q1bZzIQhW9x7NgxkyQZExODqVOnmgo04X24iz53DoiJgRH73Rf/zL9jlxf3xVwxvtKCWvkYVw9tz77++mvT24w2aML3WLt2rUlqJXSCYXsqkbHQ//vvwKjRFrZsT0ax8vFo3CwepSok+f1aweSotctCMHd6OE4dCsENtZxo28aBihUR8DDMwgAnezE+99xzxlZW+B5TpkzBXXfdZdqy7dq1C7mCwDrn+PEUy9oFv6ma/2qhI8mUkRGIcoXgmaedoKbhT+s2LZVZYUZx5tNPPzU2/cL3+PDDD9G1a1dTwbxp0ya/baFw4gTwZm8LG7Ynok2ncyhfRQlGvsaRAw5880kUopyh6NPbidKl7R4RTHILi09iY2Mxa9Ys0/ZI+B5PPfUUvvzyS9xyyy3GudsX158XuyQjxorHUz3PqV1IEHD6pAOD345CwRxh+OgDh4nHeQq2i6xRo4ZxvmVBL2PpAS/wM5uHth1hYWEmQ7RIkSLeHoIQtlXvX3vttVi9erWxvu7du7c+CR+F2dGPP/448ufPb6r42TdTiGDg7Nmz5gBFAXnkyJF48MEH7R6SuAg9evQwrURYfcYKZmWyi2CBz+Vy5cqZtjq0vq5du7bdQxIXgdX7P/zwg6nmpyOMuDg8lf/xB/DdaAubtiUjS85EVKqZYPplFy6R7DeiEa0wt21wYdWfIdi4IgyJ55248Xon2rZ1wMuxDluZP38+brrpJhPzYNIwq2OF78FwGM/nbCVCZz067AVTq5BBX6RU89/VPhaVrpXYdqnEnAWmjEqp2m9Y14lnnvGvqn03Q4cOxZNPPokCBQqYdUoxD9+ECd08nx89etRUBbI60F9hJe1771lYuDgJzR86h+sbJNo9JPE3OzY7MWpgFIrlp7jvQL58vjE13bt3x/vvv2/c2pYsWaKYh4/CAsayZcua8zldFm688Ub4GnRkfPGlZIRki0eH52ORLYcq+QOV40ccGN4/CuHJoRjwiROe7sJ1zz33YNKkSWjbti2+++47eBtbBH5CgZ9C/zPPPIPPPvvMjiEI4XV4s/Omz5o1q6kQyOmPp8AggdnsFA/4OfXv3x/PP/+83UMSwivw8MRDFKs52EPZXysEgoEjR46YYA+tG2fMmIGmTZvaPSQhvAKD0QxK33bbbZg9e7Zm3YehaMZWIkxAoiPMNddcY/eQfB6eztesARYutPDrbxaOnbCQLU8iKl+XIvYXKOJ7Yj9dCNjfcNWSEGxYEYqEcy4UK+xAo4ZO1K8PlCiBoIPiPkV+Wl+zr7XwXZiExGSkbNmymQB1MJ3RWc0/cKCFhb8n45rr4tCi3XlEZ7F7VL7N2uUuTBkZiShnCJ5+yolGjfyraj+tayHjHfzOs8/7Cy+8YPeQxL/ApG4md1NA4xndnx32mAg4eLCFSdOTUe/OWNx2V7xf3kOBBJMyJ34diRqVQ/D6aw7jOucLMKmF8Q4mudD6ulmzZnYPSfwLLJJjsVyTJk3w448/+uRcbd8OvP5GMs4mJeDhF2KRv1DgtUYLdvbscGLEp1EokJ22/E4UKuTZ38ci3mrVqtka77BN4KdFP6362d+JmaKFPD3bQtgMbzXadaxcuRKvvvoq+vbta/eQxH8wZMgQdOzY0fTL5DrF/plCBDI8OLHHH4Xj4cOHo0OHDnYPSfwHtGukbeMNN9xgKplVxS8CHSbeMbjJwDStr+vWrWv3kMR/cPfdd2Py5Mlo164dRo0apfm6zCA4xf4FCyz8+ruFE6cs5MyfiEq1ElC6QhIKF0+yzWLy9AkH9u50YtPaEGxYHoq4sy4UKuDATX+L+qVK+afolRksXLgQDRs2RGhoqHEsLFq0qN1DEv/hssfAHNuKvPnmm3jjjTeCar7c1fwDByfjXHwSrr85DvVujZfQn26Otm5wYe7UMOzbFoYGdVKq9v25o8M333xj+rnny5fPOCNFsYeU8FnOnDljhM7jx4+b6kBWCfr7PfXDD8CQr5JQrGIcWj0ch+w5VU3rbeLOAz/+EI5l88LRpLELL77oQGgofAa2jWT7SMbSly1bpliHj8O4ORPHkpKSsHjxYhOj8kWOHKHIb2HXgUS063zOtEUTgcGGlS6M+zIKlcuF4I1eDmTP7vnfyTbcbMd9//33Y+zYsbAD2wR+/tr69esb2w5mijJjVIhAhtmGLVq0MP39mCWdO3duu4ck/oO4uDgjIrAn3cCBA9G5c2fNmQhoPv74Y7z00kumv9/GjRtNYFr4NocOHTJJGexJx0pmVjQLEciwGnbw4MFo3LgxfvnlF7uHIy6B5cuXo2bNmqYnHavOGPgRV9bPfuXKlMr+3xZbOH3GQpJlIUeeZBQoRhv/JBQpkWxE/6hM7DHIaMGpEw7s2+XE3p0u7NvpxKHdIYg540SIw4H8+RxoWD9F1OdHG6yiflpuvfVW/PzzzyZR+IsvvrB7OOISGD9+vAnM5ciRw5zVs3sjIuhjnDwJTJhgYep0C3FWEm5oHIf6t8UjOiuCFq5/m9e68Mu0cBzcHorK1zjRto0D113n32sdLZQrVKhgEpA++OADvPzyy3YPSVwC/fr1w2uvvWY+OyYk+XMVv5ulS4FPBiTj+NkkNH0gFjXrJvr1veVP0Hnph28ikHg2FI8/4kSLFr61rjGZpXjx4qaFJBOFW7ZsafeQxCXwyCOPmGKhO++8E9OnT/fZOYuJAfr2s7B0VSLueSQW1WurXYi/s3heKKaPjsRNN7rQrZsD4eGe/518FlepUsW8X7NmDSpXroygEvjJnDlzTCCaVbHMGGXfJyECEd5m119/vck4pK0WMxCFfzBo0CAj7BcpUgRbt241riNCBCIUiCkUUzAeNmwYHnvsMbuHJC6RLl26mERJ9jljRbOq+EWgsnfvXpQuXdq00WGrrwYNGtg9JHGJNG/e3AR56AzDoI+4ekv8ffuArVuBbduAzVssbN5qIeZciuifPXcychdMRFS0ZSr8I6MsRJr37leYv6NDQOw5B2JjHIg9h79f/75iHIg568DhvS7EnnUixOlArhwOlC/rQJkyvGAu9jT0pYCw3fz+++/GWYQtjrZs2WIqLoXvw2ozBuiYhESnPTruBSunTgETJ1qYMs3CucQkXH9THBo0SUCWbMFTXcso6cbVLsydFo5Du0JRtWKKsF+zZmCsdyNGjDDP4zx58piElujoTMwKEx7j9OnTRvA8efKkqRJkUlIgcOYM3TMt/PhzMkpUikOrDnHIpmp+jxEfl1K1v3ReOK6t7EKXFx0et7C+Enr16oU+ffoYh50VK1YoxuEncO/LJCS6I1EDYZK3LydPDxhgYcacJNzSKhYNb08IiGd8sGFZwKwJYVg8OxL33uXEk0864HR653e3adPGPI9btWplqvjtwlaBn7+awWjadrBikBazQgQiM2fONNlrtD3jASpv3rx2D0lcIufPnzdiwv79+03F4FNPPaW5EwHJgAEDjKMOgwabN29GWFiY3UMSl8iBAwdMcgZdR1gxyBZIQgQizz77rHHUofU1e1sL/2Hp0qUm2ZXVZps2bTJ7K5G58FTvFv157dtn4cxZ4OxZC6f5egaIiwcs/s9K+X9PGMji5YTDCP9ZswBZooGsWR3IlhUoXvz/Yj4NyBT4+nduv/1246jDREkmTAr/YfTo0aaVSK5cucyZPWvWrEEuJgKTJwMTp6RY99dqGIeGdyQga/bAFfq5Lq5fSSv+cBzdG4pqlZ1o19aB6tUDZ+1jMgv7w1KEeffdd9G9e3e7hyQug7feesu0EalUqZLp+0t3pEBhyRJgwGcp1fx3to1FjTqq5s9sdmx2YsLXkaZq/7GHU6r2ffErdOLECZMgyaQWimYUz4T/8NBDD5m2bHQxnjJlCnz9uT9ypIWRY5JRvf55tHwwzifvCZExiQnA+K8isHl5ODo94cJdd3lvv8akYD6LqW+zHTeTkYJS4CezZs1C06ZNjfDJKn72fxIikOAtVqdOHSxZssRYn9ECTfgXn332GZ577jkUK1bMHIQlfIpATGShLT+F4i+//BJPPvmk3UMSlwnXKK5VrGhmZbMQgQYT7bhOMZGF1vy06Bf+Bc98PPux5+9XX31l93CCkoQECv4ptpR8pbsvCzezZEl5DQC3X1vhea927domkYXJklyzhH8JnxUrVjSfHR336LwnUqprp04FfpicjDOxSShXLQHVrk9E+SqJCA2QfOAjBxxY9WcoVi8NxalDIahRLUXYp+tqoAj7bpTI4t+wep/C56lTpwJS+OR68+WXFmb/koySleNwT3tV82da1f7EcCydG47qlVKq9gsXhs/Su3dvvPnmm8buetWqVQGVyBIMMJmbiWTUQ9iq7dprr4Wv8+OPwICBSSh6TRzadDyP8Ai7RyT+i3MxwIjPInF8Tzh6dHWiXj3vztmDDz6I7777DnfddRcmTZoEO7Fd4Oevv+GGG0xVR7du3fDee+/ZORwhMh1WcLCSIzIy0iSx5M+fX7Psh9blDNAdPHgQQ4YMwRNPPGH3kITIVFgRy8rYokWLmiQWtaLwP/bt22fWKVqXz5s3D40aNbJ7SEJkKnQYodNIvXr1sHDhQtk0+iF//PGHcW+jdTkDPxI/RaBBxzY6tz388MP45ptv7B6OuAJGjhyJ9u3bI3fu3KaKPwuzX4SBiUGzZgHzFrAlSDKcYckob8T+BJStnISQEP+aqGOHHVi9NARrlobi8N4QZIt2ol4dB26/3QGbWqh6tRUF+7n37NnT7iGJK4AV/Kzkr1q1qrEuD0Txc/HilGr+EzFJuLNNLGrcqGr+K2X7JhcmDo9AwplQPNrBCbay9+WvDJNXmMTCZJZx48bhvvvus3tI4gpo27YtxowZg7vvvhsTJ070izlctgzo+04yonLHo81TscidL3Adi/ydg/ucGD04Es7zoXizlxMVK3r39zMZmEksbEXx119/oUaNGghqgZ+wHyP7MrIqlpPCDC0hAkUYrl69urnxX3zxRXz88cd2D0lcIexvzT7X7FO3bt06uY2IgIFV+7QVog3a559/jqefftruIYkrpHPnzhg0aJD5PLmfUqKGCBRoeXbdddchMTERP/30E2699Va7hySukNtuuw1z5swxya8UQh2BVhopgpbJkyebICaFlo0bN6Js2bJ2D0lcAXzOMGC3detWk/z66aefah4zYO9eYNEiYN58C9t3JSMkPBnlr403lf2lr/Fdsf/kcQdWLUkR9Q/uDkHWSCfq3OBAgwYO1KoFBHqHMrZF7dq1K3LkyIFdu3YhW7Zsdg9JXAHHjx83AuiZM2fMGsW1KhBhNf/gwRbmzEtGrkIJaNw8HpVrSui/VHZtc+KXKeHYsT4M1So58VIX367ad9OxY0dTWMVn8Zo1a4wrkvA/1q9fb/Q9yo4zZswwTm7+wLZtQJ++ydh/NAm3tjqPG29OCDgnH38mKQlYMCsU86dFoHSxEPR6zfvrGkV9xqPmzp2LZs2aYdq0abAbnxD4OQQK/Lzha9WqZao7WNkhhL/z0ksvGVG/UKFCWLt2LXLmzGn3kMQVwqpYrk/cYN577734/vvvNZfC7+Hzt2XLlmZDwozDxYsXIzQ01O5hiSvk6NGjRtw/fPgwXnnlFbz99tuaSxEQz1+K++wzes899xg7UonC/h3soU0jP1fa9NOuXwh/59ixY+b5e+jQIdPPmn2thf878JH58+ejYcOGdg/Jp9m1C/j1V2D+gmTs2mshNDIZRcskoHCJZBQpkYQiJZKRJZv3w46JicChfU7s2+XEvp0uc1HUjw53ovb1KaL+ddcBEUFiw8vEIxafsNXR0KFD8fjjj9s9JHEVMDH/mWeeMe1uuUcuXbp0wM7n2rXAd6MtLFuRjJwFE3BTs3hUvU5C/8XYucWJOVPCsXtjGMqUdKJdG4exrvblqn03TAJmMjCRK6H/w0LH/v37G02EhXJMLvMHzp8Hvv7awqRpyShUJh73PnJe1fw+wKH9Tnw/LALH9oWiTWsn2rZ12JKYOXjwYFMYR6duthDxhaRunxD43X01eSimBYusokQg8Ntvv6F+/fpGQKNLBS0bhX/D3kHXX3+9sbaTVZQIJBtSivqs+KZlo/BvaH/GXoysIGTCBoVRIQLBhpR2yQwMqNWR/8OWbOxtzcpBJsCyPYwQgWBDyv7t3E9FBItiGMCwJduwYcNMKxGKZ9HR0XYPyedhZHHHDsZBgA0bLWzaYuH0GQtJloWsOZKRv2iiEfsLF08y4n+2HFamivkH9/5fzN+/y4Uj+12wEp0IcTlQvChQrqwDNWo4cMMNQFQUggrGL9jiiGeDJk2aYNasWUqW9HNYQXjzzTebJKQGDRoYMTQQrfrTsn49MHqMhSXLkpE9fyIaN4tD1esT/UK49gbbN7rw89Qw7NkchnKlU4T9unXhN9XHp0+fNhXfe/bsMc6EbCMp/Jtz586ZxDK2AfXH9lWrVwMff5KM/ceScFur86jTWNX8dlXtL/wxFPOmRqBU0RC89KID5cvbMhSw9Tbj5jExMcbpmW0kfQGfEfjJiBEj0KFDByM0UEiTVb/wZ2v+atWqmYcYv9PDhw+3e0gik+jVqxf69Okjq34RENb8DEQzsa5v37549dVX7R6SyCTatGmDsWPHms+X+ylZ9Qt/hX1FmVhHy2R+p++//367hyQyAX6edevWxZ9//imrfuH3TJo0ybiLUFihEyHXLOH/pBUaZNV/ZTDSeOgQsHVriuXt5i0WNm22cOpv0T88wkJkFgsRUckIj7IQ+fcVEWUhKprvYd4nJgCx5xyIjXGkvp47B8SdcyIu9u+fxziApBQxv0SxFDG/bFkHypQBSpYMnir9i/HBBx+gW7duSqwLMNIKDQMGDMBzzz2HYGDTJmD0aAu//5mMbHkT0ahZHKrfkIhgdHLnOrttowu/TAnDvq1hqFDWibZtHKhTx3+E/fTW/CVLljSJdVmyZLF7SCKTix/9yarfTWxsSjX/5OnJKFw2pZo/V16fkVKDomp/wlcROLo3FA/c60S7dvZU7bsT62655RaTUMekyQULFvhMYp1PCfxprYJl1S8CxZrfn2xoxOVZBcuqX/graZ+3NWvWNNUcao0TmFbBsuoXgfK8HT9+vKrNAogNGzYYq35aBcuqXwTC85auFO+8847dQxKZyE8//WSqnYms+jMHRh8PH04R/Q8cAGJigLNnU64zZyyc4etZy/Te5s+STbjSgYhwIEtWIGs0kDWrA1mzpLzSWIEaEMMtFPIl5v8TPW8Dm7RWwdwzl2FWS5CwZQswZoyFRX8kIzp3IurcHI+qtRKRLafPyBwe43wssG5FCP5cEIYD20JRqUKKsM8cQ38T9oms+QObLl26mGpnf9ZIVq0CPu6fjAOs5r/3POrcpGp+b1Ttz58WgZJF7K3a94fnrU8J/O6KQh6ST5w4Iat+4ffZaTNnzsQdd9xh95CEBysKZdUv/NmaPywszFjJyjEn8Jg8eTLuvvtuWfULv7fmz5MnjwkE5MuXz+4hiUxGFYUikKz55ZgTmDz55JOmX7ms+r0PI5WsnAsNTbnElVnz0zFnyZIlJi7F6kmHP6p/4l8rCm+99VbMnTvXxCGZjOQrFYXegg4h48ZZ+G2xhdiEZBQtnYAq1ycasT9LNp+SPK6KuPPAhpUhWL0sBNvWhsKR7ES1yk7c19qBWrX8U9hP75jzzDPP4LPPPrN7SCKT8Xerfjfck3z1lYUpM1Kq+e/pcB558gfOGuMrHNjjxMThKVX797dy4sEH7ava9xfHHJ8T+MmoUaPw0EMPyapf+PVD65FHHsHXX39t95CEh5DwIPyV/fv3m0Q6WvP369cPPXv2tHtIwkO0a9cOo0ePVk9g4deJdKzcb926td1DEh5APYFFIFjzu1wuY81PxxEReFB4YEBv9+7dEh6E3/H++++je/fuyJ49O9auXYsiRYrYPSThAXbu3GnWqbNnz6J///54/vnng3Ke6fqxeDGwcKGFpcstxCUmo3j5BFS9LhGVayUg2g8d3xPigY2rQ7DqzxBsWZ0i6lcs70TDBg7UqwfkzQu/R4l0wVcMOX36dNx5553wV1auTKnm33coGZVviEPjO+ORt6DPyat+Kez/Mi0Mm1aEoVRRF17q4kCFCnaPChdY8zdo0MC8+loinU8K/BzSXXfdhalTpxrrYB6YQ5WyK/zIdqZw4cLmAOWPtjPi0q2DKT6sWrUKrVq1wvfff69seOHz8PnaokULs6FWK5zAR9bBwt+t+SnsU+AXgcvGjRtNciyt+ocNG4bHHnvM7iEJ8Z8cPXrUJEsePnxYrXCCAFkHC3+35mfhCQtQRODyxRdfoFOnTsY6mDGqsmXLIpg5fRr44w9gwUILy1cmI9GyUKJCAqpen4CylZKQLYflsxXvMWeBnVtcWLUkFJtXhwIJTpQr60Sjv0X9AgUQMKgVTvC2M6ZmkjNnTvgr8fHA7NnA2PHJOHg0GRVrxaNx83jkL5Rs99D8jn27UoT9zSvDULwQ2404cdNNQEgIfIJBgwahc+fOiIqKMjGq0qVLw9fwSYE/vVV/37598eqrr9o9JCH+lUWLFplMHlnzBw8rV640IgQrDMeOHYv777/f7iEJ8a+MGDECHTp0MNb8tJLlc1YENlOmTDFJk8wwZcIkE5OE8GV69eqFPn36IG/evMaan68isPnwww/RtWtXZMuWzQR7ihYtaveQhPhX2rRpY/b+3Eex1VF4eLhmLMDp2LEjhgwZgpIlS5rgXhY2fhfCR2F8gtb8f/75J5o2bWqSu2XNH9gwDkmr/l9++QX16tXDggULfK7C0C5OngR+/z1F7F+1JhnxSRaisiYjf9EkFCmRhMIl+JqM7Dm9L/pTzN+3y4V9O53Yu9OFg7tDcOqYEy6HA2VK/V/UL1wYAcepU6eM8wSt+Z999ll8+umndg9JeJjY2FiT2L1582YTlxw+fLjfzzmF/p9/BsaMS8b+w8moUCMeNzePR4EiEvr/iz07nPhlahi2rglDySIpwn7Dhr4j7Ke35ucaxbXKF/FZgZ989913ePDBB031Pg/OnFAhfNWav1q1ati6dSseffRRfPXVV3YPSXiJN998E71790bu3LmNEJE/f37NvfB5a/63337bVJyJ4IB7Ke6prrnmGpPYERERYfeQhMgQfj+ZhELrdjrj3HvvvZqpIICfNy0bmYTUpEkTzJo1S0KE8FkmTpxo3Ltozb948WLjiCSCy6qfVTwDBw60e0hCXJT33nsPPXr0MNb8jFHQYVIEPrt27TK9zGnVT2fRF154we4h+RwnTgCbNgFbtwJbtljYtMXC8ZMWEpMtRGZJRoFiSShcPEXwz1swGVHRFiKjLISEXvnvTEoCzp8DYs85cPwIhfz/i/mnj6eI+VmiHShXxoFyZR0oUwYoVw4oWBABzRNPPGHcu1gNS9eJ6Ohou4ckvMDvv/9ukpACwao/LQkJwC+/AKPHJmPvwWSUvzYet7SIR8GiEvrTs2ubE3OnhmH7ujCUKuZC2zYONGgAuFzwKZKTk3HzzTdj/vz5aNiwIebOneuziXM+LfBzaHfffbepPqtRo4Y5QMuqX/giL774oul1xZ5mrDziQUoEn1U/+3BOmDBBQWnhk8/T5s2bY8aMGcZ1gpvqEF9KixQe5fjx4ya54+DBg6YP57vvvqsZFz75PKVQtmbNGtx3330YN26c3UMSXmTTpk2mouP8+fMYOnQoHn/8cc2/8Glr/p49e6Jfv352D0l4kZ9//tlUyBIG+W6if6gQPsb69euNNT/3Vd988w0efvhhu4ckvMiXX36Jp556Slb9lwgVkePHUwT/lCtF9D963EJSMmDxfxYQEmoh4m+xPzzSQnhUMqKigMhoCxGRFuLiHIiNoZDv+PtyprzGOhB/3mGcARxwwOkAsma5UMyn23OhQvDZlgGeYPbs2bj99tvNe7pN0A1XBA8vv/wyPvroIxQsWNAkofmzVX96EhOBefOA0WOSsWt/MspWi0ejO+JRrHRyUN3j6eE6un2jC/NmhGHXxjCUKelEuzYpDiU+qpnj888/xzPPPGOs+RmjKlWqFHwVnxb4CYPRPEQzOE3rxvfff9/uIQlxATNnzkSzZs2MgPbjjz+ayiMRvFb9PFA9+eSTdg9JiAv47LPP8Nxzzxlr/hUrVqBixYqaoSBj6tSpaNmypck45bPKHaAWwld4/vnnje2ZrPmDFwZ6GPDJmjWrSURjFZoQvuQ0wZY3rDbid3PZsmWy5g9CKJzxvFesWDEsWbIEBQKpGbLwe1i5TUccxidYFTlt2jQVHwQZjEvedtttJiGJibMUTylOiMuDov+BA9KTaNsAADDFSURBVLynUq6YmP+/53XmjIWzMSmvMecAdurJlsWBrFmBrFkdYBcXFqTz1X3xz3nypFTmB7PQt2/fPlMkRYdJxqgGDBhg95CEDVb9TERjgjcLe1ko56uV0Vcj9C9Y8LfQv9dCltyJqFwrAdWuT0ShYsEh9lNx3r3diVV/hmL9slCcO+1C2VIpwv6NN/qusE+4j2KrIzp2M55Ood+X8XmBn9Cik5U8ZNCgQejUqZPdQxLCwNYRtOlgLw4e9gcPHqyZCVLeeecdU8lDu04epO+44w67hySEgS44dJegvRD7HL/00kuamSDlsccew9dff23Es0WLFqFq1ap2D0kIA12Q6IZEJk+ebJJRRHAKqLTBYzC6aNGixr2tEEuahLAZhkwY2GEsIjw83CSg0GFQBB9nzpxBzZo1sWXLFvPK9Uq2wsIXYLFBixYtTJsbJksyqVvW/MFr1c9nFAvluKf+4YcfTJxKCF9od8NqfTqgsn3g0qVL9QwNUpgkye8C3Wa6dOliEr0DkeRkYM0aYOFCC7/+ZuHYSQvZ8yaiynUpYn+BIoFl4U+Ved9OivohWPdXKM4eD0He3A40rE8bfgeuucb3E5x2796N2rVr48CBA6YwigVSvp6A4hcCP+nbty9ef/11M6EM/NFqWAg72blzp7nhDx06ZDJkWc2hFhLBC5fSRx55BN9++63ZoC5cuFCBP+ETm2bahzJDlj3OWHHk8PXdlPAYcXFxxgqPPaQY8KN4xtYyQtgJg46tW7c2z1E6ddGxSwQvDEbfeOONqZb93E8xKUkIO/nggw/QrVs3s4di8UGrVq30gQQxW7duRZ06dUzLBlZJMz6l1lfCTriH6tixo2lxExkZafb6rJAVwctvv/1mkiZ5/mOCGl2yFAcQdpKQkGCemXPmzDHuN3/88QdKlCihDyWIGTNmDNq2bWve08mBjg6BDKv6V61KEfsX/WHh5GkLOQskogor+29IQL6CfiHR/gMqywf2OLF6aQjWLg3FqaMhyJPTgfp1U0R9mvL5uD6eysmTJ1GvXj3TOoKO8iyMypEjB3wdvxH4OUzaXg8bNszYC3HDSktsIezgxIkTJvi4ceNGVKtWzQQfs2XLpg8jyGHmITestEPjhpXiWfHixe0elghStm3bZoKPR44cQdOmTU0lv4KPghtWWk2xP2eVKlXw66+/Inv27JoYYQusgmXwkX3XO3fubOzPFHwUO3bsMEm07HPO1ld0RlISrbCLcePG4YEHHjDvP/nkE7zwwgv6MMQFSbR08qO7g55fwi7efvttvPrqq6YgatKkSaaSXwjaXtMNl/F0OfkJO+F3kG6C33zzjSmIovsNXXCEeO+999CjRw+zh2LiPy37g4GEBNrA/1/sP302GbkLJaJs5UQUKZGMwsWTkDuf5ZPV7lSSjx50YO9OF/bucmLz6lCcPByCnNkdqH9jiqhPs1B/M46Jj483BVHz5s0zLoLUdOgq6A/4jcDvzvbiRpXWCPny5TPZXqVKlbJ7WCLIYAYsK/Yp6rPykTe8rM+Em1OnTpm+d2vWrDGWU8yczpkzpyZIeBVWFDEJifahtOfjASoLG78Jkc5yiuLqzJkzERYWprkRXmXz5s1mnTp27JjZ30+cOFH2oSIV9jdnGyz2vXv00UdNkrfEM+FteN6jNSMDPs8//7xpJyKEG1busw0WQ2ps18YAtRDeZtSoUXjooYfM+4EDB5qESSHcfPzxx6kt+piw5m5/K4Q36d27N958801z1ps6daopQBGCcA/F5xZbHkdERGDu3LmmUCmYiI9nC2jg118trFln4dARC0nJFsIiLOQvlmjE/sIlklGkhPdFf6rGR9xi/k4XDuxy4uCeECTGORHiBArkd6BalRRRv3p1ICQEfvs9bN++vdlTMXbOQii6CfoLfiXwu3ueMdjDflLly5c34lnu3LntHpYIEtjDul27dhg7dqyp2Of3rzK9RoRIw969e414tm/fPrNezZ492/TrFMIbsJLolltuMZWxdJBgEhIdJYRIC/dR7Hl29uxZs5EdPny4xDPhNViZzYP79u3bjYUss6Tp0CVEWtj+ir1juf9+6623TLs2IbzFhg0bTBISnW8o4o4fP15JSOIfUFB99tlnzfvvvvsu1WpWCG9AIYTVZiyGYosjtjoSIi0M+dN5hhb9TOim2yQLUoTwFowzsJ0pYctIujMLkZbExERTuc+zHzU+FvSWLVs2aCfp1Cm2g0q5tmyxsGmLW/QHwiKSka9oiuift2AyoqKByGgLkVEWoqItRERZiIi8tD73VIRjzwHnzzlwLsaB2HMOxMY4cO6sA4cPOrF/pwsH97iQFJ8i5hcs4ED5sg6ULetAmTJA6dJAoHTSe+2119CvXz9z1mMBFAt7/Qm/E/gJK84onrECjTaz3KAwy0cIT9O9e3dzaKJNKJ0kGjdurEkXGbJ69WpzcDp9+jTatGljssBomSeEJ0lKSsL9999vrK3YJ4giP50khMgIJh+xrQi/NxTOKKAJ4WlYkU1b4z///NM4cfEAT2cuITLiiy++QKdOnVIDhB06dNBECY9z8OBBE2/YtWuXSUb65ZdfTF9rITLi5ZdfxkcffWRiBD/99BMaNWqkiRIeZ+3atSYeyngDz3+jR49WvEFkCM96rVu3Nu0b6C7JGEGFChU0W8Lj8JnIeAMF3J49exoBTYiMiImJMfsnuriVLl3axAjy5s2ryUoj+m/b5hb+/xb9DwHJsIxQT3GXEq9b5A2PtIzwHxGVjPAoC2FhFuLjHDh/zmkE/fMxDsSdT8kCcPB/Dr6mJAa4HA4ULAiUK3OhmB+oprBDhgxBx44dzfuvv/46NSHJn/BLgZ+wdywz6mmHzY0KK6olnglP8vnnn+OZZ54x70eOHIkHH3xQEy7+FSYf3XHHHWYzy+SQd999VzMmPMqLL75o7GOZnT9nzhxToS3Ev/HVV1/h8ccfN++HDh2a+l4ITwUYW7VqhSlTpiBXrlzm4F6uXDlNtvhXXnnlFbOHCgkJMRn1tEwXwlPQ2YYOXMuXL0eZMmXMOpUnTx5NuLgodBl54IEH8P333yN79uzG5a9SpUqaMeEx6BTIJCQ6B7KogCKaip7EfyXYsjUb3f1KlChhnm1y+ROeZNWqVWZ9ohMz4+cjRoyQY6D4Vw4dOmSebTt37sQNN9xgXGrk8ndxkpK4tvPsknLFxPz/ffo/nztnITraYUT66OgUsT7tlfZnNFYMlvrEmTNnmnaRjFO98cYbppWIP+K3Aj+ZP38+mjRpYnrisafQhx9+aPeQRIDCHkG0i+HhvW/fvnj11VftHpLwE7799ls8/PDD5v2gQYNSq9CEyGwo7FPgJ2PGjDGBRiEuhV69eqFPnz7Gjoq2aLT6FCKz4ZGDNsZMmGTbGlbEsvJMiP+C+28GBvlsy5o1KxYtWoSqVatq4kSmw6RctoVgsIeiPgUQivxC/Bfnz583yUdcn4oWLWpEtEKFCmniRKbDin0mcVM8YxU2E0qYNCnEf3HkyBFTKLd161bUrFkTCxYsQDRVHSEymT179hihdv/+/ca5jQ64LEIR4r/YuHGjWadOnDiBu+66CxMmTFCLLOER/vrrL5PUTfcI6jas3ndcSm8DH8Sv8zFo3fHNN9+Y97RE++yzz+wekghAaCFLoYzBxSeeeMLYCglxqdBK1m17TQeIadOmafJEpkNL/i5dupj37733nsR9cVn07t0b7du3T7VvXLFihWZQZDrcq1Pc56GJfYol7otLhS5tPPPxAM4qoKZNm5qqRSEyOwmpc+fORtynHT8T3iTui0uF1dN0pylfvrwRNmhJzPVKiMwkISEB9957rxH38+fPb9YrifviUqHd9axZs0wCG4UNtnZgYpsQmcnJkyfNXp3iPt1sJk6cKHFfXDJMXGORJQsCJk+ebIqY/Lg2WfgoO3fuNHt1ivtM0KVNv7+K+34v8JO2bdvinXfeMe+ff/55jB8/3u4hiQBi06ZNaNasGWJjY43VOiuw/fmGF/bw2muv4bHHHku1b2TPMyEyC2bes7KRm146RHTt2lWTKy4LPtdoz3/LLbcYa2IeyFnZIURmQUHfvTZR6KdNvxCXA4M87B1bsWJFY03Mdero0aOaRJEpcA/FhFx3cIe9rGkNKsTlQKGV4lm+fPmwcuVKI8QyjiBEZsBEXLbSYhs2WhYzCalkyZKaXHFZMHGNRSdMSpoxY4aJHzBOJURmQLHsnnvuwdq1a42LDZOQcuTIockVl0W9evVMSwfCYl4WMQmRma0gmjZtal7pCkiXiNDQUL+eYL8X+Al7Wz/11FPmYE7xTJX8IjOgvR5tYWhjVaNGDZM8wt6fQlwuDBQOHjzYtBRx9z5jkFqIq4XrEr9XtAVt3rw5Pv30UyUhiSuClnnc2FapUgUHDx5EnTp1sGTJEs2muCq4N2cLLSYhuZNx3a1EhLhccubMaQKF7Bm7Zs0as04pGUlkhmjG9iHunovcS9ESVIgrgYIrRTMKsOyLzuRJJSOJzBDN2DKSggddbXgGrFWrliZWXBG0TmciG+NUw4YNw3333adkJHHVUCyjHf+8efOQJUsW8ywsVqyYZlZcEVyX3K24X3nlFeNYqmQkkRmFvHXq1MGGDRtQpEgRE1vIli2b309sQAj83JQMHDgwVeR/7rnn8NJLL+nGF1fM999/bw7jx48fN9Ub7BfEDYoQVwqzwWijTgsYirGsXlQykrhS+KxjFSxt9eLi4kwgeuzYsUpCEldF9uzZTTCaSW0MRvOATrtZIa5UNOOe3F25z/dct4S4GooXL24Ch3yluK9kJHE1MPGWe3J3+5CPP/7YtNQS4mqg8MpKflYt0rmNRQPbtm3TpIor4vDhw2ZPzqprutlQ3GdMQYirgQkjFPmZ5M04lZKRxNWwefNmsydfunQpcufOjdmzZ6N69eqaVHFVUNR/9913zftPPvnExD8ZTxfiSvjtt9/MnnzHjh0oVaoU5s6di8KFCwfEZAaEwE9cLpexT3ff+Dycs5pfN764XNGM3x23aNayZUtzw7NXlRBXS3R0tOkh1LFjx9RkpJdfflnJSOKyRTNWwfK7Q1h1xsprVgoJcbWwMpZtH2hZRVtZBn+YRCnElYhm/O64RbMBAwaY/boQmdGbcfHixUpGEpkimjGRzS2ayWFEZBYNGjQw4j6TkbZs2WKEjz///FMTLK5KNGNsSm2ORGbBmDmTu5WMJK5WNOM65RbN3IltQlwtjCPQtdudjMS4J5ORjh07pskVl8WECROMm7K7kPePP/5A2bJlA2YWHRZVpgBjzJgxePjhhxEfH4+6deuaQzs3w0L8l2jG7DDaMhJWb/Tv31/BaJHpcNllDyHaDJHWrVsbuz32QRPiv0Szdu3amUQRwmpYBqO58RUiM0lMTETnzp1NP2LChBKuW7QFFeK/RDO2DKGQQdFs1KhRpg+xEJnN2bNnTVIurfX4HOQeXtXX4lJFszvuuAPbt283fdOnTp1q4gZCZDYHDhxAs2bNsHz5ckRGRhrHrRYtWmiixSWJZvyuMBhN0YyuEOXKldPMiUyHVsV8Ju7atcsUN02fPh3XX3+9Zlr8J3R/YHyKBXL8ztBpJF++fJo5kemwCIXOpSdPnjTPQj4T+WwU4r/0F7o/MJ7J9yzkZcJIoBXIBaTAn/7GL1++vAn86MYX/yaasT+suy86+7xQ7JdoJjwJHypMRkpISFAykvhPjhw5YkQz9kWnaDZy5EiTHCKEp+AWkc5IPXv2TO2D9u233yoZSVwUiWbC2ygZSVwurCyjaMbqH4lmwtvJSEyUZDISkyiFuBgSzYS3UTKSuFwomrE9ciCLZsK3WL9+vUlG2r17t5KRxH+SFESFvAEr8JN169YZi1ne+MwgYxbiddddZ/ewhA+KZgzy0OpTopnwNuwjSwvsU6dOKRlJXBRae3Ijy/6drDSjM029evU0Y8IrfPfdd3jkkUdMMhK/d/z+8XsoxMVEs5IlS5qseibZCuFpeJx955138Oqrr5o/KxlJ/JtoxqRutvFjXIDxAVWaCW8lIz399NMYOnSo+XPXrl1NEqWckcS/iWbcV1E0Y6s/IbyRjMQ9FPfwSkYS/yaacY1i+zXChDW1YhPeTEa68847sWLFCjkjiYtyLsgKeQNa4Cf79+83lmi88ZlJRks0VkAKQSSaCV9JRqJ4u2fPHiUjiX/A3kB8bkk0E76UjMTAD0VcITISzWjPmD9/fk2O8CpsB/Hoo48qGUlkCCs2GNiRaCZ8JRmJVf3Dhw+XM5IwSDQTvpKM1KlTJwwbNsz8WclIIi2xsbHGkj9YRDPhH8lIn332mUmiFCJ9IW9YWJhxv+X3JZAJeIGfnDlzxnyQP/74o7nxBw4caDYsIrihaMYb/ujRo6o0Ez6RjMQsxJUrVyoZSaQyceJEc4CiaFarVi1TaSbRTPhKMtKMGTPM91IEN2lFMyYjjRkzRpVmwjaUjCTSI9FM+HIyUv369TF58mQ5IwU56UWzDz74wFTISjQTdqBkJJERwSiaCf9JRurWrZtJopQzUnCzJY37bc6cOY37KPfagY4TQUDWrFkxdepUPP7440hOTjZZPcxC5IFKBCfjx49H48aNjbhPcYJiv2xkhZ0UKlQICxcuRJMmTYyVzF133WX6xARBDpbIAD6rPvroI9x7771G3KcTzfz58yXuC1upVKmSOdBXr14dhw8fRsOGDU0SighO4uPj8fzzz+PFF180zyrurxmYlo2ssJObbroJixYtQtGiRbFp0ybUrl3btI8Qwcnp06dN8NltI0vRjFU+gdh7UfgPdLyZPXs2smfPjl9//RU33ngjNm/ebPewhI2J/oxNcQ9F0Yyuoy+//LLEfWEbTCzp2bOnEXBDQ0Mxbtw43HbbbTh06JA+lSBlw4YN5lnFWABFs59//lnivrCVkJAQDBkyBP369TN/fv/999G2bVtT3S+Ck4ULF5p1iuJ+iRIlTAwgGMT9oBH4CTclvPH79u2baiPDgM+aNWvsHprwIrS45oJPOzyJZsIXk5Foa/zYY48ZgZfCye23347du3fbPTThRXbu3IlbbrnFBHYomjErVaKZ8NVkpFatWqFDhw44ceKE3UMTXmT58uUmQZKJaO4DNR2yJJoJX6By5coXJCPxYN+9e3ez9xfBw5w5c8x3gYloEs2ErycjVatWzfRep+OECA54zqOA6k6gdYtmjFUJ4SvJSHTCzZYtm0lGqlixonHqUhFK8MBnEpMjr732WmzdujXoRDPhf8lIVapUMY5uInhgXJKOko0aNUot5OW+qkKFCggarCBk/PjxVq5cuVgWa4WGhlp9+vSx4uPj7R6W8DCTJk2y8ufPbz53l8tl9ezZ00pISNC8C58jOTnZ6t+/vxUREWG+r1mzZrWGDh1qfi4Cl6SkJGvQoEFWdHS0+dyjoqKsgQMH6nMXPgn3Td26dbOcTqf5vhYqVMiaPn263cMSHiYuLs7q1auXFRISYj73PHnyWBMnTtS8C5/k9OnT1kMPPWS+q7yuueYaa8mSJXYPS3iYU6dOWU8++WTq516qVCnrt99+07wLn2Tfvn3WLbfckvp9rVevnrVlyxa7hyU8zP79+63mzZunfu61atWyNm7cqHkXPsm6deus6tWrp35f77nnHuvgwYN2D0t4mA0bNli1a9dO/dxvv/12fe7CZ1mwYIFVvHjx1O/r008/bZ05c8buYQkPwzNe2bJlUz/3Rx55JCg/96AU+MmBAwesu+66K/ULUKNGDWv16tV2D0t4gKNHj1pt27ZN/awrVqxoLV26VHMtfB4e8uvUqZP63W3SpIm1e/duu4clPMDOnTutm2++OfWzrl+/vrV161bNtfB5/vjjD6t8+fKp390OHTpYJ06csHtYwgOsWLHCqlatWupn3bp1a+vw4cOaa+HzTJkyxSpQoID53jIpqXv37lZsbKzdwxIeYM6cOVaxYsVS16lnn33WOnv2rOZa+DRM4v7yyy+tLFmymO9tZGSkSfZm8q8IvM965MiRVs6cOVMLjvr166fCE+EXyd29e/dOTfLNnTu3NXbsWBUjBCCJiYnWBx98YIWHh5vPOlu2bNZXX32lz1r4RXL3U089lXoOKFmypDVv3jy7hyU8wLlz56wuXbpYDocjteBoxowZQTvXQSvwuzfX33333QWb6759+2pzHUBMnjw5tWqfAb1XXnnFOn/+vN3DEuKyNtcffvhhajU/N9fDhg3T5jqAnkNffPHFBQG9AQMGKKAn/G5z/fLLL2tzHcBV+2+88cYFVfvjxo2ze1hCXBbHjh2z2rVrd0HC759//qlZDKCAXseOHRXQEwGX8Ktq/sAqMmrRokXq51uzZk1rzZo1dg9LiMti5cqVF1Tzt2rVyjp06JBmMUBQkZEIBH7++ecLEn6feeYZJfwGEL///rtVrly51M/34YcfDvoio6AW+NNutFu2bKmNdoAF8R588EFZcoqA2mint8fas2eP3cMSVxnEkyWnCCS00Q7MIF7aqn0F8USgJf/26NFDyb8BEMRLa8nZuXPnoLRmFIGT/Dt48GAl/wbYZzpq1Kh/FBapTajwV5T8G3iosEgEevIvW3bNnz/f7mGJTCgsUpvQfyKB/yJWWWFhYbLK8lOmTp0qG04RFFZZ2bNnt77++mtV8/upDWfWrFlTq/Y/+eQTVe2LgNl0v/TSS6nV/IULF7Zmzpxp97DEZcKg85tvvikbThE07btUze//NpwlSpSw5s6da/ewhMgUduzYYTVu3Dj1+92gQQO17/JD1BpUBHr7rqpVq6auU/fee6+q+f2QTZs2WTfeeKNag4qA5KeffrKKFi2q9l0B2Br0+PHjdg/LZ5DAn479+/dbzZs3T/3C1KpVy1q7dq09n464qqr9ChUqWIsXL9YsioBjw4YN1g033JD6Xb/jjjtUze8n7Nq1y7r11ltTP7u6detamzdvtntYQmQ6ixYtssqWLZv6XX/kkUeC3jbLX60377nnHuvgwYN2D0uITGfSpElWvnz5zPfc5XKplZcf8csvv1xQtf/000+ral8EbDV/dHS0+Z5HRUVZn376qZKC/agdaK5cuVKr9vv06aOqfRGQ1fy9evW6oJXX+PHj7R6WuMQCoo8++ii1HSgLUIYOHaoCIhFwnDp1ynriiScuqOZfsGCB3cMSV1C1X7BgQWvatGmau3RI4L/IZnzEiBFWjhw5Uqv5u3btqkxEH+X8+fPm4Mub3G232a1bNys2NtbuoQnh0c34e++9d0E1/7vvvmuqmYRvbij79euXWrXPQ9THH39sPkchApWYmBjrxRdfvKCaf8iQISYQJHyzyqxLly6pAToGpceMGaMgjwj4av42bdpc0NZrwoQJEtB8FPYjZ8VG2qp9iv1CBFM1Pyst6VbBuJXwPZYtW2Y1bdo09fO69tprrVWrVtk9LCE8yvLly60qVaqkfu9btGhhKvyF78Fnx5w5cy4oGmIRCotRhAhkZs+efUE1/6OPPmpt27bN7mGJDGCsfNy4cVa5cuVSP6+HHnpIVfsXQQL/v7Bv3z6rWbNmqV8k2igz8MkAqLAfCvifffaZEQzSVu3TtkOIYGH9+vXW9ddfn3oPUJChkExBWdjPiRMnrN69e6cmjLmDcrRBEyJY+PXXX60yZcqk3gPFihUziXlM0BO+sd99/vnnU6s3eN19992q2hdBxQ8//JBazc+rcuXKJqigRDzfYOPGjSao467e4NWpUycltoqgISkpyfr8889Tq/l51a9f34g0Evp9gyVLllh33nln6ufDhEmeA9n2SIhggEncr7/+unFFSiv0M+lF2A+fFbNmzbLq1KmT+vmwAIUJ+HqOiGDh5MmT1uOPP556D3C9otskk4iF/fDsTQckJt27P6MCBQqYdtzi4kjg/w/4kJs+fbp13XXXpX6xGABlIJQBUWGPPUf//v1TK/bdVYEU+1W1L4KRhIQE69tvv70gs42CMgMKFJiFPS1DaFVHZ4W0CUijRo2SWCCCEj27fY89e/ZYnTt3TnWC4VW7dm0T+FGQRwQj7OOX/tnN4AKDDBL67WHdunVW27ZtLxD2KaBRSBMimJ/ddJl03xMUa/Tsto/ff//datKkSernwfWKCUlMTBIiWItQ6I7kdnHTs9s3dI20hUHSNUSwo2e37+kadFOXrnFlSOC/zEw3Bj7dD0QGRHm44iFLeJ6zZ89aH374oZU/f/7Uz4DWKoMGDVIVoBBpMt0oJLvvEQapGaym4Cw8z5EjR6yePXumWvHzqlSpkqoAhUgj9Kd332HCHhP3+HfC8+zcudN66qmnLhAH6tata/30008S9oW4iPsOgw0MOjD4IDzP6tWrrfvuu+8CcUBVgEL8n7179/7DfYfiDUUcJel5h4ULF1q33HKLqgCFuAgbNmz4h/sOk2EorAnPw2fB5MmTrRo1asiZWIiLsHjx4gvcd7heMbmYScbC89Dl6Ouvv7ZKly4tZ+KrQAL/FTwgGQBlINR98zNAykApA6Yi8zlz5ozpNZ43b94L+i2qj68Q/96rhsJyWustCs8UoEXmc/jwYat79+4X2GZWrVpVfXyFuAi052eCXtoeaEzgYyIfE/pE5rN9+3ZjR0fLWPecN2zYUH18hbgIbHfEtkdsf+S+Zxh8YBBClsueYeXKlVarVq1S55vXPffcY3r7CiH+CdtHso0k20m67xmKORR1JPRnPpzTefPmWY0aNbrAip/7K/XxFSJjNm/ebD388MMXWPczOYZJMsIzLV3YeqpatWqp8804Vbdu3axDhw5pyoXIALYSYTKx+55hkjGTjZl0LDzT0mXo0KFWyZIlU+c8T5481rvvvqsWbFeABP6r2NjPnTvXBEbTb+wZQBWZE1R7++23rdy5c6fOcalSpayvvvpKQTUhLnFjP2HCBCM0p93YU4imIC2unoMHD1ovvfSSFRUVlTrH1157rTVp0iQz/0KI/97YM2GPiXvue4gJfUzsY4KfuHrYT4595dIG1W6++WZr/vz5ml4hLoHTp0+bYAODDu57iMEIBiW4homr56+//rJatmx5QVCtdevW1qpVqzS9QlwCFG0o3qRNNqa4Q5FHZ5LMif/NmTPHql+/fur8hoaGWh07dlShjxCXCJNgHnvssQuSjZksw6QZJSRdPVzrx48fb1WpUiV1frNkyWK98sorKvQR4hJhUjGTi9MmGzP5mEnIInMKfQYPHmwVK1YsdX7z5ctnffDBByr0uQok8GcCDJAyUOr+YjKA2q5dO2vmzJkSoi8TbuoY4OnatauVM2fO1DktW7as6TEuW0whrmyjT8GZwrP7nqIg/fTTT5usaQV9Lt8hges+AzppbTFr1aplTZs2TYdTIa4AVsMygY+JfO57igl+PXr0sFasWKH76jKh6EibXva/TCvs33bbbdaiRYv0HRXiCqC7CIMPDEK47ykGJ/r27WsSacTlz+eYMWOsO+644wJhn+vW2rVrNZ1CXAF0a6OYQ1HHfV9VrlzZGjBggLVv3z7N6WVy9OhRk8xVp06dCxw82apz9+7dmk8hroAdO3aYWAqTZNz3Vb169cxZ8Pjx45rTy4Rtgz/55BOrYsWKqfOZLVs26/XXX1erTiGuECYZM9k4bbuwZs2aGbfcmJgYzetlsmnTJuutt96yihQpkjqfBQoUMGuX5vPqcfD/QGQKv/32G9566y389NNPqT/LlSsX7rnnHtx333246aabEBISotlOB7+Ca9aswbhx4zB+/Hhs3bo19e8qVKiA1157Dffff7/mTohMuNdmzJiB3r17Y9myZak/L1y4MFq3bm3usxtuuAEOh0NznY7k5GQsXrzYrFPff/89Dhw4kPp3nLM33ngDt99+u+ZOiKskMTERo0ePRt++fbFly5bUn5crV86sUbwqVaqkec6AhIQEzJ0716xTkyZNwsmTJ1P/rmnTpnj99ddRu3ZtzZ0QV8m5c+cwZMgQvPfeezh48GDqz2vUqGHWKJ77SpQooXnOgNjYWMycOdOsU9OnTzd/Jk6nE23btsWrr75qzn9CiKvj+PHj6N+/PwYMGIDTp0+bn/GM16BBA7NG3XvvvciXL5+mOQO4f5o8ebJZp37++WezNyURERF48skn0a1bN3N+FkJcHXv27MG7776LYcOGIT4+3vwsNDQUt912m9lPtWzZEtmyZdM0ZwD3nxMmTDDr1KJFi1J/niNHDrzwwgt47rnnkDNnTs2dEFfJunXr0K9fP4wdO9bE1ElUVBSaN29u1qk77rjD7A/EP9m+fbvR+bhOrVy5MvXnhQoVQo8ePfD4448jMjJSU5cJSOD3AEuXLsW3335rHraHDh1K/XnevHnRqlUrswDUr18fLpcLwcyGDRvMTc5r48aNqT/nzd2sWTO0adMGLVq0CPp5EiKz4abkl19+wahRo4wI5A76kOLFi5ugD9cpBqqDWeznPHE9d4v6PICmPTjdfffdePDBB03yVjDPkxCegMFUBlfHjBljxKDz58+n/h0Ffvc6Vb58+aD+AJKSkrBgwQKzTv3www84duxY6t8VLFjQJG+1b98eNWvWtHWcQgQiFKcZ7OHFfRXvx7TJf1yjeA8WKVIEwUxcXBxmz55t1qmpU6fi7NmzqX9XunRpM08PP/wwypYta+s4hQhETpw4gREjRpj7748//kj9OZNqeIbh/ceClNy5cyOYOXPmjFmfOE9cr9xiI6levbrZd3Kd4t5KCJG57Nu3D8OHDzf3H4u/3ISHhxvxjPcfxbQsWbIE9dQfPXrUnPc4Tzz/sQjFTb169cx6/tBDDyF79uy2jlOIQGTTpk2p69SOHTtSf541a1aTjMT7j8lJYWFhCGZ2796dKuqnLSxkwfMtt9yCBx54wMyVkiIyFwn8HoRBnoULF6YGXfkwdsODAbOm+aWuU6eOOWAFA6zOd4v6GW3cOB8U94N94yaELwVdeVWpUiUoRGyK+swsdDuKaOMmhG8EXadNm2buyx9//PGCoGu1atVS16lSpUohGGAwh65RnI+Mkknd+0sGeoI9mVQIb3HkyBFMnDgxw6Br3bp1U8X+AgUKBMWHwnWala+cDyZrKZlUCN8IujJpmfclk5jTB125Tt11110mkTkYiImJMe52nI+MkkndjizBnkwqhK8Ugt15553mvqQzGStogyVJi0U5nA8lkwrhGzFjCtfumHFGhWBcpxo3bmwcSYKB/fv3p+4v0yeTch44H5yXYE8m9SQS+L1omzpv3jzzZWfwJ61tKqs6eHDgl50VVoFkT8EkB27K3Aen5cuXp/6drJeE8E3bVG5SKKa5bVMJ7VK5TjEzkWJ/IG1UGIRevXo1pkyZYtaptLbg0dHRqdZLtOBXlqEQ9sL9k/tenTNnTqptKqlVq5a5Vxn8oaV/IInbtAT/66+/TMIoD088RKVvB8V/e6NGjdTSSAgfsE11V1jRNtVt58hEyYYNG6ZWeJQsWTKgkidPnTpl2hlxjeJ5l0FpN7Sz5j6Sl9pBCeG7tqmsPGvSpEnqnoI2qoG0TjEZ69dff00973J/5UbtoITwHbh3Wrt2barYn7aVK2M0dHvlnoIJzXny5EEg/bvpaOBuu8bzLvUEN9QM3PsptYMSwndbuVLMpos3iy949gmkdiNcp7iPdBcLcl+V9rzLdlDcR/Lfr3ZQ3kECv01iEh/S7ooGVqa5YTC6YsWK5qHtvlid5g/ZiQyyU8xnANp98bCY9tDEf1/a7HD1BBLCdysa2BvVXdHASv+0gZ+qVatesE5VrlzZL6yI+O/gQTHtOkU3kbQVwRTx3dnhfPWH9VeIYIR29KxoYJCWQZC09tgM/Fx77bWpaxRbjjBRyR9Ef66/3D9xfWJiJF/Xr19/QUUwrRfd2eE333xzQCVdCRFIMEjrrmhgACgtPAdxbUq7n6ITiT+IaUy2cq9P7itt8J3kz5/fuBZwnbrxxhuDxrFOCH9j8+bNqZVoPCelv4/TrlG8mLDjD+vU4cOHL1ijeKWttCNcc91OUDzf+sO/S4hgg8LRihUrUtepnTt3XvD3xYoV+8c6RVczf/h37d279x/rFNeutHBtcjuKlClTxrbxCiEuDmNRaV0W09/HTCJMu0YxVuUP7TQYg9q2bdsFaxTPgEzsTgvPelynmNDA5FDhXSTw2wxtwNwZLwxOp7VZdcNgSFrRn4Eg9gFj8NpOMZ/WSenF/LQVv244TrYhYICHFWaBlF0pRDBAW1Xa9/Mwxcy8tA4kbijus7I/vejP9ht2ivmszE8bgKaYnzYDOm2QnVmG7v5u7KMkhPCviix3dTtFtLTJhW6YrMP9U9p1iqI/rWntgm1R3GK++2KyZFox3w2tvSnmu6t/7VxfhRCXz65du8xeitXt3JukTS5Ma+3Is15a4Z8tk+wUx1mJn17MZ6AnI4oXL24cj7hOcV/lD0lVQoj/s27dOrNO0S2JYn/a5Ek3rMZKL6bRldJOcZxxtPQiGYWz9HCMtNxnW0iuUxy7RH0h/AeK4mwxwhg6C1KYoJQRRYsW/cc6ZWclKcfNNinpRTKeYdPDvRNjayyK4zrF86oQwn+gZsaWbVynqPnx3s8IJuykXaN4/rOzTRJjUEzYTr9OpW215oaxKI6ZVfrU+7jmCvuQwO9D8IFPy9X0BxPaPKaHQR4+5Hkz0ZaHCwAFKveV9s/sZ3+phxYK9AziUMDja/r3HAszJ1etWpWhmM/flb4SpWzZsgruCBFA6xT70qdfp9LasLphRSkPJlwTWOmR0frkfk/h7VLWKf5+CncZrU/uP7uzoBmUSmvfndbOOv1hj+uogjtCBAYMRm/atOmCNYp7F1bGp4dtkSj6M4OaAnpG65P7utQWHVyn6M6U0frkfs/KE7eY77YzS0vBggX/sU4pE1qIwIHiPoW0tOsUkxLTOia5YXUH1yi6urEi7WJ7KV6X6qbEAA6DNRmtT+73bFnEcdGCMSPYYiB9UEq9FYUIHHjm4rqUdp3iupWR6M+1iesAe9dzHbjYXorr2aW6DvH3cD26WGyKFx2OOK60rYvSi/npK+aUyC1E4MAqUp7z0q5TFxP9mYjkTvBmTOhieymuU5eaoMjiEfe6lNFaRcc5FplQJDt69Og//v8z0ZzrZtp1ihX7gdS6V4hgh4k86ZOlmfidEUzs5jpA8f9ieyn+mZb/l5oAzvPlv+2lOD7qfFxLMxLzGQfjOdR93nPv9+Qi6TtI4PcDMhL90/b1+C+4MUm/ceGGJa1I5r7BMwoqXQwejDIS82W/KERwQXHKLValvY4fP37J/w1uDDJKTkovkvF9RhX4F4MBpvQiGavLJOYLEVwwSMxgT9pMZF6soL9UmKWcUXISA0tp1yheGQW/LwYToNIKZHylwC+ECC64v0kv+jPYcjnnM65J6c99XLvSB3O4bmWUXHQxaGOdXsxncFwIEVywyCMj0T+jpOqLwTNe+nMfY0jpA88ZBZkvBs927gIY98UETon5QgQfXDvSO6Qx+fty9j0Uz9Kf+9xJR2nXqss5S1LMp8tlejH/UpPIhRCBAxN+0ov+6duP/BvcN1HbS3/u47kx/bkvowLdi8H1KL3r5TXXXCMx38eRwO+nUOB3B6dZVZ9RBg6vyxHC0i4S7gUifZYQxTK3DTeziSTmCyEygocnZiS6g9PMCLxYJevlCGFpE5fSrk1p1ytar7mzC9mPTWK+EOJiFazuClVWVrDCIqO9FH92OQEhN6ykvVjGNQV8t5jP/rZCCJERPMu526KxUvVie6n0fRAvJ4hzMRc4d6Ub1yr+WQghLtZ20i36c191sb0UE7evBLZ8TL+Xcq9XbicRBqOZOCCEEBnB9cct+lNEu1gla0Zt3i4FJhNdrNqWhXBcpxhLl5gvhLgYLJJzi/779u3LcC/FV+67LhfGxdMnBLjXKyZtu1uDU8y3s4WluDIk8AcwDEa7LffTLwYMAmV0UOKfuTGRcC+E8NY6xaznjKyseQi72EGJ65eEeyGEtxIBuB5lFAhiEIgHpYwEMlorap0SQngDJkumtdxP79B2sTZJCjQLIbwFq/wzsrLmxb1WRnspvl5q6xEhhMiMFkoXa7PmLjLJqPWIBDEhhLegwH+xlrUZuU7yoivJpbYeEf6HBH4hhBBCCCGEEEIIIYQQQgghhBDCD3DaPQAhhBBCCCGEEEIIIYQQQgghhBBC/DcS+IUQQgghhBBCCCGEEEIIIYQQQgg/QAK/EEIIIYQQQgghhBBCCCGEEEII4QdI4BdCCCGEEEIIIYQQQgghhBBCCCH8AAn8QgghhBBCCCGEEEIIIYQQQgghhB8ggV8IIYQQQgghhBBCCCGEEEIIIYTwAyTwCyGEEEIIIYQQQgghhBBCCCGEEH6ABH4hhBBCCCGEEEIIIYQQQgghhBDCD5DAL4QQQgghhBBCCCGEEEIIIYQQQvgBEviFEEIIIYQQQgghhBBCCCGEEEIIP0ACvxBCCCGEEEIIIYQQQgghhBBCCOEHSOAXQgghhBBCCCGEEEIIIYQQQggh/AAJ/EIIIYQQQgghhBBCCCGEEEIIIYQfIIFfCCGEEEIIIYQQQgghhBBCCCGE8AMk8AshhBBCCCGEEEIIIYQQQgghhBB+gAR+IYQQQgghhBBCCCGEEEIIIYQQwg+QwC+EEEIIIYQQQgghhBBCCCGEEEL4ARL4hRBCCCGEEEIIIYQQQgghhBBCCPg+/wNgP9Off1ZquQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } - }, - "outputs": [], + ], "source": [ "# visual sanity check for one example cell, mirroring the original notebook's plot\n", "example_id = str(int(df_cell_meta.index[7]))\n", @@ -361,14 +337,7 @@ "cell_type": "code", "execution_count": 6, "id": "2f1d3bf5", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-14T20:59:30.243478Z", - "iopub.status.busy": "2026-07-14T20:59:30.243354Z", - "iopub.status.idle": "2026-07-14T20:59:30.347139Z", - "shell.execute_reply": "2026-07-14T20:59:30.346575Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -428,14 +397,7 @@ "cell_type": "code", "execution_count": 7, "id": "09ef320b", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-14T20:59:30.349203Z", - "iopub.status.busy": "2026-07-14T20:59:30.349082Z", - "iopub.status.idle": "2026-07-14T20:59:30.451245Z", - "shell.execute_reply": "2026-07-14T20:59:30.450605Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -523,26 +485,13 @@ "cell_type": "code", "execution_count": 8, "id": "10f40fda", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-14T20:59:30.452882Z", - "iopub.status.busy": "2026-07-14T20:59:30.452768Z", - "iopub.status.idle": "2026-07-14T20:59:30.682663Z", - "shell.execute_reply": "2026-07-14T20:59:30.682091Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n", "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n", "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n", "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n", @@ -701,14 +650,7 @@ "cell_type": "code", "execution_count": 9, "id": "4a21421e", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-14T20:59:30.684526Z", - "iopub.status.busy": "2026-07-14T20:59:30.684405Z", - "iopub.status.idle": "2026-07-14T20:59:30.710037Z", - "shell.execute_reply": "2026-07-14T20:59:30.709320Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -763,14 +705,7 @@ "cell_type": "code", "execution_count": 10, "id": "8e9a96f8", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-14T20:59:30.711881Z", - "iopub.status.busy": "2026-07-14T20:59:30.711716Z", - "iopub.status.idle": "2026-07-14T20:59:30.734739Z", - "shell.execute_reply": "2026-07-14T20:59:30.734108Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -865,14 +800,7 @@ "cell_type": "code", "execution_count": 11, "id": "f4ec2540", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-14T20:59:30.736344Z", - "iopub.status.busy": "2026-07-14T20:59:30.736217Z", - "iopub.status.idle": "2026-07-14T20:59:40.545232Z", - "shell.execute_reply": "2026-07-14T20:59:40.544494Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stderr", @@ -883,12 +811,14 @@ ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jishar/Documents/celldega/dega/lib/python3.12/site-packages/scanpy/plotting/_utils.py:364: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", - " plt.show()\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -930,15 +860,19 @@ "cell_type": "code", "execution_count": 12, "id": "1a864fad", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-14T20:59:40.547317Z", - "iopub.status.busy": "2026-07-14T20:59:40.547174Z", - "iopub.status.idle": "2026-07-14T20:59:40.595300Z", - "shell.execute_reply": "2026-07-14T20:59:40.594550Z" + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } - }, - "outputs": [], + ], "source": [ "n_clusters = {radius: adata.obs[\"leiden\"].nunique() for radius, adata in adatas.items()}\n", "\n", From c6ad15df4145b29031757f431e8200e413c84c87 Mon Sep 17 00:00:00 2001 From: Jaspreet Ishar Date: Thu, 16 Jul 2026 11:51:16 -0400 Subject: [PATCH 03/14] reduced redunancy with existing methods; updated notebook; added helper functions --- .../Nuclear_Expansion_Radial_Buffering.ipynb | 371 ++++++++++++++---- src/celldega/nbhd/__init__.py | 4 + src/celldega/nbhd/collection.py | 155 +++----- .../{radial_expansion.py => expansion.py} | 22 +- src/celldega/nbhd/neighborhoods.py | 136 +++---- src/celldega/nbhd/trx_streaming.py | 10 +- src/celldega/nbhd/utils.py | 72 +++- ..._radial_expansion.py => test_expansion.py} | 56 +-- tests/unit/test_nbhd/test_trx_streaming.py | 4 +- tests/unit/test_nbhd/test_utils.py | 67 ++++ 10 files changed, 587 insertions(+), 310 deletions(-) rename src/celldega/nbhd/{radial_expansion.py => expansion.py} (91%) rename tests/unit/test_nbhd/{test_radial_expansion.py => test_expansion.py} (85%) create mode 100644 tests/unit/test_nbhd/test_utils.py diff --git a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb index a0f74b1b..b7a3d8d3 100644 --- a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb +++ b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb @@ -5,7 +5,7 @@ "id": "3341e980", "metadata": {}, "source": [ - "# Nuclear-to-Cell Radial Buffering with `celldega.nbhd`\n", + "# Nuclear-to-Cell Expansion with `celldega.nbhd`\n", "\n", "This notebook is a runnable companion to a nucleus/cell segmentation-sensitivity\n", "analysis: starting from a nucleus polygon, grow it outward in fixed steps until it\n", @@ -15,7 +15,7 @@ "\n", "That workflow is now a first-class part of Celldega's neighborhood API:\n", "\n", - "- **`NeighborhoodCollection.calc_radial_expansion`** replaces the manual\n", + "- **`NeighborhoodCollection.calc_expansion`** replaces the manual\n", " `expand_nuclei_within_cell` buffering loop. It is deliberately generic: give it a\n", " `NeighborhoodCollection` of *any* entity and a matching per-entity bounding\n", " `GeoDataFrame`; it buffers every entity outward at each requested radius (in\n", @@ -24,13 +24,18 @@ " observation axis so results stay directly comparable across radii. Nucleus ->\n", " cell is just the running example below -- the same method works for any other\n", " pair of nested per-entity geometries.\n", - "- **`NeighborhoodCollection.calc_signature(by=\"cell-free\", gdf_trx=...)`** replaces\n", - " the custom `assign_trx_to_entity_streaming_parquet_optimized` + manual pivot.\n", - " It spatially joins transcripts to each radius's polygons and returns a cell-by-\n", - " gene `AnnData`, ready for the usual scanpy pipeline. A `feature_col` argument\n", - " lets it work directly with non-Xenium transcript column names (e.g. `\"name\"`\n", - " instead of `\"feature_name\"`), so a custom `transcripts.parquet` with `x`/`y`/\n", - " `name` columns doesn't need to be reshaped first.\n", + "- **`NeighborhoodCollection.calc_signature(by=\"cell-free\", ...)`** replaces the\n", + " custom `assign_trx_to_entity_streaming_parquet_optimized` + manual pivot. It\n", + " spatially joins transcripts to each radius's polygons and returns a cell-by-gene\n", + " `AnnData`, ready for the usual scanpy pipeline -- either from an in-memory\n", + " `GeoDataFrame` (`gdf_trx=`) or streamed straight from a parquet file\n", + " (`trx_parquet_path=`) for transcript files too large to hold in memory.\n", + "- **`celldega.nbhd.gdf_from_contour_coords`** builds a nucleus/cell\n", + " `GeoDataFrame` directly from a long-format vertex-coordinate table (the shape\n", + " of a `*_contour_coords.csv` export), replacing a hand-rolled `safe_polygon` +\n", + " `groupby(...).agg(list)` helper.\n", + "- **`celldega.nbhd.df_to_anndata`** wraps any entity-by-gene (or other matrix)\n", + " DataFrame as a bare `AnnData`, with no normalization/PCA/clustering computed.\n", "\n", "Because the real instrument files (OME-TIFF, per-dataset contour CSVs, a full-tile\n", "`transcripts.parquet`) aren't available here, this notebook builds a small\n", @@ -44,7 +49,14 @@ "cell_type": "code", "execution_count": 1, "id": "4d0f46b0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-16T15:44:06.157731Z", + "iopub.status.busy": "2026-07-16T15:44:06.157551Z", + "iopub.status.idle": "2026-07-16T15:44:09.007106Z", + "shell.execute_reply": "2026-07-16T15:44:09.006463Z" + } + }, "outputs": [ { "data": { @@ -90,7 +102,14 @@ "cell_type": "code", "execution_count": 2, "id": "5f2394c8", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-16T15:44:09.009393Z", + "iopub.status.busy": "2026-07-16T15:44:09.009012Z", + "iopub.status.idle": "2026-07-16T15:44:09.022451Z", + "shell.execute_reply": "2026-07-16T15:44:09.021953Z" + } + }, "outputs": [ { "data": { @@ -144,6 +163,103 @@ "gdf_nuclei.shape, gdf_cells.shape" ] }, + { + "cell_type": "markdown", + "id": "bc61b60a", + "metadata": {}, + "source": [ + "### Building from segmentation contour CSVs\n", + "\n", + "The synthetic `gdf_nuclei`/`gdf_cells` above were built directly with Shapely.\n", + "A real pipeline more often exports segmentation contours to CSV instead -- one\n", + "row per polygon vertex, grouped by a cell id (e.g. a `*_nuclei_contour_coords.csv`\n", + "/ `*_cell_contour_coords.csv` pair). `celldega.nbhd.gdf_from_contour_coords`\n", + "builds a `GeoDataFrame` directly from that long format, so you don't need to\n", + "hand-roll a `safe_polygon` + `groupby(...).agg(list)` helper yourself. Any\n", + "coordinate offsetting/rescaling (e.g. registering instrument microns into an\n", + "image's pixel space) should happen on the vertex columns before calling it." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "faac734e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-16T15:44:09.024123Z", + "iopub.status.busy": "2026-07-16T15:44:09.024015Z", + "iopub.status.idle": "2026-07-16T15:44:09.034334Z", + "shell.execute_reply": "2026-07-16T15:44:09.033837Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cell_idgeometrycenter_xcenter_y
00POLYGON ((4.33166 1.62735, 4.31013 1.29888, 4....1.8151361.627354
\n", + "
" + ], + "text/plain": [ + " cell_id geometry center_x \\\n", + "0 0 POLYGON ((4.33166 1.62735, 4.31013 1.29888, 4.... 1.815136 \n", + "\n", + " center_y \n", + "0 1.627354 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# a toy long-format contour table, matching a *_nuclei_contour_coords.csv shape --\n", + "# reuses one nucleus'''s own vertices, just to show the round trip\n", + "example_geom = gdf_nuclei.geometry.iloc[0]\n", + "vx, vy = zip(*example_geom.exterior.coords)\n", + "df_contours_demo = pd.DataFrame({\n", + " \"cell_id\": [gdf_nuclei[\"cell_id\"].iloc[0]] * len(vx),\n", + " \"vertex_x\": vx,\n", + " \"vertex_y\": vy,\n", + "})\n", + "\n", + "gdf_from_csv_demo = dega.nbhd.gdf_from_contour_coords(df_contours_demo)\n", + "gdf_from_csv_demo" + ] + }, { "cell_type": "markdown", "id": "69869e12", @@ -156,9 +272,16 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "85a6f217", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-16T15:44:09.036322Z", + "iopub.status.busy": "2026-07-16T15:44:09.036157Z", + "iopub.status.idle": "2026-07-16T15:44:09.047309Z", + "shell.execute_reply": "2026-07-16T15:44:09.046772Z" + } + }, "outputs": [ { "data": { @@ -223,7 +346,7 @@ "4 37.955601" ] }, - "execution_count": 3, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -240,9 +363,9 @@ "id": "2bda07c4", "metadata": {}, "source": [ - "## 3. Radial expansion series\n", + "## 3. Expansion series\n", "\n", - "`calc_radial_expansion` buffers every nucleus outward at each radius in\n", + "`calc_expansion` buffers every nucleus outward at each radius in\n", "`radii_um` and intersects it with the matching row of `gdf_cells`, so a nucleus\n", "never grows past its own cell's membrane. It returns a dict keyed by radius, each\n", "value a new `NeighborhoodCollection` sharing the same `cell_id` observation axis." @@ -250,9 +373,16 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "658414fd", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-16T15:44:09.048949Z", + "iopub.status.busy": "2026-07-16T15:44:09.048830Z", + "iopub.status.idle": "2026-07-16T15:44:09.136141Z", + "shell.execute_reply": "2026-07-16T15:44:09.135405Z" + } + }, "outputs": [ { "name": "stdout", @@ -270,7 +400,7 @@ ], "source": [ "radii_um = [0, 0.5, 1, 1.5, 2, 2.5, 3]\n", - "nbhd_series = nbhd_nuclei.calc_radial_expansion(gdf_cells, radii_um=radii_um)\n", + "nbhd_series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=radii_um)\n", "\n", "for radius, nbhd in nbhd_series.items():\n", " print(f\"radius={radius:>4} um -> n={len(nbhd.gdf):>4} mean_area={nbhd.gdf['area_um2'].mean():6.2f} um^2\")" @@ -278,21 +408,17 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "140c06c5", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-16T15:44:09.137851Z", + "iopub.status.busy": "2026-07-16T15:44:09.137709Z", + "iopub.status.idle": "2026-07-16T15:44:09.904417Z", + "shell.execute_reply": "2026-07-16T15:44:09.903657Z" } - ], + }, + "outputs": [], "source": [ "# visual sanity check for one example cell, mirroring the original notebook's plot\n", "example_id = str(int(df_cell_meta.index[7]))\n", @@ -320,7 +446,7 @@ "coordinates rather than microns -- e.g. the original notebook builds them via\n", "`vertex_x * high_res_scale`, where `high_res_scale = 1 / scaling_factor` is a\n", "pixels-per-micron factor (`scaling_factor` itself, from `PhysicalSizeX`, is\n", - "microns-per-pixel). `calc_radial_expansion` needs to know that scale to convert\n", + "microns-per-pixel). `calc_expansion` needs to know that scale to convert\n", "`radii_um` into the geometry's own units before buffering.\n", "\n", "Pass whichever factor your pipeline already has on hand:\n", @@ -335,9 +461,16 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "2f1d3bf5", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-16T15:44:09.906523Z", + "iopub.status.busy": "2026-07-16T15:44:09.906380Z", + "iopub.status.idle": "2026-07-16T15:44:10.007031Z", + "shell.execute_reply": "2026-07-16T15:44:10.006451Z" + } + }, "outputs": [ { "name": "stdout", @@ -360,7 +493,7 @@ "nbhd_nuclei_px = dega.nbhd.NeighborhoodCollection(\n", " gdf=gdf_nuclei_px, nbhd_type=\"nucleus\", nbhd_col=\"cell_id\"\n", ")\n", - "nbhd_series_px = nbhd_nuclei_px.calc_radial_expansion(\n", + "nbhd_series_px = nbhd_nuclei_px.calc_expansion(\n", " gdf_cells_px,\n", " radii_um=radii_um,\n", " is_pixel_space=True,\n", @@ -395,9 +528,16 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "09ef320b", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-16T15:44:10.008694Z", + "iopub.status.busy": "2026-07-16T15:44:10.008575Z", + "iopub.status.idle": "2026-07-16T15:44:10.109064Z", + "shell.execute_reply": "2026-07-16T15:44:10.108613Z" + } + }, "outputs": [ { "data": { @@ -411,7 +551,7 @@ " 'MarkerB': 625})" ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -483,16 +623,29 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "10f40fda", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-16T15:44:10.111160Z", + "iopub.status.busy": "2026-07-16T15:44:10.110996Z", + "iopub.status.idle": "2026-07-16T15:44:10.322544Z", + "shell.execute_reply": "2026-07-16T15:44:10.322053Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n", - "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n", + "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n", "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n", "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n", @@ -608,7 +761,7 @@ "3.0 610.0 571.0 291.0 284.0 984.0 837.0" ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -635,6 +788,56 @@ "gene_totals" ] }, + { + "cell_type": "markdown", + "id": "b7de3063", + "metadata": {}, + "source": [ + "### A bare AnnData, without Celldega's cat/color bookkeeping\n", + "\n", + "`calc_signature` already returns a ready-to-use `AnnData` in\n", + "`nbhd.mod[\"gene_cell_free\"]` (with `n_transcripts`, `cat`, `color` metadata\n", + "attached). If you already have your own entity-by-gene DataFrame -- built by\n", + "hand, or from a lower-level function directly -- `celldega.nbhd.df_to_anndata`\n", + "wraps it as a plain `AnnData` (`obs` = the DataFrame's index, `var` = its\n", + "columns, `X` = its values), with no normalization, PCA, neighbors, or\n", + "clustering computed." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7ec22ce0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-16T15:44:10.324334Z", + "iopub.status.busy": "2026-07-16T15:44:10.324212Z", + "iopub.status.idle": "2026-07-16T15:44:10.327415Z", + "shell.execute_reply": "2026-07-16T15:44:10.326767Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "AnnData object with n_obs × n_vars = 120 × 6" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_gene_counts = pd.DataFrame(\n", + " nbhd_series[3.0].mod[\"gene_cell_free\"].X,\n", + " index=nbhd_series[3.0].mod[\"gene_cell_free\"].obs_names,\n", + " columns=nbhd_series[3.0].mod[\"gene_cell_free\"].var_names,\n", + ")\n", + "adata_bare = dega.nbhd.df_to_anndata(df_gene_counts)\n", + "adata_bare" + ] + }, { "cell_type": "markdown", "id": "081a93dd", @@ -648,9 +851,16 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "id": "4a21421e", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-16T15:44:10.329020Z", + "iopub.status.busy": "2026-07-16T15:44:10.328894Z", + "iopub.status.idle": "2026-07-16T15:44:10.352373Z", + "shell.execute_reply": "2026-07-16T15:44:10.351661Z" + } + }, "outputs": [ { "name": "stdout", @@ -703,9 +913,16 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "id": "8e9a96f8", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-16T15:44:10.354180Z", + "iopub.status.busy": "2026-07-16T15:44:10.354045Z", + "iopub.status.idle": "2026-07-16T15:44:10.374415Z", + "shell.execute_reply": "2026-07-16T15:44:10.373970Z" + } + }, "outputs": [ { "data": { @@ -770,7 +987,7 @@ "4 34" ] }, - "execution_count": 10, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -798,9 +1015,16 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "id": "f4ec2540", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-16T15:44:10.376329Z", + "iopub.status.busy": "2026-07-16T15:44:10.376208Z", + "iopub.status.idle": "2026-07-16T15:44:20.125826Z", + "shell.execute_reply": "2026-07-16T15:44:20.125025Z" + } + }, "outputs": [ { "name": "stderr", @@ -811,14 +1035,12 @@ ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jishar/Documents/celldega/dega/lib/python3.12/site-packages/scanpy/plotting/_utils.py:364: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " plt.show()\n" + ] } ], "source": [ @@ -858,21 +1080,17 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "id": "1a864fad", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-16T15:44:20.128192Z", + "iopub.status.busy": "2026-07-16T15:44:20.128045Z", + "iopub.status.idle": "2026-07-16T15:44:20.176612Z", + "shell.execute_reply": "2026-07-16T15:44:20.175735Z" } - ], + }, + "outputs": [], "source": [ "n_clusters = {radius: adata.obs[\"leiden\"].nunique() for radius, adata in adatas.items()}\n", "\n", @@ -901,20 +1119,21 @@ "\n", "| Original notebook | This notebook / Celldega API |\n", "| --- | --- |\n", + "| `safe_polygon` + `groupby(\"cell_id\").agg(list)` parsing `..._nuclei_contour_coords.csv` | `dega.nbhd.gdf_from_contour_coords(df_contours, id_col=\"cell_id\", x_col=\"vertex_x\", y_col=\"vertex_y\")` |\n", "| `gdf_nuclei_original` (parsed from `..._nuclei_contour_coords.csv`) | `gdf_nuclei` -> `NeighborhoodCollection(gdf=gdf_nuclei, nbhd_col=\"cell_id\")` |\n", - "| `gdf_cells` / `gdf_cells2` (parsed from `..._Expanded_5um_cell_contour_coords.csv`) | `gdf_cells` passed to `calc_radial_expansion` |\n", - "| `expand_nuclei_within_cell(nuclei_gdf, expand_um)` loop building `nuclei_gdfs = {\"original\": ..., \"expanded_0_5um\": ..., ...}` | `nbhd_series = nbhd_nuclei.calc_radial_expansion(gdf_cells, radii_um=[0, 0.5, 1, 1.5, 2, 2.5, 3])` |\n", + "| `gdf_cells` / `gdf_cells2` (parsed from `..._Expanded_5um_cell_contour_coords.csv`) | `gdf_cells` passed to `calc_expansion` |\n", + "| `expand_nuclei_within_cell(nuclei_gdf, expand_um)` loop building `nuclei_gdfs = {\"original\": ..., \"expanded_0_5um\": ..., ...}` | `nbhd_series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[0, 0.5, 1, 1.5, 2, 2.5, 3])` |\n", "| `assign_trx_to_entity_streaming_parquet_optimized(trx_parquet_path, entity_gdf, x_col=\"x\", y_col=\"y\", gene_col=\"name\", batch_size=1_000_000)` + manual `pivot_table` per radius | `nbhd.calc_signature(by=\"cell-free\", trx_parquet_path=trx_parquet_path, x_col=\"x\", y_col=\"y\", feature_col=\"name\", batch_size=1_000_000)` per radius -- same batched-parquet-plus-spatial-index mechanics, now built in |\n", "| `assignments_out=...` (per-transcript assignment parquet) | not written by `calc_signature` (it only needs the resulting counts); if you need per-transcript assignments too, keep using your own writer alongside it |\n", "| Just the transcript *total* per entity, no gene breakdown | `nbhd.calc_transcript_assignment(trx_parquet_path=trx_parquet_path, x_col=\"x\", y_col=\"y\", gene_col=\"name\")` -> adds a `total_transcripts` column to `nbhd.obs` via the same streaming join |\n", - "| Per-radius `pd.read_parquet(..._nuclei_by_gene.parquet)` -> `AnnData` | `nbhd.mod[\"gene_cell_free\"]` (already an `AnnData`) |\n", + "| Per-radius `pd.read_parquet(..._nuclei_by_gene.parquet)` -> `AnnData` (e.g. `ad.AnnData(X=nbg)`) | `nbhd.mod[\"gene_cell_free\"]` (already an `AnnData`), or `dega.nbhd.df_to_anndata(your_own_df)` for a bare one with no Celldega bookkeeping |\n", "| Per-radius `adata.write(...h5ad)` | `nbhd.mod[\"gene_cell_free\"].write_h5ad(...)`, or persist the whole collection (geometry + all modalities) with `nbhd.write(\"radius.h5mu\")` |\n", "\n", "`calc_signature` also accepts `gdf_trx=` (an already-in-memory `GeoDataFrame` of\n", "transcript points) for smaller or pre-filtered transcript sources -- see the\n", "sanity-check cell above, which confirms both paths agree. Use `trx_parquet_path=`\n", - "whenever the transcripts don't comfortably fit in memory, especially since a\n", - "radial-expansion series re-joins the same transcripts once per radius.\n" + "whenever the transcripts don't comfortably fit in memory, especially since an\n", + "expansion series re-joins the same transcripts once per radius." ] }, { diff --git a/src/celldega/nbhd/__init__.py b/src/celldega/nbhd/__init__.py index a68f3678..229229d8 100644 --- a/src/celldega/nbhd/__init__.py +++ b/src/celldega/nbhd/__init__.py @@ -10,6 +10,8 @@ _get_df_cell, _get_gdf_cell, _get_gdf_trx, + df_to_anndata, + gdf_from_contour_coords, ) @@ -22,7 +24,9 @@ "_get_gdf_trx", "alpha_shape", "alpha_shape_cell_clusters", + "df_to_anndata", "filter_alpha_shapes", + "gdf_from_contour_coords", "generate_hextile", "hextile_niche", ] diff --git a/src/celldega/nbhd/collection.py b/src/celldega/nbhd/collection.py index b4ca55ee..e7690883 100644 --- a/src/celldega/nbhd/collection.py +++ b/src/celldega/nbhd/collection.py @@ -314,11 +314,11 @@ def calc_gradient( ) return type(self)(gdf=gdf_rings, nbhd_type=nbhd_type, **kwargs) - def calc_radial_expansion( + def calc_expansion( self, gdf_bounds: gpd.GeoDataFrame, radii_um: Sequence[float] = (0, 0.5, 1, 1.5, 2, 2.5, 3), - nbhd_type: str = "radial_expansion", + nbhd_type: str = "expansion", *, technology: str | None = None, scale_um_per_pixel: float | None = None, @@ -336,40 +336,35 @@ def calc_radial_expansion( collection independently, using each one as its own tiny ROI, and clips the result to a matching row in ``gdf_bounds`` (joined by ``self.nbhd_col``). One new ``NeighborhoodCollection`` is returned per - radius, all sharing the same observation axis (the entity ids) so - ``calc_signature``/``calc_population`` results stay directly comparable - across radii. + radius, all sharing the same observation axis so ``calc_signature``/ + ``calc_population`` results stay directly comparable across radii. The canonical use case is a segmented nucleus growing outward until it - reaches its corresponding cell boundary — e.g. to see how nuclear vs. - cytoplasmic transcript capture changes as the working boundary is - expanded toward the true cell membrane — but ``gdf_bounds`` can be any + reaches its corresponding cell boundary, but ``gdf_bounds`` can be any per-entity containing geometry (this collection's entities need not be nuclei, and ``gdf_bounds`` need not be cells). Args: gdf_bounds: Per-entity clipping boundary (e.g. a cell segmentation polygon for each nucleus), with a column named ``self.nbhd_col`` - matching this collection's neighborhood ids and a ``geometry`` - column. Every buffered entity is intersected with its matching - row. + and a ``geometry`` column. Every buffered entity is intersected + with its matching row. radii_um: Buffer distances in microns (default ``0`` through ``3`` in ``0.5`` steps). ``0`` returns the original (validity-repaired) entity geometry, clipped to its bound. nbhd_type: Label recorded on each returned collection (default - ``"radial_expansion"``). + ``"expansion"``). technology: Imaging platform used to look up ``scale_um_per_pixel`` for pixel-space geometry (e.g. ``"Xenium"``). - scale_um_per_pixel: Microns per pixel — the factor a micron distance - is *divided* by to get pixels. Required (directly, via + scale_um_per_pixel: Microns per pixel (a micron distance is + *divided* by this to get pixels). Required (directly, via ``technology``, or via ``pixels_per_micron``) when - ``is_pixel_space=True``. Takes precedence over + ``is_pixel_space=True``; takes precedence over ``pixels_per_micron`` if both are given. - pixels_per_micron: Pixels per micron — the reciprocal convention, - where a micron distance is *multiplied* by this factor to get - pixels (e.g. a notebook's own ``buffer_dist = expand_um * - high_res_scale``). Equivalent to passing - ``scale_um_per_pixel=1 / pixels_per_micron``. + pixels_per_micron: Pixels per micron — the reciprocal convention + (a micron distance is *multiplied* by this to get pixels, e.g. a + notebook's own ``buffer_dist = expand_um * high_res_scale``). + Equivalent to ``scale_um_per_pixel=1 / pixels_per_micron``. is_pixel_space: ``True`` if this collection's geometry is in pixel units; ``False`` (default) if already in microns. join_style: Shapely buffer join style (``1``=round, ``2``=mitre @@ -394,31 +389,19 @@ def calc_radial_expansion( Examples: >>> nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_col="cell_id") - >>> series = nbhd_nuclei.calc_radial_expansion(gdf_cells, radii_um=[0, 1, 2, 3]) + >>> series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[0, 1, 2, 3]) >>> for radius, nbhd in series.items(): ... nbhd.calc_signature(by="cell-free", gdf_trx=gdf_trx, drop_missing=False) - - If this collection's geometry is in pixel space, pass whichever - scale factor your pipeline already computes — e.g. a - ``high_res_scale`` (pixels/micron) straight from a notebook, with no - need to invert it into microns/pixel first:: - - >>> series = nbhd_nuclei.calc_radial_expansion( - ... gdf_cells, radii_um=[0, 1, 2, 3], - ... is_pixel_space=True, pixels_per_micron=high_res_scale, - ... ) """ - from celldega.nbhd.radial_expansion import _calc_radial_expansion + from celldega.nbhd.expansion import _calc_expansion if self.gdf is None: - raise ValueError( - "gdf or geometry is required to calculate a radial expansion series" - ) + raise ValueError("gdf or geometry is required to calculate an expansion series") if self.transformation_matrix is not None and "transformation_matrix" not in kwargs: kwargs["transformation_matrix"] = self.transformation_matrix - per_radius_gdf = _calc_radial_expansion( + per_radius_gdf = _calc_expansion( self.gdf, gdf_bounds, radii_um=radii_um, @@ -601,26 +584,22 @@ def calc_signature( `x_location`/`y_location` columns); defaults to ``self.data_dir``. Used only when neither ``gdf_trx`` nor ``trx_parquet_path`` is given. - gdf_trx: Pre-loaded transcript points for ``by="cell-free"``, for - transcript sources that don't follow the ``data_dir`` convention - (custom paths, column names, or pre-filtering). Loads the whole - frame into memory for one spatial join; takes precedence over - ``trx_parquet_path`` and ``data_dir``. - feature_col: Gene/feature column name (default ``"feature_name"``). - Used as the column in ``gdf_trx`` when given, or as the gene - column when streaming from ``trx_parquet_path``. - trx_parquet_path: Path to a transcripts parquet file (or dataset) to - stream in batches instead of loading into memory — for transcript - files too large for an in-memory ``gdf_trx``/``data_dir`` join - (e.g. a whole-tile file streamed once per radius across a - :meth:`calc_radial_expansion` series). Requires - ``x_col``/``y_col``/``feature_col`` to match its columns. Takes - precedence over ``data_dir`` but not ``gdf_trx``. + gdf_trx: Pre-loaded transcript points for ``by="cell-free"`` (custom + paths/column names); loads the whole frame into memory for one + spatial join. Takes precedence over ``trx_parquet_path`` and + ``data_dir``. + feature_col: Gene/feature column name (default ``"feature_name"``), + used with ``gdf_trx`` or as the gene column when streaming from + ``trx_parquet_path``. + trx_parquet_path: Transcripts parquet path to stream in batches + instead of loading into memory — for transcript files too large + for an in-memory join (e.g. a whole-tile file streamed once per + radius across a :meth:`calc_expansion` series). Takes precedence + over ``data_dir`` but not ``gdf_trx``. x_col: Transcript x-coordinate column in ``trx_parquet_path``. y_col: Transcript y-coordinate column in ``trx_parquet_path``. batch_size: Rows read per streamed batch when using - ``trx_parquet_path``. Bounds peak memory use; does not affect the - result. + ``trx_parquet_path``. drop_missing: When ``True`` (default), neighborhoods with fewer than ``min_cells`` cells (or transcripts) are removed from the collection entirely. When ``False``, the collection keeps all @@ -766,60 +745,38 @@ def calc_transcript_assignment( ) -> None: """Add per-neighborhood transcript-count columns to ``obs``. - Two mutually exclusive modes: - - - **Audit mode** (default, ``data_dir``): reads a Xenium-convention - ``transcripts.parquet`` that already carries a per-transcript - ``cell_id`` column (unassigned transcripts marked by the - ``"UNASSIGNED"`` sentinel) and adds ``total_transcripts``, - ``unassigned_transcripts``, and ``transcript_assignment_proportion``. - The transcript-to-cell assignment is **not computed** in this mode — - it must already be present in the instrument data. - - **Streaming mode** (``trx_parquet_path``): computes transcript-to- - neighborhood assignment from geometry — via the same batched, - spatial-index-accelerated point-in-polygon join used by - ``calc_signature(trx_parquet_path=...)`` — for transcript files that - don't carry a pre-existing per-transcript assignment (e.g. a custom - pipeline's ``x``/``y``/gene ``transcripts.parquet`` with no - ``cell_id`` column, or a radius from - :meth:`calc_radial_expansion`). Adds only ``total_transcripts`` — - there's no pre-existing assignment to compare against, so - ``unassigned_transcripts``/``transcript_assignment_proportion`` don't - apply. For a full gene expression matrix (not just totals) in this - mode, use ``calc_signature(by="cell-free", trx_parquet_path=...)`` - instead. + Default (audit) mode reads a Xenium-convention ``transcripts.parquet`` + that already carries a per-transcript ``cell_id`` column (unassigned + transcripts marked ``"UNASSIGNED"``) and adds ``total_transcripts``, + ``unassigned_transcripts``, and ``transcript_assignment_proportion`` — + assignment isn't computed here, just audited. + + Pass ``trx_parquet_path`` instead to compute ``total_transcripts`` from + geometry via the same streaming, spatial-index-accelerated join as + ``calc_signature(trx_parquet_path=...)``, for transcripts with no + pre-existing ``cell_id`` (e.g. a custom pipeline's own ``x``/``y``/gene + file). Only ``total_transcripts`` is added in this mode; use + ``calc_signature`` for a full gene expression matrix. Args: - data_dir: Directory containing a Xenium-convention - ``transcripts.parquet`` for audit mode; defaults to - ``self.data_dir``. Ignored when ``trx_parquet_path`` is given. - trx_parquet_path: Path to a transcripts parquet file (or dataset) to - stream in batches for streaming mode, instead of audit mode. - x_col: Transcript x-coordinate column in ``trx_parquet_path`` - (streaming mode only). - y_col: Transcript y-coordinate column in ``trx_parquet_path`` - (streaming mode only). - gene_col: Transcript gene/feature column in ``trx_parquet_path`` - (streaming mode only) — only used to batch the point-in-polygon - join; the per-gene breakdown itself is discarded here. + data_dir: Directory with a Xenium-convention ``transcripts.parquet`` + (audit mode); defaults to ``self.data_dir``. Ignored when + ``trx_parquet_path`` is given. + trx_parquet_path: Transcripts parquet path to stream for + geometry-based counting instead of audit mode. + x_col: Transcript x-coordinate column (streaming mode only). + y_col: Transcript y-coordinate column (streaming mode only). + gene_col: Transcript gene column (streaming mode only) — only used + to batch the join; the per-gene breakdown is discarded. batch_size: Rows read per streamed batch (streaming mode only). - Bounds peak memory use; does not affect the result. Returns: ``None`` — the columns are added to ``self.obs``. Raises: - ValueError: If geometry is missing, the transcripts lack a - ``cell_id`` column in audit mode, or neither ``data_dir`` nor - ``trx_parquet_path`` resolves to a usable transcript source. A - complete absence of the ``"UNASSIGNED"`` sentinel in audit mode - only warns. - - Examples: - >>> nbhd.calc_transcript_assignment( - ... trx_parquet_path="dataset_transcripts.parquet", - ... x_col="x", y_col="y", gene_col="name", - ... ) + ValueError: If geometry is missing, transcripts lack ``cell_id`` in + audit mode, or neither transcript source is given. Audit mode + only warns if the ``"UNASSIGNED"`` sentinel is entirely absent. """ if self.gdf is None: raise ValueError("gdf or geometry is required to calculate transcript assignment") diff --git a/src/celldega/nbhd/radial_expansion.py b/src/celldega/nbhd/expansion.py similarity index 91% rename from src/celldega/nbhd/radial_expansion.py rename to src/celldega/nbhd/expansion.py index 75caa80a..8190d72a 100644 --- a/src/celldega/nbhd/radial_expansion.py +++ b/src/celldega/nbhd/expansion.py @@ -1,4 +1,4 @@ -"""Radial expansion: per-entity buffering clipped to a matching bounding geometry. +"""Expansion: per-entity buffering clipped to a matching bounding geometry. Unlike :mod:`celldega.nbhd.gradient` — which grows concentric rings outward from and inward into ONE dissolved region of interest (e.g. a tumor alpha shape) — this grows @@ -26,7 +26,7 @@ _DEFAULT_RADII_UM: tuple[float, ...] = (0, 0.5, 1, 1.5, 2, 2.5, 3) -def _calc_radial_expansion( +def _calc_expansion( gdf_source: gpd.GeoDataFrame, gdf_bounds: gpd.GeoDataFrame, radii_um: Sequence[float] = _DEFAULT_RADII_UM, @@ -40,7 +40,7 @@ def _calc_radial_expansion( mitre_limit: float = 5.0, add_colors: bool = True, ) -> dict[float, gpd.GeoDataFrame]: - """Engine behind :meth:`NeighborhoodCollection.calc_radial_expansion`. + """Engine behind :meth:`NeighborhoodCollection.calc_expansion`. For each radius in ``radii_um``, buffers every entity in ``gdf_source`` outward by that distance and intersects the result with the matching row (by @@ -97,16 +97,10 @@ def _calc_radial_expansion( Examples: Prefer the public method, which anchors on a collection of entities and - returns one new collection per radius:: + returns one new collection per radius (pass ``pixels_per_micron=`` for + pixel-space geometry, e.g. a notebook's own ``high_res_scale``):: - >>> series = nbhd_nuclei.calc_radial_expansion(gdf_cells, radii_um=[0, 1, 2, 3]) - - If geometry is in pixel space (e.g. built with a ``high_res_scale = - 1 / scaling_factor`` px/micron factor, so ``buffer_dist = expand_um * - high_res_scale``), pass that same factor directly as - ``pixels_per_micron`` instead of inverting it yourself:: - - >>> series = nbhd_nuclei.calc_radial_expansion( + >>> series = nbhd_nuclei.calc_expansion( ... gdf_cells, radii_um=[0, 1, 2, 3], ... is_pixel_space=True, pixels_per_micron=high_res_scale, ... ) @@ -150,7 +144,9 @@ def _calc_radial_expansion( ) radii_sorted = sorted({float(r) for r in radii_um}) - colors = _ring_colors("viridis", len(radii_sorted)) if add_colors else [None] * len(radii_sorted) + colors = ( + _ring_colors("viridis", len(radii_sorted)) if add_colors else [None] * len(radii_sorted) + ) color_by_radius = dict(zip(radii_sorted, colors, strict=True)) results: dict[float, gpd.GeoDataFrame] = {} diff --git a/src/celldega/nbhd/neighborhoods.py b/src/celldega/nbhd/neighborhoods.py index f64b76a8..b60500a6 100644 --- a/src/celldega/nbhd/neighborhoods.py +++ b/src/celldega/nbhd/neighborhoods.py @@ -21,40 +21,13 @@ from scipy import sparse from celldega.nbhd.collection import NeighborhoodCollection +from celldega.nbhd.utils import df_to_anndata def _nbhd_geometry_for_join(gdf_nbhd: gpd.GeoDataFrame, nbhd_col: str) -> gpd.GeoDataFrame: return gdf_nbhd[[nbhd_col, "geometry"]].reset_index(drop=True) -def _pivot_trx_counts_by_sjoin( - gdf_trx_pts: gpd.GeoDataFrame, - feature_col: str, - nbhd_col: str, - gdf_nbhd: gpd.GeoDataFrame, -) -> pd.DataFrame: - """In-memory transcript-to-neighborhood counts via a single spatial join. - - Shared by the ``gdf_trx=`` and ``data_dir=`` cell-free code paths. For - transcript files too large to hold in memory this way, see - :mod:`celldega.nbhd.trx_streaming` (``trx_parquet_path=``) instead. - """ - joined = gdf_trx_pts.sjoin( - _nbhd_geometry_for_join(gdf_nbhd, nbhd_col), - how="left", - predicate="within", - ) - return ( - joined.groupby([nbhd_col, feature_col]) - .size() - .unstack(fill_value=0) - .rename_axis(None, axis=1) - .reindex(gdf_nbhd[nbhd_col]) - .fillna(0) - .astype(int) - ) - - def _calc_nbhd_by_gene( gdf_nbhd: gpd.GeoDataFrame, by: str = "cell", @@ -76,8 +49,8 @@ def _calc_nbhd_by_gene( :meth:`NeighborhoodCollection.calc_signature`. Computes gene expression values for each neighborhood, either from cell-level - expression data (mean expression of cells within each neighborhood) or from - raw transcript counts (cell-free mode). + expression data (mean expression of cells within each neighborhood, `by="cell"`) + or from raw transcript counts (`by="cell-free"`). Parameters ---------- @@ -85,59 +58,43 @@ def _calc_nbhd_by_gene( GeoDataFrame containing neighborhood geometries. Must have a geometry column and a column specified by `nbhd_col` for neighborhood identifiers. by : str, default "cell" - Method for calculating gene expression: - - "cell": Mean expression of cells within each neighborhood (requires `adata`) - - "cell-free": Transcript counts within each neighborhood (requires `data_dir` - or a pre-loaded `gdf_trx`) + "cell" (requires `adata`) or "cell-free" (requires one of `gdf_trx`, + `trx_parquet_path`, `data_dir`). adata : AnnData, optional AnnData object with cell data. Required when `by="cell"`. Must have spatial coordinates in `obsm["spatial"]`. data_dir : str, optional - Path to a directory containing a Xenium-convention `transcripts.parquet` - (`feature_name`/`x_location`/`y_location` columns). Used when - `by="cell-free"` and neither `gdf_trx` nor `trx_parquet_path` is given. + Directory with a Xenium-convention `transcripts.parquet` + (`feature_name`/`x_location`/`y_location` columns). Used for `by="cell-free"` + when neither `gdf_trx` nor `trx_parquet_path` is given. gdf_trx : gpd.GeoDataFrame, optional - Pre-loaded transcript points, for transcript sources that don't follow the - `data_dir` convention (custom file paths, column names, or pre-filtering). - Must have a `geometry` column of transcript points and a gene/feature - column named `feature_col`. Takes precedence over `trx_parquet_path` and - `data_dir`. + Pre-loaded transcript points for `by="cell-free"` (custom paths/column + names); a `geometry` column plus a gene column named `feature_col`. Takes + precedence over `trx_parquet_path` and `data_dir`. feature_col : str, default "feature_name" - Gene/feature column name. Used as the column in `gdf_trx` when it is - given, or as `gene_col` when streaming from `trx_parquet_path` (transcripts - loaded from `data_dir` always use the Xenium `feature_name` column). + Gene/feature column name, used with `gdf_trx` or as `gene_col` when + streaming from `trx_parquet_path` (`data_dir` always uses `feature_name`). trx_parquet_path : str, optional - Path to a transcripts parquet file (or dataset) to stream in batches - instead of loading into memory — for transcript files too large for an - in-memory `gdf_trx`/`data_dir` join. Requires `x_col`/`y_col`/`feature_col` - to match its columns. Takes precedence over `data_dir` but not `gdf_trx`. - x_col : str, default "x" - Transcript x-coordinate column in `trx_parquet_path`. - y_col : str, default "y" - Transcript y-coordinate column in `trx_parquet_path`. + Transcripts parquet path to stream in batches for `by="cell-free"` + instead of loading into memory (see `celldega.nbhd.trx_streaming`); takes + precedence over `data_dir` but not `gdf_trx`. + x_col, y_col : str, default "x", "y" + Transcript coordinate columns in `trx_parquet_path`. batch_size : int, default 1_000_000 - Rows read per streamed batch when using `trx_parquet_path`. Bounds peak - memory use; does not affect the result. + Rows read per streamed batch when using `trx_parquet_path`. nbhd_col : str, default "name" Column in `gdf_nbhd` containing neighborhood identifiers. min_cells : int, default 1 Minimum number of cells/transcripts required within a neighborhood to - include it in the output. Only applies when `by="cell"`. + include it in the output. Returns ------- AnnData - AnnData object with shape (n_neighborhoods, n_genes) where: - - `X`: Matrix of gene expression values (mean for cell-derived, counts for cell-free) - - `obs`: DataFrame indexed by neighborhood names - - `var`: DataFrame indexed by gene names - - `obs["n_cells"]`: Cell count per neighborhood (when `by="cell"`) - - `uns["by"]`: Method used ("cell" or "cell-free") - - Notes - ----- - For cluster-specific gene expression analysis, filter your AnnData object - to include only cells from the desired cluster before calling this function. + Shape (n_neighborhoods, n_genes): `X` = expression values (mean for + cell-derived, counts for cell-free), `obs`/`var` indexed by neighborhood/ + gene, plus `obs["n_cells"]` (`by="cell"`) or `obs["n_transcripts"]` + (`by="cell-free"`) and `uns["by"]`. """ if by == "cell": if adata is None: @@ -179,21 +136,23 @@ def _calc_nbhd_by_gene( # Reindex to preserve order df_result = df_result.reindex(filtered_gdf[nbhd_col]).fillna(0) - # Build AnnData - adata_nbg = AnnData( - X=df_result.values, - obs=pd.DataFrame(index=df_result.index), - var=pd.DataFrame(index=df_result.columns), - ) - - # Add cell counts + adata_nbg = df_to_anndata(df_result) adata_nbg.obs["n_cells"] = [cell_counts.get(n, 0) for n in adata_nbg.obs.index] elif by == "cell-free": if gdf_trx is not None: print("Calculating neighborhood-by-gene (cell-free, provided gdf_trx)") - df_result = _pivot_trx_counts_by_sjoin( - gdf_trx[[feature_col, "geometry"]], feature_col, nbhd_col, gdf_nbhd + joined = gdf_trx[[feature_col, "geometry"]].sjoin( + _nbhd_geometry_for_join(gdf_nbhd, nbhd_col), how="left", predicate="within" + ) + df_result = ( + joined.groupby([nbhd_col, feature_col]) + .size() + .unstack(fill_value=0) + .rename_axis(None, axis=1) + .reindex(gdf_nbhd[nbhd_col]) + .fillna(0) + .astype(int) ) elif trx_parquet_path is not None: print("Calculating neighborhood-by-gene (cell-free, streaming parquet)") @@ -222,9 +181,19 @@ def _calc_nbhd_by_gene( engine="pyarrow", ) geometry = gpd.points_from_xy(df_trx["x_location"], df_trx["y_location"]) - gdf_trx_xenium = gpd.GeoDataFrame(df_trx[["feature_name"]], geometry=geometry) feature_col = "feature_name" - df_result = _pivot_trx_counts_by_sjoin(gdf_trx_xenium, feature_col, nbhd_col, gdf_nbhd) + joined = gpd.GeoDataFrame(df_trx[[feature_col]], geometry=geometry).sjoin( + _nbhd_geometry_for_join(gdf_nbhd, nbhd_col), how="left", predicate="within" + ) + df_result = ( + joined.groupby([nbhd_col, feature_col]) + .size() + .unstack(fill_value=0) + .rename_axis(None, axis=1) + .reindex(gdf_nbhd[nbhd_col]) + .fillna(0) + .astype(int) + ) else: raise ValueError( "data_dir, gdf_trx, or trx_parquet_path is required when by='cell-free'" @@ -237,14 +206,7 @@ def _calc_nbhd_by_gene( filtered_gdf = gdf_nbhd[gdf_nbhd[nbhd_col].isin(valid_nbhds)].reset_index(drop=True) - # Build AnnData - adata_nbg = AnnData( - X=df_result.values, - obs=pd.DataFrame(index=df_result.index), - var=pd.DataFrame(index=df_result.columns), - ) - - # Add transcript counts + adata_nbg = df_to_anndata(df_result) adata_nbg.obs["n_transcripts"] = trx_counts.loc[valid_nbhds].values else: diff --git a/src/celldega/nbhd/trx_streaming.py b/src/celldega/nbhd/trx_streaming.py index 0857416a..e77f5ce2 100644 --- a/src/celldega/nbhd/trx_streaming.py +++ b/src/celldega/nbhd/trx_streaming.py @@ -6,7 +6,7 @@ whole-tile ``transcripts.parquet`` (tens of millions of rows, e.g. covering a 55,000 x 55,000 micron tile) that is more memory than is comfortable to hold — especially when the same file is assigned once per radius in a -:meth:`~celldega.nbhd.collection.NeighborhoodCollection.calc_radial_expansion` +:meth:`~celldega.nbhd.collection.NeighborhoodCollection.calc_expansion` series. This module instead streams the parquet file in batches via ``pyarrow``, and for @@ -50,8 +50,8 @@ def _assign_trx_to_entity_streaming_parquet( ``gene_col``. gdf_entity: One row per entity to assign transcripts to — e.g. a nucleus, cell, or a single radius's buffered polygons from - :meth:`NeighborhoodCollection.calc_radial_expansion` — with an - ``id_col`` column and a ``geometry`` column. + :meth:`NeighborhoodCollection.calc_expansion` — with an ``id_col`` + column and a ``geometry`` column. id_col: Column in ``gdf_entity`` identifying each entity. x_col: Transcript x-coordinate column in the parquet file. y_col: Transcript y-coordinate column in the parquet file. @@ -143,7 +143,9 @@ def _assign_trx_to_entity_streaming_parquet( columns=[id_col, gene_col, "count"], ) return ( - df_long.pivot_table(index=id_col, columns=gene_col, values="count", fill_value=0, aggfunc="sum") + df_long.pivot_table( + index=id_col, columns=gene_col, values="count", fill_value=0, aggfunc="sum" + ) .rename_axis(None, axis=1) .astype(int) ) diff --git a/src/celldega/nbhd/utils.py b/src/celldega/nbhd/utils.py index 66a2a3cd..baacc5ec 100644 --- a/src/celldega/nbhd/utils.py +++ b/src/celldega/nbhd/utils.py @@ -5,10 +5,11 @@ from typing import Any # Third-party imports +from anndata import AnnData import geopandas as gpd import numpy as np import pandas as pd -from shapely.geometry import Point, base +from shapely.geometry import Point, Polygon, base from shapely.ops import transform @@ -147,3 +148,72 @@ def round_coords( return (round(x, precision), round(y, precision)) return transform(round_coords, geometry) + + +def gdf_from_contour_coords( + df_contours: pd.DataFrame, + id_col: str = "cell_id", + x_col: str = "vertex_x", + y_col: str = "vertex_y", +) -> gpd.GeoDataFrame: + """ + Build a polygon GeoDataFrame from a long-format vertex-coordinate table. + + Each row of `df_contours` is one polygon vertex, in order; rows sharing the + same `id_col` value become one polygon -- the shape produced by exporting a + segmentation mask's contours to CSV (e.g. a `*_nuclei_contour_coords.csv` / + `*_cell_contour_coords.csv` pair, one row per `(id_col, x_col, y_col)` + vertex). A group that fails to form a valid polygon (e.g. fewer than 3 + vertices) becomes an empty geometry rather than raising, so one malformed + entity doesn't break the whole batch. + + Any coordinate offsetting/rescaling (e.g. converting instrument microns to + a registered image's pixel space) should be applied to `df_contours[x_col]`/ + `df_contours[y_col]` before calling this function. + + Parameters + ---------- + df_contours : pd.DataFrame + Long-format vertex table with `id_col`, `x_col`, `y_col` columns. + id_col : str, default "cell_id" + Column identifying which polygon each vertex belongs to. + x_col, y_col : str, default "vertex_x", "vertex_y" + Vertex coordinate columns. + + Returns + ------- + gpd.GeoDataFrame + One row per id, with `id_col`, `geometry`, `center_x`, `center_y` + columns -- ready to pass to `NeighborhoodCollection(gdf=..., nbhd_col=id_col)` + or as the `gdf_source`/`gdf_bounds` of `calc_expansion`. + """ + + def _safe_polygon(row: pd.Series) -> Polygon: + try: + return Polygon(zip(row[x_col], row[y_col], strict=True)) + except Exception: + return Polygon() + + grouped = df_contours.groupby(id_col).agg(list) + gdf = gpd.GeoDataFrame( + {id_col: grouped.index}, + geometry=grouped.apply(_safe_polygon, axis=1).to_numpy(), + ).reset_index(drop=True) + gdf["center_x"] = gdf.centroid.x + gdf["center_y"] = gdf.centroid.y + return gdf + + +def df_to_anndata(df: pd.DataFrame) -> AnnData: + """ + Wrap a matrix DataFrame as a plain AnnData: `obs` = `df.index`, `var` = + `df.columns`, `X` = `df.values`. No normalization, filtering, or clustering + is computed -- just the container, e.g. for an entity-by-gene count table + (obs = neighborhoods/nuclei, var = genes) so you can run your own scanpy + pipeline from there. + """ + return AnnData( + X=df.values, + obs=pd.DataFrame(index=df.index), + var=pd.DataFrame(index=df.columns), + ) diff --git a/tests/unit/test_nbhd/test_radial_expansion.py b/tests/unit/test_nbhd/test_expansion.py similarity index 85% rename from tests/unit/test_nbhd/test_radial_expansion.py rename to tests/unit/test_nbhd/test_expansion.py index dc887fef..443e94f5 100644 --- a/tests/unit/test_nbhd/test_radial_expansion.py +++ b/tests/unit/test_nbhd/test_expansion.py @@ -5,7 +5,7 @@ from shapely.geometry import Point, Polygon from celldega.nbhd import NeighborhoodCollection -from celldega.nbhd.radial_expansion import _calc_radial_expansion +from celldega.nbhd.expansion import _calc_expansion def _synthetic_nucleus_cell_inputs(): @@ -32,10 +32,10 @@ def _synthetic_nucleus_cell_inputs(): return gdf_nuclei, gdf_cells -def test_calc_radial_expansion_grows_and_clips_to_bound(): +def test_calc_expansion_grows_and_clips_to_bound(): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() - series = _calc_radial_expansion(gdf_nuclei, gdf_cells, radii_um=[0, 1, 5], id_col="cell_id") + series = _calc_expansion(gdf_nuclei, gdf_cells, radii_um=[0, 1, 5], id_col="cell_id") assert list(series.keys()) == [0.0, 1.0, 5.0] @@ -53,12 +53,12 @@ def test_calc_radial_expansion_grows_and_clips_to_bound(): np.testing.assert_allclose(sorted(gdf_5["area_um2"]), [100.0, 100.0]) -def test_calc_radial_expansion_pixels_per_micron_matches_scale_um_per_pixel(): +def test_calc_expansion_pixels_per_micron_matches_scale_um_per_pixel(): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() high_res_scale = 2.0 # pixels per micron, e.g. a notebook's own scale variable scaling_factor = 1.0 / high_res_scale # microns per pixel - via_pixels_per_micron = _calc_radial_expansion( + via_pixels_per_micron = _calc_expansion( gdf_nuclei, gdf_cells, radii_um=[1], @@ -66,7 +66,7 @@ def test_calc_radial_expansion_pixels_per_micron_matches_scale_um_per_pixel(): is_pixel_space=True, pixels_per_micron=high_res_scale, ) - via_scale_um_per_pixel = _calc_radial_expansion( + via_scale_um_per_pixel = _calc_expansion( gdf_nuclei, gdf_cells, radii_um=[1], @@ -88,10 +88,10 @@ def test_calc_radial_expansion_pixels_per_micron_matches_scale_um_per_pixel(): np.testing.assert_allclose(sorted(gdf_1["area_um2"]), [9.0, 9.0]) -def test_calc_radial_expansion_scale_um_per_pixel_takes_precedence(): +def test_calc_expansion_scale_um_per_pixel_takes_precedence(): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() - result = _calc_radial_expansion( + result = _calc_expansion( gdf_nuclei, gdf_cells, radii_um=[1], @@ -103,27 +103,27 @@ def test_calc_radial_expansion_scale_um_per_pixel_takes_precedence(): np.testing.assert_allclose(sorted(result[1.0]["area_px2"]), [36.0, 36.0]) -def test_calc_radial_expansion_raises_when_pixel_space_scale_missing(): +def test_calc_expansion_raises_when_pixel_space_scale_missing(): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() with pytest.raises(ValueError, match="scale_um_per_pixel, pixels_per_micron, or technology"): - _calc_radial_expansion( + _calc_expansion( gdf_nuclei, gdf_cells, radii_um=[1], id_col="cell_id", is_pixel_space=True ) -def test_neighborhood_collection_calc_radial_expansion_accepts_pixels_per_micron(): +def test_neighborhood_collection_calc_expansion_accepts_pixels_per_micron(): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") - series = nbhd_nuclei.calc_radial_expansion( + series = nbhd_nuclei.calc_expansion( gdf_cells, radii_um=[1], is_pixel_space=True, pixels_per_micron=2.0 ) np.testing.assert_allclose(sorted(series[1.0].gdf["area_px2"]), [36.0, 36.0]) -def test_calc_radial_expansion_works_for_non_nucleus_entities(): +def test_calc_expansion_works_for_non_nucleus_entities(): # Demonstrates this isn't nucleus/cell-specific: any pair of per-entity # source/bound geometries with a shared id column works, e.g. a small "core" # region expanding into a larger parent "zone". @@ -146,7 +146,7 @@ def test_calc_radial_expansion_works_for_non_nucleus_entities(): } ) - series = _calc_radial_expansion(gdf_core, gdf_zone, radii_um=[0, 10], id_col="region_id") + series = _calc_expansion(gdf_core, gdf_zone, radii_um=[0, 10], id_col="region_id") assert list(series.keys()) == [0.0, 10.0] assert set(series[0.0]["region_id"]) == {"r1", "r2"} @@ -154,56 +154,58 @@ def test_calc_radial_expansion_works_for_non_nucleus_entities(): np.testing.assert_allclose(sorted(series[10.0]["area_um2"]), [25.0, 25.0]) -def test_calc_radial_expansion_add_colors(): +def test_calc_expansion_add_colors(): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() - with_colors = _calc_radial_expansion(gdf_nuclei, gdf_cells, radii_um=[0, 1, 2], id_col="cell_id") + with_colors = _calc_expansion( + gdf_nuclei, gdf_cells, radii_um=[0, 1, 2], id_col="cell_id" + ) assert all("color" in gdf.columns for gdf in with_colors.values()) # one shade per radius, shared across entities within that radius assert with_colors[0.0]["color"].nunique() == 1 assert len({gdf["color"].iloc[0] for gdf in with_colors.values()}) == 3 - without_colors = _calc_radial_expansion( + without_colors = _calc_expansion( gdf_nuclei, gdf_cells, radii_um=[0, 1], id_col="cell_id", add_colors=False ) assert all("color" not in gdf.columns for gdf in without_colors.values()) -def test_calc_radial_expansion_raises_on_duplicate_ids(): +def test_calc_expansion_raises_on_duplicate_ids(): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() gdf_cells_dup = pd.concat([gdf_cells, gdf_cells.iloc[[0]]], ignore_index=True) gdf_cells_dup = gpd.GeoDataFrame(gdf_cells_dup, geometry="geometry") with pytest.raises(ValueError, match="duplicate"): - _calc_radial_expansion(gdf_nuclei, gdf_cells_dup, radii_um=[0, 1], id_col="cell_id") + _calc_expansion(gdf_nuclei, gdf_cells_dup, radii_um=[0, 1], id_col="cell_id") -def test_calc_radial_expansion_raises_on_missing_bound_match(): +def test_calc_expansion_raises_on_missing_bound_match(): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() gdf_cells_missing = gdf_cells.iloc[[0]].reset_index(drop=True) with pytest.raises(ValueError, match="no matching row"): - _calc_radial_expansion(gdf_nuclei, gdf_cells_missing, radii_um=[0, 1], id_col="cell_id") + _calc_expansion(gdf_nuclei, gdf_cells_missing, radii_um=[0, 1], id_col="cell_id") -def test_neighborhood_collection_calc_radial_expansion_returns_series(): +def test_neighborhood_collection_calc_expansion_returns_series(): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") - series = nbhd_nuclei.calc_radial_expansion(gdf_cells, radii_um=[0, 1, 5]) + series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[0, 1, 5]) assert list(series.keys()) == [0.0, 1.0, 5.0] for nbhd in series.values(): assert isinstance(nbhd, NeighborhoodCollection) assert nbhd.nbhd_col == "cell_id" assert set(nbhd.obs.index) == {"c1", "c2"} - assert nbhd.nbhd_type == "radial_expansion" + assert nbhd.nbhd_type == "expansion" def test_calc_signature_cell_free_accepts_custom_gdf_trx(): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") - series = nbhd_nuclei.calc_radial_expansion(gdf_cells, radii_um=[0, 5]) + series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[0, 5]) # Custom transcript format: "name" for gene, arbitrary x/y columns already # converted to points -- exercises the feature_col override end to end. @@ -242,7 +244,7 @@ def test_calc_signature_cell_free_requires_data_dir_or_gdf_trx(): def test_calc_signature_cell_free_streams_from_parquet_across_radii(tmp_path): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") - series = nbhd_nuclei.calc_radial_expansion(gdf_cells, radii_um=[0, 5]) + series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[0, 5]) trx_path = tmp_path / "transcripts.parquet" pd.DataFrame( @@ -287,7 +289,7 @@ def test_calc_signature_cell_free_streams_from_parquet_across_radii(tmp_path): def test_calc_transcript_assignment_streaming_mode_computes_totals(tmp_path): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") - series = nbhd_nuclei.calc_radial_expansion(gdf_cells, radii_um=[5]) + series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[5]) trx_path = tmp_path / "transcripts.parquet" pd.DataFrame( diff --git a/tests/unit/test_nbhd/test_trx_streaming.py b/tests/unit/test_nbhd/test_trx_streaming.py index a5dd1549..202dbf73 100644 --- a/tests/unit/test_nbhd/test_trx_streaming.py +++ b/tests/unit/test_nbhd/test_trx_streaming.py @@ -61,9 +61,7 @@ def test_streaming_assignment_batches_across_multiple_reads(tmp_path): def test_streaming_assignment_custom_column_names(tmp_path): gdf_entity = _synthetic_entities() path = tmp_path / "custom_trx.parquet" - pd.DataFrame( - {"xx": [1, 2], "yy": [1, 2], "name": ["GeneA", "GeneA"]} - ).to_parquet(path) + pd.DataFrame({"xx": [1, 2], "yy": [1, 2], "name": ["GeneA", "GeneA"]}).to_parquet(path) counts = _assign_trx_to_entity_streaming_parquet( str(path), gdf_entity, id_col="cell_id", x_col="xx", y_col="yy", gene_col="name" diff --git a/tests/unit/test_nbhd/test_utils.py b/tests/unit/test_nbhd/test_utils.py new file mode 100644 index 00000000..4be99723 --- /dev/null +++ b/tests/unit/test_nbhd/test_utils.py @@ -0,0 +1,67 @@ +import pandas as pd +import pytest + +from celldega.nbhd import df_to_anndata, gdf_from_contour_coords + + +def test_gdf_from_contour_coords_builds_polygons(): + df_contours = pd.DataFrame( + { + "cell_id": [1, 1, 1, 1, 2, 2, 2], + "vertex_x": [0, 10, 10, 0, 20, 30, 25], + "vertex_y": [0, 0, 10, 10, 0, 0, 10], + } + ) + + gdf = gdf_from_contour_coords(df_contours) + + assert list(gdf["cell_id"]) == [1, 2] + assert list(gdf.geometry.area) == [100.0, 50.0] + assert {"center_x", "center_y"}.issubset(gdf.columns) + + +def test_gdf_from_contour_coords_custom_columns(): + df_contours = pd.DataFrame( + { + "id": ["a", "a", "a"], + "x": [0, 4, 2], + "y": [0, 0, 4], + } + ) + + gdf = gdf_from_contour_coords(df_contours, id_col="id", x_col="x", y_col="y") + + assert list(gdf["id"]) == ["a"] + assert gdf.geometry.iloc[0].area == pytest.approx(8.0) + + +def test_gdf_from_contour_coords_malformed_group_becomes_empty_geometry(): + # a group with only 2 vertices can't form a polygon + df_contours = pd.DataFrame( + { + "cell_id": [1, 1, 2, 2, 2], + "vertex_x": [0, 1, 0, 4, 2], + "vertex_y": [0, 1, 0, 0, 4], + } + ) + + gdf = gdf_from_contour_coords(df_contours) + + assert gdf.set_index("cell_id").loc[1, "geometry"].is_empty + assert not gdf.set_index("cell_id").loc[2, "geometry"].is_empty + + +def test_df_to_anndata_wraps_matrix_without_extra_computation(): + df = pd.DataFrame( + [[1, 2], [3, 4]], + index=["nbhd_1", "nbhd_2"], + columns=["GeneA", "GeneB"], + ) + + adata = df_to_anndata(df) + + assert list(adata.obs_names) == ["nbhd_1", "nbhd_2"] + assert list(adata.var_names) == ["GeneA", "GeneB"] + assert adata.X.tolist() == [[1, 2], [3, 4]] + assert "X_pca" not in adata.obsm + assert "neighbors" not in adata.uns From f031039fb16faf531db045a9dc2415f264d470fb Mon Sep 17 00:00:00 2001 From: Jaspreet Ishar Date: Thu, 16 Jul 2026 14:13:04 -0400 Subject: [PATCH 04/14] removed redundant methods; shortened docstrings --- .../Nuclear_Expansion_Radial_Buffering.ipynb | 453 +++++------------- src/celldega/nbhd/__init__.py | 10 +- src/celldega/nbhd/collection.py | 196 +++----- src/celldega/nbhd/expansion.py | 95 ++-- src/celldega/nbhd/neighborhoods.py | 91 +--- src/celldega/nbhd/trx_streaming.py | 54 +-- src/celldega/nbhd/utils.py | 98 ++-- tests/unit/test_nbhd/test_expansion.py | 59 +-- tests/unit/test_nbhd/test_utils.py | 65 +-- 9 files changed, 349 insertions(+), 772 deletions(-) diff --git a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb index b7a3d8d3..2c56225c 100644 --- a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb +++ b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb @@ -28,12 +28,10 @@ " custom `assign_trx_to_entity_streaming_parquet_optimized` + manual pivot. It\n", " spatially joins transcripts to each radius's polygons and returns a cell-by-gene\n", " `AnnData`, ready for the usual scanpy pipeline -- either from an in-memory\n", - " `GeoDataFrame` (`gdf_trx=`) or streamed straight from a parquet file\n", - " (`trx_parquet_path=`) for transcript files too large to hold in memory.\n", - "- **`celldega.nbhd.gdf_from_contour_coords`** builds a nucleus/cell\n", - " `GeoDataFrame` directly from a long-format vertex-coordinate table (the shape\n", - " of a `*_contour_coords.csv` export), replacing a hand-rolled `safe_polygon` +\n", - " `groupby(...).agg(list)` helper.\n", + " `GeoDataFrame` (`gdf_trx=`, custom column names) or from a Xenium-convention\n", + " `transcripts.parquet` directory (`data_dir=`), which is internally streamed in\n", + " batches so a whole-tile file doesn't need to be loaded into memory once per\n", + " radius.\n", "- **`celldega.nbhd.df_to_anndata`** wraps any entity-by-gene (or other matrix)\n", " DataFrame as a bare `AnnData`, with no normalization/PCA/clustering computed.\n", "\n", @@ -51,10 +49,10 @@ "id": "4d0f46b0", "metadata": { "execution": { - "iopub.execute_input": "2026-07-16T15:44:06.157731Z", - "iopub.status.busy": "2026-07-16T15:44:06.157551Z", - "iopub.status.idle": "2026-07-16T15:44:09.007106Z", - "shell.execute_reply": "2026-07-16T15:44:09.006463Z" + "iopub.execute_input": "2026-07-16T18:08:31.310410Z", + "iopub.status.busy": "2026-07-16T18:08:31.310247Z", + "iopub.status.idle": "2026-07-16T18:08:34.727938Z", + "shell.execute_reply": "2026-07-16T18:08:34.727361Z" } }, "outputs": [ @@ -104,10 +102,10 @@ "id": "5f2394c8", "metadata": { "execution": { - "iopub.execute_input": "2026-07-16T15:44:09.009393Z", - "iopub.status.busy": "2026-07-16T15:44:09.009012Z", - "iopub.status.idle": "2026-07-16T15:44:09.022451Z", - "shell.execute_reply": "2026-07-16T15:44:09.021953Z" + "iopub.execute_input": "2026-07-16T18:08:34.730310Z", + "iopub.status.busy": "2026-07-16T18:08:34.729854Z", + "iopub.status.idle": "2026-07-16T18:08:34.747066Z", + "shell.execute_reply": "2026-07-16T18:08:34.746617Z" } }, "outputs": [ @@ -163,103 +161,6 @@ "gdf_nuclei.shape, gdf_cells.shape" ] }, - { - "cell_type": "markdown", - "id": "bc61b60a", - "metadata": {}, - "source": [ - "### Building from segmentation contour CSVs\n", - "\n", - "The synthetic `gdf_nuclei`/`gdf_cells` above were built directly with Shapely.\n", - "A real pipeline more often exports segmentation contours to CSV instead -- one\n", - "row per polygon vertex, grouped by a cell id (e.g. a `*_nuclei_contour_coords.csv`\n", - "/ `*_cell_contour_coords.csv` pair). `celldega.nbhd.gdf_from_contour_coords`\n", - "builds a `GeoDataFrame` directly from that long format, so you don't need to\n", - "hand-roll a `safe_polygon` + `groupby(...).agg(list)` helper yourself. Any\n", - "coordinate offsetting/rescaling (e.g. registering instrument microns into an\n", - "image's pixel space) should happen on the vertex columns before calling it." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "faac734e", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-16T15:44:09.024123Z", - "iopub.status.busy": "2026-07-16T15:44:09.024015Z", - "iopub.status.idle": "2026-07-16T15:44:09.034334Z", - "shell.execute_reply": "2026-07-16T15:44:09.033837Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
cell_idgeometrycenter_xcenter_y
00POLYGON ((4.33166 1.62735, 4.31013 1.29888, 4....1.8151361.627354
\n", - "
" - ], - "text/plain": [ - " cell_id geometry center_x \\\n", - "0 0 POLYGON ((4.33166 1.62735, 4.31013 1.29888, 4.... 1.815136 \n", - "\n", - " center_y \n", - "0 1.627354 " - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# a toy long-format contour table, matching a *_nuclei_contour_coords.csv shape --\n", - "# reuses one nucleus'''s own vertices, just to show the round trip\n", - "example_geom = gdf_nuclei.geometry.iloc[0]\n", - "vx, vy = zip(*example_geom.exterior.coords)\n", - "df_contours_demo = pd.DataFrame({\n", - " \"cell_id\": [gdf_nuclei[\"cell_id\"].iloc[0]] * len(vx),\n", - " \"vertex_x\": vx,\n", - " \"vertex_y\": vy,\n", - "})\n", - "\n", - "gdf_from_csv_demo = dega.nbhd.gdf_from_contour_coords(df_contours_demo)\n", - "gdf_from_csv_demo" - ] - }, { "cell_type": "markdown", "id": "69869e12", @@ -272,14 +173,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "85a6f217", "metadata": { "execution": { - "iopub.execute_input": "2026-07-16T15:44:09.036322Z", - "iopub.status.busy": "2026-07-16T15:44:09.036157Z", - "iopub.status.idle": "2026-07-16T15:44:09.047309Z", - "shell.execute_reply": "2026-07-16T15:44:09.046772Z" + "iopub.execute_input": "2026-07-16T18:08:34.748526Z", + "iopub.status.busy": "2026-07-16T18:08:34.748398Z", + "iopub.status.idle": "2026-07-16T18:08:34.763023Z", + "shell.execute_reply": "2026-07-16T18:08:34.762511Z" } }, "outputs": [ @@ -346,7 +247,7 @@ "4 37.955601" ] }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -373,14 +274,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "658414fd", "metadata": { "execution": { - "iopub.execute_input": "2026-07-16T15:44:09.048949Z", - "iopub.status.busy": "2026-07-16T15:44:09.048830Z", - "iopub.status.idle": "2026-07-16T15:44:09.136141Z", - "shell.execute_reply": "2026-07-16T15:44:09.135405Z" + "iopub.execute_input": "2026-07-16T18:08:34.764600Z", + "iopub.status.busy": "2026-07-16T18:08:34.764486Z", + "iopub.status.idle": "2026-07-16T18:08:34.862039Z", + "shell.execute_reply": "2026-07-16T18:08:34.861190Z" } }, "outputs": [ @@ -408,14 +309,14 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "140c06c5", "metadata": { "execution": { - "iopub.execute_input": "2026-07-16T15:44:09.137851Z", - "iopub.status.busy": "2026-07-16T15:44:09.137709Z", - "iopub.status.idle": "2026-07-16T15:44:09.904417Z", - "shell.execute_reply": "2026-07-16T15:44:09.903657Z" + "iopub.execute_input": "2026-07-16T18:08:34.864034Z", + "iopub.status.busy": "2026-07-16T18:08:34.863897Z", + "iopub.status.idle": "2026-07-16T18:08:35.700858Z", + "shell.execute_reply": "2026-07-16T18:08:35.700146Z" } }, "outputs": [], @@ -461,14 +362,14 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "2f1d3bf5", "metadata": { "execution": { - "iopub.execute_input": "2026-07-16T15:44:09.906523Z", - "iopub.status.busy": "2026-07-16T15:44:09.906380Z", - "iopub.status.idle": "2026-07-16T15:44:10.007031Z", - "shell.execute_reply": "2026-07-16T15:44:10.006451Z" + "iopub.execute_input": "2026-07-16T18:08:35.702856Z", + "iopub.status.busy": "2026-07-16T18:08:35.702739Z", + "iopub.status.idle": "2026-07-16T18:08:35.811831Z", + "shell.execute_reply": "2026-07-16T18:08:35.811207Z" } }, "outputs": [ @@ -519,23 +420,19 @@ "gene_col=\"name\")` call. Two gene pairs simulate real biology: `NucGene*`\n", "transcripts cluster tightly at the nucleus center (captured at every radius), while\n", "`CytoGene*` and a cell-type marker gene (`MarkerA`/`MarkerB`) scatter through the\n", - "cytoplasm and are only picked up as the buffer radius grows.\n", - "\n", - "We also write these to an actual `transcripts.parquet` file, so the streaming\n", - "API below reads from disk exactly like it would on a real, whole-tile transcript\n", - "file." + "cytoplasm and are only picked up as the buffer radius grows." ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "09ef320b", "metadata": { "execution": { - "iopub.execute_input": "2026-07-16T15:44:10.008694Z", - "iopub.status.busy": "2026-07-16T15:44:10.008575Z", - "iopub.status.idle": "2026-07-16T15:44:10.109064Z", - "shell.execute_reply": "2026-07-16T15:44:10.108613Z" + "iopub.execute_input": "2026-07-16T18:08:35.813813Z", + "iopub.status.busy": "2026-07-16T18:08:35.813683Z", + "iopub.status.idle": "2026-07-16T18:08:35.865917Z", + "shell.execute_reply": "2026-07-16T18:08:35.865257Z" } }, "outputs": [ @@ -551,7 +448,7 @@ " 'MarkerB': 625})" ] }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -586,12 +483,6 @@ "\n", "df_trx = pd.DataFrame(trx_rows)\n", "gdf_trx = gpd.GeoDataFrame(df_trx[[\"name\"]], geometry=gpd.points_from_xy(df_trx[\"x\"], df_trx[\"y\"]))\n", - "\n", - "# persist to a real parquet file, so the streaming API (below) reads from disk\n", - "# the same way it would for a real, whole-tile transcripts.parquet\n", - "trx_parquet_path = os.path.join(tempfile.mkdtemp(), \"transcripts.parquet\")\n", - "df_trx.to_parquet(trx_parquet_path)\n", - "\n", "gdf_trx.shape, gdf_trx[\"name\"].value_counts().to_dict()" ] }, @@ -605,32 +496,28 @@ "`calc_signature(by=\"cell-free\", ...)` spatially joins transcripts to each\n", "radius's polygons and returns transcript counts as an `AnnData` in\n", "`nbhd.mod[\"gene_cell_free\"]` -- one call per radius, no custom pivot code\n", - "needed. It supports the same transcript source in two ways:\n", - "\n", - "- **In-memory** (`gdf_trx=...`): loads the whole transcript table into memory as\n", - " points and does a single spatial join. Simple, and fine when the transcripts\n", - " already fit comfortably in memory (or you've pre-filtered them yourself).\n", - "- **Streaming** (`trx_parquet_path=...`): reads the parquet file in batches via\n", - " `pyarrow`, narrowing candidate entities per batch with a spatial index before\n", - " testing exact polygons -- the same mechanics as the original notebook's\n", - " `assign_trx_to_entity_streaming_parquet_optimized`. Use this for a real,\n", - " whole-tile `transcripts.parquet` (tens of millions of rows) that you don't want\n", - " to load into memory seven times over (once per radius).\n", - "\n", - "Both produce identical counts -- the cell below runs the streaming path (as you\n", - "would on real data) and spot-checks it against the in-memory path for one radius." + "needed. It accepts the same transcript source in two ways:\n", + "\n", + "- **`gdf_trx=`**: an in-memory `GeoDataFrame` of transcript points with a\n", + " `feature_col` gene column of your choosing -- what this notebook's synthetic,\n", + " custom-column (`x`/`y`/`name`) transcripts use below.\n", + "- **`data_dir=`**: a directory with a Xenium-convention `transcripts.parquet`\n", + " (`feature_name`/`x_location`/`y_location`). This path is streamed in batches\n", + " internally (narrowing candidate entities per batch with a spatial index\n", + " before testing exact polygons), so a whole-tile file doesn't need to be\n", + " loaded into memory once per radius -- see the sanity-check cell below." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "10f40fda", "metadata": { "execution": { - "iopub.execute_input": "2026-07-16T15:44:10.111160Z", - "iopub.status.busy": "2026-07-16T15:44:10.110996Z", - "iopub.status.idle": "2026-07-16T15:44:10.322544Z", - "shell.execute_reply": "2026-07-16T15:44:10.322053Z" + "iopub.execute_input": "2026-07-16T18:08:35.867449Z", + "iopub.status.busy": "2026-07-16T18:08:35.867338Z", + "iopub.status.idle": "2026-07-16T18:08:35.968417Z", + "shell.execute_reply": "2026-07-16T18:08:35.967750Z" } }, "outputs": [ @@ -638,19 +525,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n", - "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n", - "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n", - "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n", - "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n", - "Calculating neighborhood-by-gene (cell-free, streaming parquet)\n" + "Calculating neighborhood-by-gene (cell-free, provided gdf_trx)\n", + "Calculating neighborhood-by-gene (cell-free, provided gdf_trx)\n", + "Calculating neighborhood-by-gene (cell-free, provided gdf_trx)\n", + "Calculating neighborhood-by-gene (cell-free, provided gdf_trx)\n", + "Calculating neighborhood-by-gene (cell-free, provided gdf_trx)\n", + "Calculating neighborhood-by-gene (cell-free, provided gdf_trx)\n", + "Calculating neighborhood-by-gene (cell-free, provided gdf_trx)\n" ] }, { @@ -761,21 +642,14 @@ "3.0 610.0 571.0 291.0 284.0 984.0 837.0" ] }, - "execution_count": 9, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "for radius, nbhd in nbhd_series.items():\n", - " nbhd.calc_signature(\n", - " by=\"cell-free\",\n", - " trx_parquet_path=trx_parquet_path,\n", - " x_col=\"x\",\n", - " y_col=\"y\",\n", - " feature_col=\"name\",\n", - " drop_missing=False,\n", - " )\n", + " nbhd.calc_signature(by=\"cell-free\", gdf_trx=gdf_trx, feature_col=\"name\", drop_missing=False)\n", "\n", "gene_totals = pd.DataFrame(\n", " {\n", @@ -806,14 +680,14 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "7ec22ce0", "metadata": { "execution": { - "iopub.execute_input": "2026-07-16T15:44:10.324334Z", - "iopub.status.busy": "2026-07-16T15:44:10.324212Z", - "iopub.status.idle": "2026-07-16T15:44:10.327415Z", - "shell.execute_reply": "2026-07-16T15:44:10.326767Z" + "iopub.execute_input": "2026-07-16T18:08:35.970449Z", + "iopub.status.busy": "2026-07-16T18:08:35.970224Z", + "iopub.status.idle": "2026-07-16T18:08:35.973951Z", + "shell.execute_reply": "2026-07-16T18:08:35.973388Z" } }, "outputs": [ @@ -823,7 +697,7 @@ "AnnData object with n_obs × n_vars = 120 × 6" ] }, - "execution_count": 10, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -843,22 +717,24 @@ "id": "081a93dd", "metadata": {}, "source": [ - "### Streaming vs. in-memory sanity check\n", + "### `data_dir=` sanity check\n", "\n", - "Confirms the streaming path above (`trx_parquet_path=`) and the in-memory path\n", - "(`gdf_trx=`) agree, using the radius=3um collection as a spot check." + "`data_dir=` expects a Xenium-convention `transcripts.parquet`\n", + "(`feature_name`/`x_location`/`y_location`) and is internally streamed in\n", + "batches rather than loaded fully into memory. Confirms it agrees with the\n", + "`gdf_trx=` path above, using the radius=3um collection as a spot check." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "id": "4a21421e", "metadata": { "execution": { - "iopub.execute_input": "2026-07-16T15:44:10.329020Z", - "iopub.status.busy": "2026-07-16T15:44:10.328894Z", - "iopub.status.idle": "2026-07-16T15:44:10.352373Z", - "shell.execute_reply": "2026-07-16T15:44:10.351661Z" + "iopub.execute_input": "2026-07-16T18:08:35.975475Z", + "iopub.status.busy": "2026-07-16T18:08:35.975370Z", + "iopub.status.idle": "2026-07-16T18:08:36.198945Z", + "shell.execute_reply": "2026-07-16T18:08:36.198389Z" } }, "outputs": [ @@ -866,8 +742,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "Calculating neighborhood-by-gene (cell-free, provided gdf_trx)\n", - "streaming and in-memory paths agree\n" + "Calculating neighborhood-by-gene (cell-free, streaming)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "gdf_trx and data_dir paths agree\n" ] }, { @@ -880,123 +762,28 @@ } ], "source": [ + "xenium_dir = tempfile.mkdtemp()\n", + "df_trx.rename(columns={\"name\": \"feature_name\", \"x\": \"x_location\", \"y\": \"y_location\"}).to_parquet(\n", + " f\"{xenium_dir}/transcripts.parquet\"\n", + ")\n", + "\n", "nbhd_check = nbhd_series[3.0]\n", "nbhd_check.calc_signature(\n", - " by=\"cell-free\", gdf_trx=gdf_trx, feature_col=\"name\",\n", - " modality_name=\"gene_cell_free_in_memory\", drop_missing=False,\n", + " by=\"cell-free\", data_dir=xenium_dir,\n", + " modality_name=\"gene_cell_free_via_data_dir\", drop_missing=False,\n", ")\n", "\n", - "streamed = pd.DataFrame(\n", + "in_memory = pd.DataFrame(\n", " nbhd_check.mod[\"gene_cell_free\"].X, columns=nbhd_check.mod[\"gene_cell_free\"].var_names,\n", " index=nbhd_check.mod[\"gene_cell_free\"].obs_names,\n", ")\n", - "in_memory = pd.DataFrame(\n", - " nbhd_check.mod[\"gene_cell_free_in_memory\"].X,\n", - " columns=nbhd_check.mod[\"gene_cell_free_in_memory\"].var_names,\n", - " index=nbhd_check.mod[\"gene_cell_free_in_memory\"].obs_names,\n", + "via_data_dir = pd.DataFrame(\n", + " nbhd_check.mod[\"gene_cell_free_via_data_dir\"].X,\n", + " columns=nbhd_check.mod[\"gene_cell_free_via_data_dir\"].var_names,\n", + " index=nbhd_check.mod[\"gene_cell_free_via_data_dir\"].obs_names,\n", ")\n", - "assert streamed.equals(in_memory[streamed.columns])\n", - "print(\"streaming and in-memory paths agree\")" - ] - }, - { - "cell_type": "markdown", - "id": "80360cd9", - "metadata": {}, - "source": [ - "### Transcript totals via `calc_transcript_assignment`\n", - "\n", - "For just a per-entity transcript *total* (no gene breakdown), the same streaming\n", - "join backs `calc_transcript_assignment(trx_parquet_path=...)` -- e.g. as a quick\n", - "QC pass before committing to a full `calc_signature` call at every radius." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "8e9a96f8", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-16T15:44:10.354180Z", - "iopub.status.busy": "2026-07-16T15:44:10.354045Z", - "iopub.status.idle": "2026-07-16T15:44:10.374415Z", - "shell.execute_reply": "2026-07-16T15:44:10.373970Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
total_transcripts
neighborhood_id
033
129
223
337
434
\n", - "
" - ], - "text/plain": [ - " total_transcripts\n", - "neighborhood_id \n", - "0 33\n", - "1 29\n", - "2 23\n", - "3 37\n", - "4 34" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "nbhd_series[3.0].calc_transcript_assignment(\n", - " trx_parquet_path=trx_parquet_path, x_col=\"x\", y_col=\"y\", gene_col=\"name\"\n", - ")\n", - "nbhd_series[3.0].obs[[\"total_transcripts\"]].head()" + "assert in_memory.equals(via_data_dir[in_memory.columns])\n", + "print(\"gdf_trx and data_dir paths agree\")" ] }, { @@ -1015,14 +802,14 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "id": "f4ec2540", "metadata": { "execution": { - "iopub.execute_input": "2026-07-16T15:44:10.376329Z", - "iopub.status.busy": "2026-07-16T15:44:10.376208Z", - "iopub.status.idle": "2026-07-16T15:44:20.125826Z", - "shell.execute_reply": "2026-07-16T15:44:20.125025Z" + "iopub.execute_input": "2026-07-16T18:08:36.200443Z", + "iopub.status.busy": "2026-07-16T18:08:36.200330Z", + "iopub.status.idle": "2026-07-16T18:08:46.010818Z", + "shell.execute_reply": "2026-07-16T18:08:46.010098Z" } }, "outputs": [ @@ -1080,14 +867,14 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "id": "1a864fad", "metadata": { "execution": { - "iopub.execute_input": "2026-07-16T15:44:20.128192Z", - "iopub.status.busy": "2026-07-16T15:44:20.128045Z", - "iopub.status.idle": "2026-07-16T15:44:20.176612Z", - "shell.execute_reply": "2026-07-16T15:44:20.175735Z" + "iopub.execute_input": "2026-07-16T18:08:46.013475Z", + "iopub.status.busy": "2026-07-16T18:08:46.013325Z", + "iopub.status.idle": "2026-07-16T18:08:46.063822Z", + "shell.execute_reply": "2026-07-16T18:08:46.063115Z" } }, "outputs": [], @@ -1119,21 +906,19 @@ "\n", "| Original notebook | This notebook / Celldega API |\n", "| --- | --- |\n", - "| `safe_polygon` + `groupby(\"cell_id\").agg(list)` parsing `..._nuclei_contour_coords.csv` | `dega.nbhd.gdf_from_contour_coords(df_contours, id_col=\"cell_id\", x_col=\"vertex_x\", y_col=\"vertex_y\")` |\n", "| `gdf_nuclei_original` (parsed from `..._nuclei_contour_coords.csv`) | `gdf_nuclei` -> `NeighborhoodCollection(gdf=gdf_nuclei, nbhd_col=\"cell_id\")` |\n", "| `gdf_cells` / `gdf_cells2` (parsed from `..._Expanded_5um_cell_contour_coords.csv`) | `gdf_cells` passed to `calc_expansion` |\n", "| `expand_nuclei_within_cell(nuclei_gdf, expand_um)` loop building `nuclei_gdfs = {\"original\": ..., \"expanded_0_5um\": ..., ...}` | `nbhd_series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[0, 0.5, 1, 1.5, 2, 2.5, 3])` |\n", - "| `assign_trx_to_entity_streaming_parquet_optimized(trx_parquet_path, entity_gdf, x_col=\"x\", y_col=\"y\", gene_col=\"name\", batch_size=1_000_000)` + manual `pivot_table` per radius | `nbhd.calc_signature(by=\"cell-free\", trx_parquet_path=trx_parquet_path, x_col=\"x\", y_col=\"y\", feature_col=\"name\", batch_size=1_000_000)` per radius -- same batched-parquet-plus-spatial-index mechanics, now built in |\n", - "| `assignments_out=...` (per-transcript assignment parquet) | not written by `calc_signature` (it only needs the resulting counts); if you need per-transcript assignments too, keep using your own writer alongside it |\n", - "| Just the transcript *total* per entity, no gene breakdown | `nbhd.calc_transcript_assignment(trx_parquet_path=trx_parquet_path, x_col=\"x\", y_col=\"y\", gene_col=\"name\")` -> adds a `total_transcripts` column to `nbhd.obs` via the same streaming join |\n", + "| `assign_trx_to_entity_streaming_parquet_optimized(trx_parquet_path, entity_gdf, x_col=\"x\", y_col=\"y\", gene_col=\"name\", batch_size=1_000_000)` + manual `pivot_table` per radius | `nbhd.calc_signature(by=\"cell-free\", gdf_trx=gdf_trx, feature_col=\"name\")` per radius (or `data_dir=` for a Xenium-convention file, streamed internally) |\n", "| Per-radius `pd.read_parquet(..._nuclei_by_gene.parquet)` -> `AnnData` (e.g. `ad.AnnData(X=nbg)`) | `nbhd.mod[\"gene_cell_free\"]` (already an `AnnData`), or `dega.nbhd.df_to_anndata(your_own_df)` for a bare one with no Celldega bookkeeping |\n", "| Per-radius `adata.write(...h5ad)` | `nbhd.mod[\"gene_cell_free\"].write_h5ad(...)`, or persist the whole collection (geometry + all modalities) with `nbhd.write(\"radius.h5mu\")` |\n", + "| `safe_polygon`, `simple_format`, `transform_polygon`, `make_column_names_unique_fast` helper functions | available as `celldega.nbhd.safe_polygon` / `simple_format` / `transform_polygon` / `make_column_names_unique_fast`, unchanged -- not otherwise used in this notebook |\n", "\n", - "`calc_signature` also accepts `gdf_trx=` (an already-in-memory `GeoDataFrame` of\n", - "transcript points) for smaller or pre-filtered transcript sources -- see the\n", - "sanity-check cell above, which confirms both paths agree. Use `trx_parquet_path=`\n", - "whenever the transcripts don't comfortably fit in memory, especially since an\n", - "expansion series re-joins the same transcripts once per radius." + "`calc_signature`'s `gdf_trx=` path loads the whole transcript table into memory\n", + "for one spatial join -- fine once it's already loaded or pre-filtered. Its\n", + "`data_dir=` path (Xenium convention) is streamed in batches instead, so a\n", + "whole-tile `transcripts.parquet` re-joined once per radius across an expansion\n", + "series doesn't need to fit in memory -- see the sanity-check cell above." ] }, { diff --git a/src/celldega/nbhd/__init__.py b/src/celldega/nbhd/__init__.py index 229229d8..cf50c14c 100644 --- a/src/celldega/nbhd/__init__.py +++ b/src/celldega/nbhd/__init__.py @@ -11,7 +11,10 @@ _get_gdf_cell, _get_gdf_trx, df_to_anndata, - gdf_from_contour_coords, + make_column_names_unique_fast, + safe_polygon, + simple_format, + transform_polygon, ) @@ -26,7 +29,10 @@ "alpha_shape_cell_clusters", "df_to_anndata", "filter_alpha_shapes", - "gdf_from_contour_coords", "generate_hextile", "hextile_niche", + "make_column_names_unique_fast", + "safe_polygon", + "simple_format", + "transform_polygon", ] diff --git a/src/celldega/nbhd/collection.py b/src/celldega/nbhd/collection.py index e7690883..ac5d4cc0 100644 --- a/src/celldega/nbhd/collection.py +++ b/src/celldega/nbhd/collection.py @@ -331,61 +331,46 @@ def calc_expansion( ) -> dict[float, NeighborhoodCollection]: """Buffer every entity in this collection outward, clipped to its own bound. - Unlike :meth:`calc_gradient` — which grows concentric rings from ONE - dissolved region of interest — this grows **every** neighborhood in this - collection independently, using each one as its own tiny ROI, and clips - the result to a matching row in ``gdf_bounds`` (joined by - ``self.nbhd_col``). One new ``NeighborhoodCollection`` is returned per - radius, all sharing the same observation axis so ``calc_signature``/ - ``calc_population`` results stay directly comparable across radii. - - The canonical use case is a segmented nucleus growing outward until it - reaches its corresponding cell boundary, but ``gdf_bounds`` can be any - per-entity containing geometry (this collection's entities need not be - nuclei, and ``gdf_bounds`` need not be cells). + Unlike :meth:`calc_gradient` (concentric rings from ONE dissolved ROI), + this grows **every** neighborhood independently — e.g. a segmented + nucleus growing into its cell — clipping each to a matching row in + ``gdf_bounds`` (joined by ``self.nbhd_col``). Returns one new + ``NeighborhoodCollection`` per radius, sharing the same observation axis + so downstream results stay comparable across radii. Args: - gdf_bounds: Per-entity clipping boundary (e.g. a cell segmentation - polygon for each nucleus), with a column named ``self.nbhd_col`` - and a ``geometry`` column. Every buffered entity is intersected - with its matching row. - radii_um: Buffer distances in microns (default ``0`` through ``3`` in - ``0.5`` steps). ``0`` returns the original (validity-repaired) - entity geometry, clipped to its bound. - nbhd_type: Label recorded on each returned collection (default - ``"expansion"``). + gdf_bounds: Per-entity clipping boundary, with a column named + ``self.nbhd_col`` and a ``geometry`` column. + radii_um: Buffer distances in microns. ``0`` returns the original + (validity-repaired) entity geometry, clipped to its bound. + nbhd_type: Label recorded on each returned collection. technology: Imaging platform used to look up ``scale_um_per_pixel`` for pixel-space geometry (e.g. ``"Xenium"``). - scale_um_per_pixel: Microns per pixel (a micron distance is - *divided* by this to get pixels). Required (directly, via - ``technology``, or via ``pixels_per_micron``) when - ``is_pixel_space=True``; takes precedence over - ``pixels_per_micron`` if both are given. + scale_um_per_pixel: Microns per pixel (divide a micron distance by + this to get pixels). Required, directly or via ``technology``/ + ``pixels_per_micron``, when ``is_pixel_space=True``; takes + precedence over ``pixels_per_micron`` if both are given. pixels_per_micron: Pixels per micron — the reciprocal convention - (a micron distance is *multiplied* by this to get pixels, e.g. a - notebook's own ``buffer_dist = expand_um * high_res_scale``). - Equivalent to ``scale_um_per_pixel=1 / pixels_per_micron``. + (multiply a micron distance by this to get pixels, e.g. a + notebook's own ``high_res_scale``); equivalent to + ``scale_um_per_pixel=1 / pixels_per_micron``. is_pixel_space: ``True`` if this collection's geometry is in pixel units; ``False`` (default) if already in microns. join_style: Shapely buffer join style (``1``=round, ``2``=mitre (default), ``3``=bevel). mitre_limit: Shapely mitre limit, used when ``join_style=2``. add_colors: If ``True`` (default), add a ``color`` column — one - shade per radius (dark to light) — for visualization. - **kwargs: Forwarded to each new ``NeighborhoodCollection`` (e.g. - ``name``, ``data_dir``). + shade per radius — for visualization. + **kwargs: Forwarded to each new ``NeighborhoodCollection``. Returns: - A dict mapping each radius in ``radii_um`` (in microns) to a new - ``NeighborhoodCollection`` of that radius's buffered, clipped - geometries. + A dict mapping each radius to a new ``NeighborhoodCollection`` of + that radius's buffered, clipped geometries. Raises: - ValueError: If this collection has no geometry, if ids are not - unique or fail to match between this collection and - ``gdf_bounds``, or if ``is_pixel_space=True`` without a - resolvable scale (``scale_um_per_pixel``, ``pixels_per_micron``, - or ``technology``). + ValueError: If this collection has no geometry, if ids fail to + match ``gdf_bounds``, or if ``is_pixel_space=True`` without a + resolvable scale. Examples: >>> nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_col="cell_id") @@ -560,10 +545,6 @@ def calc_signature( data_dir: str | None = None, gdf_trx: gpd.GeoDataFrame | None = None, feature_col: str = "feature_name", - trx_parquet_path: str | None = None, - x_col: str = "x", - y_col: str = "y", - batch_size: int = 1_000_000, drop_missing: bool = True, ) -> None: """Calculate a neighborhood-by-gene modality and attach it to ``self.mod``. @@ -579,27 +560,13 @@ def calc_signature( modality_name: Key for the modality; defaults to ``"gene"`` (cell-derived) or ``"gene_cell_free"`` (transcript-derived). min_cells: Minimum cells/transcripts for a neighborhood to be kept. - data_dir: Transcript directory for ``by="cell-free"`` (Xenium - convention: `transcripts.parquet` with `feature_name`/ - `x_location`/`y_location` columns); defaults to ``self.data_dir``. - Used only when neither ``gdf_trx`` nor ``trx_parquet_path`` is - given. + data_dir: Directory with a Xenium-convention ``transcripts.parquet`` + (streamed in batches); defaults to ``self.data_dir``. Used for + ``by="cell-free"`` when ``gdf_trx`` isn't given. gdf_trx: Pre-loaded transcript points for ``by="cell-free"`` (custom - paths/column names); loads the whole frame into memory for one - spatial join. Takes precedence over ``trx_parquet_path`` and - ``data_dir``. - feature_col: Gene/feature column name (default ``"feature_name"``), - used with ``gdf_trx`` or as the gene column when streaming from - ``trx_parquet_path``. - trx_parquet_path: Transcripts parquet path to stream in batches - instead of loading into memory — for transcript files too large - for an in-memory join (e.g. a whole-tile file streamed once per - radius across a :meth:`calc_expansion` series). Takes precedence - over ``data_dir`` but not ``gdf_trx``. - x_col: Transcript x-coordinate column in ``trx_parquet_path``. - y_col: Transcript y-coordinate column in ``trx_parquet_path``. - batch_size: Rows read per streamed batch when using - ``trx_parquet_path``. + column names/paths); takes precedence over ``data_dir``. + feature_col: Gene/feature column in ``gdf_trx`` (default + ``"feature_name"``). drop_missing: When ``True`` (default), neighborhoods with fewer than ``min_cells`` cells (or transcripts) are removed from the collection entirely. When ``False``, the collection keeps all @@ -610,9 +577,8 @@ def calc_signature( ``None`` — the modality is attached to ``self.mod``. Raises: - ValueError: If ``adata`` is missing for ``by="cell"``, or none of - ``data_dir``, ``gdf_trx``, or ``trx_parquet_path`` is given for - ``by="cell-free"``. + ValueError: If ``adata`` is missing for ``by="cell"``, or neither + ``data_dir`` nor ``gdf_trx`` is given for ``by="cell-free"``. """ from celldega.nbhd.neighborhoods import ( _calc_nbhd_by_gene, @@ -625,15 +591,8 @@ def calc_signature( resolved_data_dir = data_dir if data_dir is not None else self.data_dir if by == "cell" and adata is None: raise ValueError("adata is required when by='cell'") - if ( - by == "cell-free" - and gdf_trx is None - and trx_parquet_path is None - and resolved_data_dir is None - ): - raise ValueError( - "data_dir, gdf_trx, or trx_parquet_path is required when by='cell-free'" - ) + if by == "cell-free" and gdf_trx is None and resolved_data_dir is None: + raise ValueError("data_dir or gdf_trx is required when by='cell-free'") modality = _calc_nbhd_by_gene( self.gdf, @@ -642,10 +601,6 @@ def calc_signature( data_dir=resolved_data_dir, gdf_trx=gdf_trx, feature_col=feature_col, - trx_parquet_path=trx_parquet_path, - x_col=x_col, - y_col=y_col, - batch_size=batch_size, nbhd_col=self.nbhd_col, min_cells=min_cells, ) @@ -736,84 +691,47 @@ def calc_bordering( def calc_transcript_assignment( self, data_dir: str | None = None, - *, - trx_parquet_path: str | None = None, - x_col: str = "x", - y_col: str = "y", - gene_col: str = "gene", - batch_size: int = 1_000_000, ) -> None: - """Add per-neighborhood transcript-count columns to ``obs``. + """Add per-neighborhood transcript-assignment columns to ``obs``. + + From ``transcripts.parquet`` in ``data_dir``, adds three ``obs`` columns + (on the underlying MuData) for each neighborhood: - Default (audit) mode reads a Xenium-convention ``transcripts.parquet`` - that already carries a per-transcript ``cell_id`` column (unassigned - transcripts marked ``"UNASSIGNED"``) and adds ``total_transcripts``, - ``unassigned_transcripts``, and ``transcript_assignment_proportion`` — - assignment isn't computed here, just audited. + - ``total_transcripts`` — transcripts falling inside the neighborhood. + - ``unassigned_transcripts`` — those with ``cell_id == "UNASSIGNED"``. + - ``transcript_assignment_proportion`` — assigned / total (``0.0`` when + the neighborhood has no transcripts). - Pass ``trx_parquet_path`` instead to compute ``total_transcripts`` from - geometry via the same streaming, spatial-index-accelerated join as - ``calc_signature(trx_parquet_path=...)``, for transcripts with no - pre-existing ``cell_id`` (e.g. a custom pipeline's own ``x``/``y``/gene - file). Only ``total_transcripts`` is added in this mode; use - ``calc_signature`` for a full gene expression matrix. + Assumption: the transcript-to-cell assignment is **not computed here** — + it must already be present in the instrument data, with unassigned + transcripts marked by the ``"UNASSIGNED"`` sentinel (Xenium convention). + Only transcripts are needed — no ``adata`` or cell polygons. Args: - data_dir: Directory with a Xenium-convention ``transcripts.parquet`` - (audit mode); defaults to ``self.data_dir``. Ignored when - ``trx_parquet_path`` is given. - trx_parquet_path: Transcripts parquet path to stream for - geometry-based counting instead of audit mode. - x_col: Transcript x-coordinate column (streaming mode only). - y_col: Transcript y-coordinate column (streaming mode only). - gene_col: Transcript gene column (streaming mode only) — only used - to batch the join; the per-gene breakdown is discarded. - batch_size: Rows read per streamed batch (streaming mode only). + data_dir: Directory containing ``transcripts.parquet``; defaults to + ``self.data_dir``. Returns: - ``None`` — the columns are added to ``self.obs``. + ``None`` — the three columns are added to ``self.obs``. Raises: - ValueError: If geometry is missing, transcripts lack ``cell_id`` in - audit mode, or neither transcript source is given. Audit mode - only warns if the ``"UNASSIGNED"`` sentinel is entirely absent. + ValueError: If geometry or a usable ``data_dir`` is missing, or the + transcripts lack a ``cell_id`` column. A complete absence of the + ``"UNASSIGNED"`` sentinel only warns. """ - if self.gdf is None: - raise ValueError("gdf or geometry is required to calculate transcript assignment") - - obs = self.obs.copy() - - if trx_parquet_path is not None: - from celldega.nbhd.trx_streaming import _assign_trx_to_entity_streaming_parquet - - counts = _assign_trx_to_entity_streaming_parquet( - trx_parquet_path, - self.gdf, - id_col=self.nbhd_col, - x_col=x_col, - y_col=y_col, - gene_col=gene_col, - batch_size=batch_size, - ) - total_transcripts = ( - counts.sum(axis=1).reindex(self.obs.index.astype(str)).fillna(0).astype(int) - ) - obs["total_transcripts"] = total_transcripts.to_numpy() - self.obs = obs - return - from celldega.nbhd.neighborhoods import _calc_nbhd_transcript_assignment from celldega.nbhd.utils import _get_gdf_trx + if self.gdf is None: + raise ValueError("gdf or geometry is required to calculate transcript assignment") resolved_data_dir = data_dir if data_dir is not None else self.data_dir if resolved_data_dir is None: - raise ValueError( - "data_dir or trx_parquet_path is required to calculate transcript assignment" - ) + raise ValueError("data_dir is required to calculate transcript assignment") gdf_trx = _get_gdf_trx(resolved_data_dir) stats = _calc_nbhd_transcript_assignment(self.gdf, self.nbhd_col, gdf_trx) stats = stats.reindex(self.obs.index.astype(str)) + obs = self.obs.copy() for col in stats.columns: obs[col] = stats[col].to_numpy() self.obs = obs diff --git a/src/celldega/nbhd/expansion.py b/src/celldega/nbhd/expansion.py index 8190d72a..39cf4cd2 100644 --- a/src/celldega/nbhd/expansion.py +++ b/src/celldega/nbhd/expansion.py @@ -1,15 +1,10 @@ """Expansion: per-entity buffering clipped to a matching bounding geometry. -Unlike :mod:`celldega.nbhd.gradient` — which grows concentric rings outward from and -inward into ONE dissolved region of interest (e.g. a tumor alpha shape) — this grows -**every** neighborhood in a collection independently, using each one as its own tiny -ROI. Each buffered entity is clipped to a matching row of a per-entity bounding -GeoDataFrame, so the expansion never grows past that entity's own outer limit. The -canonical use case is growing a segmented nucleus outward until it reaches its -corresponding cell boundary (to profile how nuclear vs. cytoplasmic transcript -capture changes with the working boundary), but the same mechanics apply to any -pair of nested per-entity geometries — e.g. a core region expanding into a parent -tissue domain, or a seed point buffer expanding into a Voronoi/tile boundary. +Unlike :mod:`celldega.nbhd.gradient` (concentric rings from ONE dissolved ROI), +this grows **every** entity in a collection independently, clipping each to a +matching row of a per-entity bounding GeoDataFrame so it never grows past its +own outer limit — e.g. a segmented nucleus growing outward until it reaches its +corresponding cell boundary. """ from __future__ import annotations @@ -42,68 +37,54 @@ def _calc_expansion( ) -> dict[float, gpd.GeoDataFrame]: """Engine behind :meth:`NeighborhoodCollection.calc_expansion`. - For each radius in ``radii_um``, buffers every entity in ``gdf_source`` outward - by that distance and intersects the result with the matching row (by - ``id_col``) in ``gdf_bounds``, so growth stops at that entity's own bounding - geometry (e.g. a nucleus growing into its cell, or any other per-entity - container). Invalid input geometries are repaired with ``shapely.make_valid`` - first. + For each radius in ``radii_um``, buffers every entity in ``gdf_source`` + outward and intersects the result with the matching row (by ``id_col``) in + ``gdf_bounds``, so growth stops at that entity's own bound. Invalid input + geometries are repaired with ``shapely.make_valid`` first. Args: - gdf_source: One row per entity to expand (e.g. a nucleus), with an + gdf_source: One row per entity to expand, with an ``id_col`` column and + a ``geometry`` column. + gdf_bounds: One row per entity's clipping boundary, with a matching ``id_col`` column and a ``geometry`` column. - gdf_bounds: One row per entity's clipping boundary (e.g. its cell), with - an ``id_col`` column matching ``gdf_source`` and a ``geometry`` - column. Must have exactly one row per id. radii_um: Buffer distances in microns. ``0`` returns the original (validity-repaired) source geometry, clipped to its bound. - id_col: Column identifying each entity, shared by both frames (default - ``"id"``). + id_col: Column identifying each entity, shared by both frames. technology: Imaging platform (e.g. ``"Xenium"``) used to look up - ``scale_um_per_pixel`` when the geometry is in pixel space. Ignored if - ``scale_um_per_pixel`` is given. - scale_um_per_pixel: Microns per pixel — the factor a micron distance is - *divided* by to get pixels (e.g. an OME-XML ``PhysicalSizeX``). - Required (directly, via ``technology``, or via ``pixels_per_micron``) - when ``is_pixel_space=True``. Takes precedence over - ``pixels_per_micron`` if both are given. - pixels_per_micron: Pixels per micron — the reciprocal convention, where a - micron distance is *multiplied* by this factor to get pixels (e.g. a - notebook's own ``buffer_dist = expand_um * high_res_scale``). Only - used when ``scale_um_per_pixel`` is not resolved some other way; - equivalent to passing ``scale_um_per_pixel=1 / pixels_per_micron``. - is_pixel_space: ``True`` if ``gdf_source``/``gdf_bounds`` geometry is in - pixel units; ``False`` (default) if already in microns. - join_style: Shapely buffer join style (``1``=round, ``2``=mitre (default, - matches sharp polygon corners), ``3``=bevel). + ``scale_um_per_pixel`` for pixel-space geometry. + scale_um_per_pixel: Microns per pixel (divide a micron distance by this + to get pixels). Required, directly or via ``technology``/ + ``pixels_per_micron``, when ``is_pixel_space=True``; takes + precedence over ``pixels_per_micron`` if both are given. + pixels_per_micron: Pixels per micron — the reciprocal convention + (multiply a micron distance by this to get pixels, e.g. a + notebook's own ``high_res_scale``); equivalent to + ``scale_um_per_pixel=1 / pixels_per_micron``. + is_pixel_space: ``True`` if the geometry is in pixel units; ``False`` + (default) if already in microns. + join_style: Shapely buffer join style (``1``=round, ``2``=mitre + (default), ``3``=bevel). mitre_limit: Shapely mitre limit, used when ``join_style=2``. - add_colors: If ``True`` (default), add a ``color`` column — one shade per - radius (dark to light) — for visualization. + add_colors: If ``True`` (default), add a ``color`` column — one shade + per radius — for visualization. Returns: - A dict mapping each radius in ``radii_um`` (in microns, ascending) to a - ``GeoDataFrame`` of that radius's buffered, clipped entities, with columns - ``id_col``, ``geometry``, ``radius_um``, ``center_x``, ``center_y``, - ``area``/``area_um2``/``area_px2``, and (when ``add_colors``) ``color``. - Entities that vanish entirely at a given radius (empty intersection) are + A dict mapping each radius to a ``GeoDataFrame`` of that radius's + buffered, clipped entities (``id_col``, ``geometry``, ``radius_um``, + ``center_x``/``center_y``, ``area``/``area_um2``/``area_px2``, and + ``color`` if requested). Entities that vanish at a given radius are dropped from that radius's frame. Raises: KeyError: If ``id_col`` is missing from either frame. - ValueError: If ids are duplicated in ``gdf_bounds``, if any source id is - missing from ``gdf_bounds``, or if ``is_pixel_space=True`` without a - resolvable scale (``scale_um_per_pixel``, ``pixels_per_micron``, or - ``technology``). + ValueError: If ids are duplicated or fail to match between frames, or + if ``is_pixel_space=True`` without a resolvable scale. Examples: - Prefer the public method, which anchors on a collection of entities and - returns one new collection per radius (pass ``pixels_per_micron=`` for - pixel-space geometry, e.g. a notebook's own ``high_res_scale``):: - - >>> series = nbhd_nuclei.calc_expansion( - ... gdf_cells, radii_um=[0, 1, 2, 3], - ... is_pixel_space=True, pixels_per_micron=high_res_scale, - ... ) + >>> series = nbhd_nuclei.calc_expansion( + ... gdf_cells, radii_um=[0, 1, 2, 3], + ... is_pixel_space=True, pixels_per_micron=high_res_scale, + ... ) """ if id_col not in gdf_source.columns: raise KeyError(f"gdf_source missing '{id_col}'") diff --git a/src/celldega/nbhd/neighborhoods.py b/src/celldega/nbhd/neighborhoods.py index b60500a6..06b94748 100644 --- a/src/celldega/nbhd/neighborhoods.py +++ b/src/celldega/nbhd/neighborhoods.py @@ -35,10 +35,6 @@ def _calc_nbhd_by_gene( data_dir: str | None = None, gdf_trx: gpd.GeoDataFrame | None = None, feature_col: str = "feature_name", - trx_parquet_path: str | None = None, - x_col: str = "x", - y_col: str = "y", - batch_size: int = 1_000_000, nbhd_col: str = "name", min_cells: int = 1, ) -> AnnData: @@ -48,53 +44,39 @@ def _calc_nbhd_by_gene( Internal spatial-computation kernel. The public entry point is :meth:`NeighborhoodCollection.calc_signature`. - Computes gene expression values for each neighborhood, either from cell-level - expression data (mean expression of cells within each neighborhood, `by="cell"`) - or from raw transcript counts (`by="cell-free"`). + `by="cell"` averages cell-level expression per neighborhood; `by="cell-free"` + counts transcripts per neighborhood, streamed in batches from `data_dir`'s + Xenium-convention `transcripts.parquet`, or from a pre-loaded `gdf_trx`. Parameters ---------- gdf_nbhd : gpd.GeoDataFrame - GeoDataFrame containing neighborhood geometries. Must have a geometry column - and a column specified by `nbhd_col` for neighborhood identifiers. + Neighborhood geometries, with a `geometry` column and a `nbhd_col` id column. by : str, default "cell" - "cell" (requires `adata`) or "cell-free" (requires one of `gdf_trx`, - `trx_parquet_path`, `data_dir`). + "cell" (requires `adata`) or "cell-free" (requires `data_dir` or `gdf_trx`). adata : AnnData, optional - AnnData object with cell data. Required when `by="cell"`. Must have spatial - coordinates in `obsm["spatial"]`. + Cell-level data with spatial coordinates in `obsm["spatial"]`; required + for `by="cell"`. data_dir : str, optional Directory with a Xenium-convention `transcripts.parquet` - (`feature_name`/`x_location`/`y_location` columns). Used for `by="cell-free"` - when neither `gdf_trx` nor `trx_parquet_path` is given. + (`feature_name`/`x_location`/`y_location`). Used for `by="cell-free"` + when `gdf_trx` isn't given. gdf_trx : gpd.GeoDataFrame, optional - Pre-loaded transcript points for `by="cell-free"` (custom paths/column - names); a `geometry` column plus a gene column named `feature_col`. Takes - precedence over `trx_parquet_path` and `data_dir`. + Pre-loaded transcript points for `by="cell-free"` (custom column + names/paths); a `geometry` column plus a gene column named `feature_col`. + Takes precedence over `data_dir`. feature_col : str, default "feature_name" - Gene/feature column name, used with `gdf_trx` or as `gene_col` when - streaming from `trx_parquet_path` (`data_dir` always uses `feature_name`). - trx_parquet_path : str, optional - Transcripts parquet path to stream in batches for `by="cell-free"` - instead of loading into memory (see `celldega.nbhd.trx_streaming`); takes - precedence over `data_dir` but not `gdf_trx`. - x_col, y_col : str, default "x", "y" - Transcript coordinate columns in `trx_parquet_path`. - batch_size : int, default 1_000_000 - Rows read per streamed batch when using `trx_parquet_path`. + Gene/feature column in `gdf_trx`. nbhd_col : str, default "name" - Column in `gdf_nbhd` containing neighborhood identifiers. + Neighborhood id column in `gdf_nbhd`. min_cells : int, default 1 - Minimum number of cells/transcripts required within a neighborhood to - include it in the output. + Minimum cells/transcripts for a neighborhood to be kept. Returns ------- AnnData - Shape (n_neighborhoods, n_genes): `X` = expression values (mean for - cell-derived, counts for cell-free), `obs`/`var` indexed by neighborhood/ - gene, plus `obs["n_cells"]` (`by="cell"`) or `obs["n_transcripts"]` - (`by="cell-free"`) and `uns["by"]`. + Shape (n_neighborhoods, n_genes); `obs["n_cells"]` (`by="cell"`) or + `obs["n_transcripts"]` (`by="cell-free"`). """ if by == "cell": if adata is None: @@ -154,50 +136,25 @@ def _calc_nbhd_by_gene( .fillna(0) .astype(int) ) - elif trx_parquet_path is not None: - print("Calculating neighborhood-by-gene (cell-free, streaming parquet)") + elif data_dir is not None: + print("Calculating neighborhood-by-gene (cell-free, streaming)") from celldega.nbhd.trx_streaming import _assign_trx_to_entity_streaming_parquet df_result = ( _assign_trx_to_entity_streaming_parquet( - trx_parquet_path, + f"{data_dir}/transcripts.parquet", gdf_nbhd, id_col=nbhd_col, - x_col=x_col, - y_col=y_col, - gene_col=feature_col, - batch_size=batch_size, + x_col="x_location", + y_col="y_location", + gene_col="feature_name", ) .reindex(gdf_nbhd[nbhd_col]) .fillna(0) .astype(int) ) - elif data_dir is not None: - print("Calculating neighborhood-by-gene (cell-free)") - - df_trx = pd.read_parquet( - f"{data_dir}/transcripts.parquet", - columns=["feature_name", "x_location", "y_location"], - engine="pyarrow", - ) - geometry = gpd.points_from_xy(df_trx["x_location"], df_trx["y_location"]) - feature_col = "feature_name" - joined = gpd.GeoDataFrame(df_trx[[feature_col]], geometry=geometry).sjoin( - _nbhd_geometry_for_join(gdf_nbhd, nbhd_col), how="left", predicate="within" - ) - df_result = ( - joined.groupby([nbhd_col, feature_col]) - .size() - .unstack(fill_value=0) - .rename_axis(None, axis=1) - .reindex(gdf_nbhd[nbhd_col]) - .fillna(0) - .astype(int) - ) else: - raise ValueError( - "data_dir, gdf_trx, or trx_parquet_path is required when by='cell-free'" - ) + raise ValueError("data_dir or gdf_trx is required when by='cell-free'") # Filter by min_cells (here it's min transcripts total) trx_counts = df_result.sum(axis=1) diff --git a/src/celldega/nbhd/trx_streaming.py b/src/celldega/nbhd/trx_streaming.py index e77f5ce2..36794529 100644 --- a/src/celldega/nbhd/trx_streaming.py +++ b/src/celldega/nbhd/trx_streaming.py @@ -1,18 +1,12 @@ """Streaming, spatial-index-accelerated transcript-to-entity assignment. -The other cell-free code paths in :mod:`celldega.nbhd.neighborhoods` -(``gdf_trx=`` or ``data_dir=``) load every transcript into memory as point -geometries and run a single :meth:`geopandas.GeoDataFrame.sjoin`. For a -whole-tile ``transcripts.parquet`` (tens of millions of rows, e.g. covering a -55,000 x 55,000 micron tile) that is more memory than is comfortable to hold — -especially when the same file is assigned once per radius in a -:meth:`~celldega.nbhd.collection.NeighborhoodCollection.calc_expansion` -series. - -This module instead streams the parquet file in batches via ``pyarrow``, and for -each batch only tests the entities whose bounding box the batch could plausibly -intersect (using the entity ``GeoDataFrame``'s spatial index), so memory use stays -bounded by the batch size regardless of the total transcript count. +Backs :meth:`NeighborhoodCollection.calc_signature`'s ``data_dir=`` cell-free +path: reads a transcripts parquet file in batches via ``pyarrow``, and per batch +only tests entities whose bounding box the batch could plausibly intersect (via +the entity ``GeoDataFrame``'s spatial index), so memory stays bounded by the +batch size regardless of file size — useful for a whole-tile +``transcripts.parquet`` re-joined once per radius in a +:meth:`~celldega.nbhd.collection.NeighborhoodCollection.calc_expansion` series. """ from __future__ import annotations @@ -39,36 +33,30 @@ def _assign_trx_to_entity_streaming_parquet( ) -> pd.DataFrame: """Stream transcripts from ``trx_parquet_path`` and count them per entity/gene. - For each streamed batch of transcripts, candidate entities are first narrowed - down with ``gdf_entity``'s spatial index (by the batch's bounding box), then - each candidate's exact polygon is tested with a vectorized point-in-polygon - check (``shapely.contains_xy``). Counts are accumulated across batches. + For each streamed batch, candidate entities are first narrowed down with + ``gdf_entity``'s spatial index (by the batch's bounding box), then each + candidate's exact polygon is tested with a vectorized point-in-polygon check + (``shapely.contains_xy``). Counts are accumulated across batches. Args: - trx_parquet_path: Path to a transcripts parquet file (or partitioned - dataset directory) containing at least ``x_col``, ``y_col``, and - ``gene_col``. - gdf_entity: One row per entity to assign transcripts to — e.g. a nucleus, - cell, or a single radius's buffered polygons from - :meth:`NeighborhoodCollection.calc_expansion` — with an ``id_col`` - column and a ``geometry`` column. + trx_parquet_path: Path to a transcripts parquet file (or dataset) + containing at least ``x_col``, ``y_col``, and ``gene_col``. + gdf_entity: One row per entity to assign transcripts to, with an + ``id_col`` column and a ``geometry`` column. id_col: Column in ``gdf_entity`` identifying each entity. x_col: Transcript x-coordinate column in the parquet file. y_col: Transcript y-coordinate column in the parquet file. gene_col: Transcript gene/feature column in the parquet file. - batch_size: Number of transcript rows read per streamed batch. Bounds - peak memory use; does not affect the result. + batch_size: Rows read per streamed batch. Bounds peak memory use; does + not affect the result. assume_non_overlapping: If ``True`` (default), a transcript is excluded - from consideration for further entities once assigned. Valid whenever - entities don't overlap (nuclei, cells, non-overlapping radial-buffer - rings), and lets a batch stop early once every point has a match. + from consideration once assigned — valid whenever entities don't + overlap — and lets a batch stop early once every point has a match. Returns: A ``DataFrame`` indexed by entity id (as ``str``) with one integer count - column per gene seen in an assigned transcript. Entities with zero - assigned transcripts, and genes never seen in an assigned transcript, are - simply absent — callers typically reindex/``fillna(0)`` against the full - entity and gene axes. + column per gene seen in an assigned transcript. Entities/genes never + seen are simply absent — callers typically reindex/``fillna(0)``. Raises: KeyError: If ``id_col`` is missing from ``gdf_entity``. diff --git a/src/celldega/nbhd/utils.py b/src/celldega/nbhd/utils.py index baacc5ec..e00efd51 100644 --- a/src/celldega/nbhd/utils.py +++ b/src/celldega/nbhd/utils.py @@ -1,6 +1,7 @@ """Helper and utility functions.""" # Standard library imports +from collections import defaultdict from collections.abc import Sequence from typing import Any @@ -150,58 +151,51 @@ def round_coords( return transform(round_coords, geometry) -def gdf_from_contour_coords( - df_contours: pd.DataFrame, - id_col: str = "cell_id", - x_col: str = "vertex_x", - y_col: str = "vertex_y", -) -> gpd.GeoDataFrame: - """ - Build a polygon GeoDataFrame from a long-format vertex-coordinate table. - - Each row of `df_contours` is one polygon vertex, in order; rows sharing the - same `id_col` value become one polygon -- the shape produced by exporting a - segmentation mask's contours to CSV (e.g. a `*_nuclei_contour_coords.csv` / - `*_cell_contour_coords.csv` pair, one row per `(id_col, x_col, y_col)` - vertex). A group that fails to form a valid polygon (e.g. fewer than 3 - vertices) becomes an empty geometry rather than raising, so one malformed - entity doesn't break the whole batch. - - Any coordinate offsetting/rescaling (e.g. converting instrument microns to - a registered image's pixel space) should be applied to `df_contours[x_col]`/ - `df_contours[y_col]` before calling this function. - - Parameters - ---------- - df_contours : pd.DataFrame - Long-format vertex table with `id_col`, `x_col`, `y_col` columns. - id_col : str, default "cell_id" - Column identifying which polygon each vertex belongs to. - x_col, y_col : str, default "vertex_x", "vertex_y" - Vertex coordinate columns. - - Returns - ------- - gpd.GeoDataFrame - One row per id, with `id_col`, `geometry`, `center_x`, `center_y` - columns -- ready to pass to `NeighborhoodCollection(gdf=..., nbhd_col=id_col)` - or as the `gdf_source`/`gdf_bounds` of `calc_expansion`. - """ - - def _safe_polygon(row: pd.Series) -> Polygon: - try: - return Polygon(zip(row[x_col], row[y_col], strict=True)) - except Exception: - return Polygon() - - grouped = df_contours.groupby(id_col).agg(list) - gdf = gpd.GeoDataFrame( - {id_col: grouped.index}, - geometry=grouped.apply(_safe_polygon, axis=1).to_numpy(), - ).reset_index(drop=True) - gdf["center_x"] = gdf.centroid.x - gdf["center_y"] = gdf.centroid.y - return gdf +def safe_polygon(row: pd.Series) -> Polygon: + """Build a `Polygon` from a row's `vertex_x`/`vertex_y` coordinate lists; empty on failure.""" + try: + return Polygon(zip(row["vertex_x"], row["vertex_y"], strict=True)) + except Exception: + return Polygon() + + +def simple_format(geometry: Sequence[Sequence[Sequence[float]]], image_scale: float) -> list: + """Rescale a nested polygon-ring coordinate list by dividing by `image_scale`.""" + return [ + [[coord[0] / image_scale, coord[1] / image_scale] for coord in polygon] + for polygon in geometry + ] + + +def transform_polygon(polygon: Polygon) -> np.ndarray: + """Convert a `Polygon`'s exterior ring into a `[1, n_points, 2]` object array.""" + exterior_coords = polygon.exterior.coords + original_format_coords = np.array([np.array(coord) for coord in exterior_coords]) + return np.array([original_format_coords], dtype=object) + + +def make_column_names_unique_fast(df: pd.DataFrame) -> pd.DataFrame: + """Rename duplicate columns in place (`col`, `col_1`, `col_2`, ...) and return `df`.""" + counts: dict[str, int] = defaultdict(int) + used: set[str] = set() + new_cols = [] + + for col in df.columns: + if col not in used: + new_cols.append(col) + used.add(col) + counts[col] += 1 + else: + while True: + new_name = f"{col}_{counts[col]}" + counts[col] += 1 + if new_name not in used: + new_cols.append(new_name) + used.add(new_name) + break + + df.columns = new_cols + return df def df_to_anndata(df: pd.DataFrame) -> AnnData: diff --git a/tests/unit/test_nbhd/test_expansion.py b/tests/unit/test_nbhd/test_expansion.py index 443e94f5..6836f275 100644 --- a/tests/unit/test_nbhd/test_expansion.py +++ b/tests/unit/test_nbhd/test_expansion.py @@ -237,31 +237,27 @@ def test_calc_signature_cell_free_requires_data_dir_or_gdf_trx(): gdf_nuclei, _gdf_cells = _synthetic_nucleus_cell_inputs() nbhd = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") - with pytest.raises(ValueError, match="data_dir, gdf_trx, or trx_parquet_path"): + with pytest.raises(ValueError, match="data_dir or gdf_trx"): nbhd.calc_signature(by="cell-free") -def test_calc_signature_cell_free_streams_from_parquet_across_radii(tmp_path): +def test_calc_signature_cell_free_streams_from_data_dir_across_radii(tmp_path): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[0, 5]) - trx_path = tmp_path / "transcripts.parquet" + # data_dir's cell-free path is now backed by the streaming engine internally, + # using the Xenium transcripts.parquet convention. pd.DataFrame( { - "x": [5, 1, 25], - "y": [5, 1, 25], - "name": ["GeneA", "GeneB", "GeneA"], + "feature_name": ["GeneA", "GeneB", "GeneA"], + "x_location": [5, 1, 25], + "y_location": [5, 1, 25], } - ).to_parquet(trx_path) + ).to_parquet(tmp_path / "transcripts.parquet") nbhd_r0 = series[0.0] - nbhd_r0.calc_signature( - by="cell-free", - trx_parquet_path=str(trx_path), - feature_col="name", - drop_missing=False, - ) + nbhd_r0.calc_signature(by="cell-free", data_dir=str(tmp_path), drop_missing=False) df_r0 = pd.DataFrame( nbhd_r0.mod["gene_cell_free"].X, index=nbhd_r0.mod["gene_cell_free"].obs_names, @@ -271,12 +267,7 @@ def test_calc_signature_cell_free_streams_from_parquet_across_radii(tmp_path): assert "GeneB" not in df_r0.columns nbhd_r5 = series[5.0] - nbhd_r5.calc_signature( - by="cell-free", - trx_parquet_path=str(trx_path), - feature_col="name", - drop_missing=False, - ) + nbhd_r5.calc_signature(by="cell-free", data_dir=str(tmp_path), drop_missing=False) df_r5 = pd.DataFrame( nbhd_r5.mod["gene_cell_free"].X, index=nbhd_r5.mod["gene_cell_free"].obs_names, @@ -284,33 +275,3 @@ def test_calc_signature_cell_free_streams_from_parquet_across_radii(tmp_path): ) assert df_r5.loc["c1", "GeneA"] == 1 assert df_r5.loc["c1", "GeneB"] == 1 - - -def test_calc_transcript_assignment_streaming_mode_computes_totals(tmp_path): - gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() - nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") - series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[5]) - - trx_path = tmp_path / "transcripts.parquet" - pd.DataFrame( - { - "x": [5, 1, 25], - "y": [5, 1, 25], - "name": ["GeneA", "GeneB", "GeneA"], - } - ).to_parquet(trx_path) - - nbhd_r5 = series[5.0] - nbhd_r5.calc_transcript_assignment(trx_parquet_path=str(trx_path), gene_col="name") - - assert nbhd_r5.obs.loc["c1", "total_transcripts"] == 2 - assert nbhd_r5.obs.loc["c2", "total_transcripts"] == 1 - assert "unassigned_transcripts" not in nbhd_r5.obs.columns - - -def test_calc_transcript_assignment_requires_data_dir_or_trx_parquet_path(): - gdf_nuclei, _gdf_cells = _synthetic_nucleus_cell_inputs() - nbhd = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") - - with pytest.raises(ValueError, match="data_dir or trx_parquet_path"): - nbhd.calc_transcript_assignment() diff --git a/tests/unit/test_nbhd/test_utils.py b/tests/unit/test_nbhd/test_utils.py index 4be99723..533b9105 100644 --- a/tests/unit/test_nbhd/test_utils.py +++ b/tests/unit/test_nbhd/test_utils.py @@ -1,54 +1,41 @@ import pandas as pd -import pytest +from shapely.geometry import Polygon -from celldega.nbhd import df_to_anndata, gdf_from_contour_coords +from celldega.nbhd import ( + df_to_anndata, + make_column_names_unique_fast, + safe_polygon, + simple_format, + transform_polygon, +) -def test_gdf_from_contour_coords_builds_polygons(): - df_contours = pd.DataFrame( - { - "cell_id": [1, 1, 1, 1, 2, 2, 2], - "vertex_x": [0, 10, 10, 0, 20, 30, 25], - "vertex_y": [0, 0, 10, 10, 0, 0, 10], - } - ) - - gdf = gdf_from_contour_coords(df_contours) +def test_safe_polygon_builds_from_vertex_columns(): + row = pd.Series({"vertex_x": [0, 10, 10, 0], "vertex_y": [0, 0, 10, 10]}) + assert safe_polygon(row).area == 100.0 - assert list(gdf["cell_id"]) == [1, 2] - assert list(gdf.geometry.area) == [100.0, 50.0] - assert {"center_x", "center_y"}.issubset(gdf.columns) +def test_safe_polygon_returns_empty_on_malformed_row(): + row = pd.Series({"vertex_x": [0, 1], "vertex_y": [0]}) + assert safe_polygon(row).is_empty -def test_gdf_from_contour_coords_custom_columns(): - df_contours = pd.DataFrame( - { - "id": ["a", "a", "a"], - "x": [0, 4, 2], - "y": [0, 0, 4], - } - ) - gdf = gdf_from_contour_coords(df_contours, id_col="id", x_col="x", y_col="y") +def test_simple_format_rescales_coordinates(): + geometry = [[[10, 20], [30, 40]]] + assert simple_format(geometry, image_scale=2) == [[[5.0, 10.0], [15.0, 20.0]]] - assert list(gdf["id"]) == ["a"] - assert gdf.geometry.iloc[0].area == pytest.approx(8.0) +def test_transform_polygon_returns_exterior_as_object_array(): + poly = Polygon([(0, 0), (1, 0), (1, 1)]) + result = transform_polygon(poly) + assert result.shape == (1, 4, 2) + assert list(result[0][0]) == [0, 0] -def test_gdf_from_contour_coords_malformed_group_becomes_empty_geometry(): - # a group with only 2 vertices can't form a polygon - df_contours = pd.DataFrame( - { - "cell_id": [1, 1, 2, 2, 2], - "vertex_x": [0, 1, 0, 4, 2], - "vertex_y": [0, 1, 0, 0, 4], - } - ) - - gdf = gdf_from_contour_coords(df_contours) - assert gdf.set_index("cell_id").loc[1, "geometry"].is_empty - assert not gdf.set_index("cell_id").loc[2, "geometry"].is_empty +def test_make_column_names_unique_fast_dedupes_columns(): + df = pd.DataFrame([[1, 2, 3]], columns=["gene", "gene", "gene"]) + result = make_column_names_unique_fast(df) + assert list(result.columns) == ["gene", "gene_1", "gene_2"] def test_df_to_anndata_wraps_matrix_without_extra_computation(): From eb7bc21e04b01063e997cded61ee4a1df34d09c2 Mon Sep 17 00:00:00 2001 From: Jaspreet Ishar Date: Thu, 16 Jul 2026 15:16:33 -0400 Subject: [PATCH 05/14] updated notebook --- .../Nuclear_Expansion_Radial_Buffering.ipynb | 152 +++++------------- 1 file changed, 43 insertions(+), 109 deletions(-) diff --git a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb index 2c56225c..4ba52f56 100644 --- a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb +++ b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb @@ -47,14 +47,7 @@ "cell_type": "code", "execution_count": 1, "id": "4d0f46b0", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-16T18:08:31.310410Z", - "iopub.status.busy": "2026-07-16T18:08:31.310247Z", - "iopub.status.idle": "2026-07-16T18:08:34.727938Z", - "shell.execute_reply": "2026-07-16T18:08:34.727361Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -100,14 +93,7 @@ "cell_type": "code", "execution_count": 2, "id": "5f2394c8", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-16T18:08:34.730310Z", - "iopub.status.busy": "2026-07-16T18:08:34.729854Z", - "iopub.status.idle": "2026-07-16T18:08:34.747066Z", - "shell.execute_reply": "2026-07-16T18:08:34.746617Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -175,14 +161,7 @@ "cell_type": "code", "execution_count": 3, "id": "85a6f217", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-16T18:08:34.748526Z", - "iopub.status.busy": "2026-07-16T18:08:34.748398Z", - "iopub.status.idle": "2026-07-16T18:08:34.763023Z", - "shell.execute_reply": "2026-07-16T18:08:34.762511Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -276,14 +255,7 @@ "cell_type": "code", "execution_count": 4, "id": "658414fd", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-16T18:08:34.764600Z", - "iopub.status.busy": "2026-07-16T18:08:34.764486Z", - "iopub.status.idle": "2026-07-16T18:08:34.862039Z", - "shell.execute_reply": "2026-07-16T18:08:34.861190Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -311,15 +283,19 @@ "cell_type": "code", "execution_count": 5, "id": "140c06c5", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-16T18:08:34.864034Z", - "iopub.status.busy": "2026-07-16T18:08:34.863897Z", - "iopub.status.idle": "2026-07-16T18:08:35.700858Z", - "shell.execute_reply": "2026-07-16T18:08:35.700146Z" + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } - }, - "outputs": [], + ], "source": [ "# visual sanity check for one example cell, mirroring the original notebook's plot\n", "example_id = str(int(df_cell_meta.index[7]))\n", @@ -364,14 +340,7 @@ "cell_type": "code", "execution_count": 6, "id": "2f1d3bf5", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-16T18:08:35.702856Z", - "iopub.status.busy": "2026-07-16T18:08:35.702739Z", - "iopub.status.idle": "2026-07-16T18:08:35.811831Z", - "shell.execute_reply": "2026-07-16T18:08:35.811207Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -427,14 +396,7 @@ "cell_type": "code", "execution_count": 7, "id": "09ef320b", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-16T18:08:35.813813Z", - "iopub.status.busy": "2026-07-16T18:08:35.813683Z", - "iopub.status.idle": "2026-07-16T18:08:35.865917Z", - "shell.execute_reply": "2026-07-16T18:08:35.865257Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -512,14 +474,7 @@ "cell_type": "code", "execution_count": 8, "id": "10f40fda", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-16T18:08:35.867449Z", - "iopub.status.busy": "2026-07-16T18:08:35.867338Z", - "iopub.status.idle": "2026-07-16T18:08:35.968417Z", - "shell.execute_reply": "2026-07-16T18:08:35.967750Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -682,14 +637,7 @@ "cell_type": "code", "execution_count": 9, "id": "7ec22ce0", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-16T18:08:35.970449Z", - "iopub.status.busy": "2026-07-16T18:08:35.970224Z", - "iopub.status.idle": "2026-07-16T18:08:35.973951Z", - "shell.execute_reply": "2026-07-16T18:08:35.973388Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -729,26 +677,13 @@ "cell_type": "code", "execution_count": 10, "id": "4a21421e", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-16T18:08:35.975475Z", - "iopub.status.busy": "2026-07-16T18:08:35.975370Z", - "iopub.status.idle": "2026-07-16T18:08:36.198945Z", - "shell.execute_reply": "2026-07-16T18:08:36.198389Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Calculating neighborhood-by-gene (cell-free, streaming)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating neighborhood-by-gene (cell-free, streaming)\n", "gdf_trx and data_dir paths agree\n" ] }, @@ -804,14 +739,7 @@ "cell_type": "code", "execution_count": 11, "id": "f4ec2540", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-16T18:08:36.200443Z", - "iopub.status.busy": "2026-07-16T18:08:36.200330Z", - "iopub.status.idle": "2026-07-16T18:08:46.010818Z", - "shell.execute_reply": "2026-07-16T18:08:46.010098Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stderr", @@ -822,12 +750,14 @@ ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jishar/Documents/celldega/dega/lib/python3.12/site-packages/scanpy/plotting/_utils.py:364: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", - " plt.show()\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -869,15 +799,19 @@ "cell_type": "code", "execution_count": 12, "id": "1a864fad", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-16T18:08:46.013475Z", - "iopub.status.busy": "2026-07-16T18:08:46.013325Z", - "iopub.status.idle": "2026-07-16T18:08:46.063822Z", - "shell.execute_reply": "2026-07-16T18:08:46.063115Z" + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } - }, - "outputs": [], + ], "source": [ "n_clusters = {radius: adata.obs[\"leiden\"].nunique() for radius, adata in adatas.items()}\n", "\n", From 91d1240b1ad62a507268767e4cd45658861aae85 Mon Sep 17 00:00:00 2001 From: Jaspreet Ishar Date: Thu, 16 Jul 2026 16:26:32 -0400 Subject: [PATCH 06/14] adding more paramters to calc_signature() --- .../Nuclear_Expansion_Radial_Buffering.ipynb | 4 +-- src/celldega/nbhd/collection.py | 20 ++++++++--- src/celldega/nbhd/neighborhoods.py | 19 +++++++---- tests/unit/test_nbhd/test_expansion.py | 34 +++++++++++++++++++ 4 files changed, 64 insertions(+), 13 deletions(-) diff --git a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb index 4ba52f56..fde164af 100644 --- a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb +++ b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb @@ -833,7 +833,7 @@ }, { "cell_type": "markdown", - "id": "0768b44c", + "id": "fa4b647b-4dd6-42b0-9231-5896987aaa62", "metadata": {}, "source": [ "## Mapping this onto a real pipeline\n", @@ -858,7 +858,7 @@ { "cell_type": "code", "execution_count": null, - "id": "fa4b647b-4dd6-42b0-9231-5896987aaa62", + "id": "14cd97bd-fa73-40c3-ab90-49a3328d5efc", "metadata": {}, "outputs": [], "source": [] diff --git a/src/celldega/nbhd/collection.py b/src/celldega/nbhd/collection.py index ac5d4cc0..0309c3f8 100644 --- a/src/celldega/nbhd/collection.py +++ b/src/celldega/nbhd/collection.py @@ -545,6 +545,8 @@ def calc_signature( data_dir: str | None = None, gdf_trx: gpd.GeoDataFrame | None = None, feature_col: str = "feature_name", + x_col: str = "x_location", + y_col: str = "y_location", drop_missing: bool = True, ) -> None: """Calculate a neighborhood-by-gene modality and attach it to ``self.mod``. @@ -560,13 +562,21 @@ def calc_signature( modality_name: Key for the modality; defaults to ``"gene"`` (cell-derived) or ``"gene_cell_free"`` (transcript-derived). min_cells: Minimum cells/transcripts for a neighborhood to be kept. - data_dir: Directory with a Xenium-convention ``transcripts.parquet`` - (streamed in batches); defaults to ``self.data_dir``. Used for - ``by="cell-free"`` when ``gdf_trx`` isn't given. + data_dir: Directory with a ``transcripts.parquet`` (columns named + ``feature_col``/``x_col``/``y_col``, Xenium convention by + default; streamed in batches); defaults to ``self.data_dir``. + Used for ``by="cell-free"`` when ``gdf_trx`` isn't given. gdf_trx: Pre-loaded transcript points for ``by="cell-free"`` (custom column names/paths); takes precedence over ``data_dir``. - feature_col: Gene/feature column in ``gdf_trx`` (default + feature_col: Gene/feature column — in ``gdf_trx``, or in + ``data_dir``'s ``transcripts.parquet`` (default ``"feature_name"``). + x_col: Transcript x-coordinate column in ``data_dir``'s + ``transcripts.parquet`` (default ``"x_location"``; ignored for + ``gdf_trx``). + y_col: Transcript y-coordinate column in ``data_dir``'s + ``transcripts.parquet`` (default ``"y_location"``; ignored for + ``gdf_trx``). drop_missing: When ``True`` (default), neighborhoods with fewer than ``min_cells`` cells (or transcripts) are removed from the collection entirely. When ``False``, the collection keeps all @@ -601,6 +611,8 @@ def calc_signature( data_dir=resolved_data_dir, gdf_trx=gdf_trx, feature_col=feature_col, + x_col=x_col, + y_col=y_col, nbhd_col=self.nbhd_col, min_cells=min_cells, ) diff --git a/src/celldega/nbhd/neighborhoods.py b/src/celldega/nbhd/neighborhoods.py index 06b94748..5ceff141 100644 --- a/src/celldega/nbhd/neighborhoods.py +++ b/src/celldega/nbhd/neighborhoods.py @@ -35,6 +35,8 @@ def _calc_nbhd_by_gene( data_dir: str | None = None, gdf_trx: gpd.GeoDataFrame | None = None, feature_col: str = "feature_name", + x_col: str = "x_location", + y_col: str = "y_location", nbhd_col: str = "name", min_cells: int = 1, ) -> AnnData: @@ -46,7 +48,7 @@ def _calc_nbhd_by_gene( `by="cell"` averages cell-level expression per neighborhood; `by="cell-free"` counts transcripts per neighborhood, streamed in batches from `data_dir`'s - Xenium-convention `transcripts.parquet`, or from a pre-loaded `gdf_trx`. + `transcripts.parquet`, or from a pre-loaded `gdf_trx`. Parameters ---------- @@ -58,15 +60,18 @@ def _calc_nbhd_by_gene( Cell-level data with spatial coordinates in `obsm["spatial"]`; required for `by="cell"`. data_dir : str, optional - Directory with a Xenium-convention `transcripts.parquet` - (`feature_name`/`x_location`/`y_location`). Used for `by="cell-free"` + Directory with a `transcripts.parquet` (columns named `feature_col`/ + `x_col`/`y_col`, Xenium convention by default). Used for `by="cell-free"` when `gdf_trx` isn't given. gdf_trx : gpd.GeoDataFrame, optional Pre-loaded transcript points for `by="cell-free"` (custom column names/paths); a `geometry` column plus a gene column named `feature_col`. Takes precedence over `data_dir`. feature_col : str, default "feature_name" - Gene/feature column in `gdf_trx`. + Gene/feature column — in `gdf_trx`, or in `data_dir`'s `transcripts.parquet`. + x_col, y_col : str, default "x_location", "y_location" + Transcript coordinate columns in `data_dir`'s `transcripts.parquet` + (ignored for `gdf_trx`, which is already point geometry). nbhd_col : str, default "name" Neighborhood id column in `gdf_nbhd`. min_cells : int, default 1 @@ -145,9 +150,9 @@ def _calc_nbhd_by_gene( f"{data_dir}/transcripts.parquet", gdf_nbhd, id_col=nbhd_col, - x_col="x_location", - y_col="y_location", - gene_col="feature_name", + x_col=x_col, + y_col=y_col, + gene_col=feature_col, ) .reindex(gdf_nbhd[nbhd_col]) .fillna(0) diff --git a/tests/unit/test_nbhd/test_expansion.py b/tests/unit/test_nbhd/test_expansion.py index 6836f275..8c525319 100644 --- a/tests/unit/test_nbhd/test_expansion.py +++ b/tests/unit/test_nbhd/test_expansion.py @@ -275,3 +275,37 @@ def test_calc_signature_cell_free_streams_from_data_dir_across_radii(tmp_path): ) assert df_r5.loc["c1", "GeneA"] == 1 assert df_r5.loc["c1", "GeneB"] == 1 + + +def test_calc_signature_cell_free_data_dir_accepts_custom_columns(tmp_path): + gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() + nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") + series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[5]) + + # non-Xenium transcripts.parquet: "name"/"x"/"y" instead of + # "feature_name"/"x_location"/"y_location" + pd.DataFrame( + { + "name": ["GeneA", "GeneB", "GeneA"], + "x": [5, 1, 25], + "y": [5, 1, 25], + } + ).to_parquet(tmp_path / "transcripts.parquet") + + nbhd_r5 = series[5.0] + nbhd_r5.calc_signature( + by="cell-free", + data_dir=str(tmp_path), + feature_col="name", + x_col="x", + y_col="y", + drop_missing=False, + ) + df_r5_custom = pd.DataFrame( + nbhd_r5.mod["gene_cell_free"].X, + index=nbhd_r5.mod["gene_cell_free"].obs_names, + columns=nbhd_r5.mod["gene_cell_free"].var_names, + ) + assert df_r5_custom.loc["c1", "GeneA"] == 1 + assert df_r5_custom.loc["c1", "GeneB"] == 1 + assert df_r5_custom.loc["c2", "GeneA"] == 1 From 5f572a271657ae883db4ccab92da0fb38e2bd5a3 Mon Sep 17 00:00:00 2001 From: Jaspreet Ishar Date: Fri, 17 Jul 2026 12:09:20 -0400 Subject: [PATCH 07/14] removing df_to_anndata --- .../Nuclear_Expansion_Radial_Buffering.ipynb | 196 ++++++++++-------- src/celldega/nbhd/__init__.py | 2 - src/celldega/nbhd/neighborhoods.py | 19 +- src/celldega/nbhd/utils.py | 16 -- tests/unit/test_nbhd/test_utils.py | 17 -- 5 files changed, 121 insertions(+), 129 deletions(-) diff --git a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb index fde164af..cdbde706 100644 --- a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb +++ b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb @@ -32,8 +32,6 @@ " `transcripts.parquet` directory (`data_dir=`), which is internally streamed in\n", " batches so a whole-tile file doesn't need to be loaded into memory once per\n", " radius.\n", - "- **`celldega.nbhd.df_to_anndata`** wraps any entity-by-gene (or other matrix)\n", - " DataFrame as a bare `AnnData`, with no normalization/PCA/clustering computed.\n", "\n", "Because the real instrument files (OME-TIFF, per-dataset contour CSVs, a full-tile\n", "`transcripts.parquet`) aren't available here, this notebook builds a small\n", @@ -47,7 +45,14 @@ "cell_type": "code", "execution_count": 1, "id": "4d0f46b0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-17T16:03:00.229534Z", + "iopub.status.busy": "2026-07-17T16:03:00.229384Z", + "iopub.status.idle": "2026-07-17T16:03:03.406991Z", + "shell.execute_reply": "2026-07-17T16:03:03.406458Z" + } + }, "outputs": [ { "data": { @@ -93,7 +98,14 @@ "cell_type": "code", "execution_count": 2, "id": "5f2394c8", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-17T16:03:03.409076Z", + "iopub.status.busy": "2026-07-17T16:03:03.408595Z", + "iopub.status.idle": "2026-07-17T16:03:03.422511Z", + "shell.execute_reply": "2026-07-17T16:03:03.421980Z" + } + }, "outputs": [ { "data": { @@ -161,7 +173,14 @@ "cell_type": "code", "execution_count": 3, "id": "85a6f217", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-17T16:03:03.424335Z", + "iopub.status.busy": "2026-07-17T16:03:03.424229Z", + "iopub.status.idle": "2026-07-17T16:03:03.437671Z", + "shell.execute_reply": "2026-07-17T16:03:03.437157Z" + } + }, "outputs": [ { "data": { @@ -255,7 +274,14 @@ "cell_type": "code", "execution_count": 4, "id": "658414fd", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-17T16:03:03.439190Z", + "iopub.status.busy": "2026-07-17T16:03:03.439074Z", + "iopub.status.idle": "2026-07-17T16:03:03.528128Z", + "shell.execute_reply": "2026-07-17T16:03:03.527579Z" + } + }, "outputs": [ { "name": "stdout", @@ -283,19 +309,15 @@ "cell_type": "code", "execution_count": 5, "id": "140c06c5", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-17T16:03:03.529649Z", + "iopub.status.busy": "2026-07-17T16:03:03.529527Z", + "iopub.status.idle": "2026-07-17T16:03:04.368773Z", + "shell.execute_reply": "2026-07-17T16:03:04.368242Z" } - ], + }, + "outputs": [], "source": [ "# visual sanity check for one example cell, mirroring the original notebook's plot\n", "example_id = str(int(df_cell_meta.index[7]))\n", @@ -340,7 +362,14 @@ "cell_type": "code", "execution_count": 6, "id": "2f1d3bf5", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-17T16:03:04.371171Z", + "iopub.status.busy": "2026-07-17T16:03:04.371005Z", + "iopub.status.idle": "2026-07-17T16:03:04.478927Z", + "shell.execute_reply": "2026-07-17T16:03:04.478287Z" + } + }, "outputs": [ { "name": "stdout", @@ -396,7 +425,14 @@ "cell_type": "code", "execution_count": 7, "id": "09ef320b", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-17T16:03:04.480763Z", + "iopub.status.busy": "2026-07-17T16:03:04.480632Z", + "iopub.status.idle": "2026-07-17T16:03:04.529835Z", + "shell.execute_reply": "2026-07-17T16:03:04.529401Z" + } + }, "outputs": [ { "data": { @@ -474,7 +510,14 @@ "cell_type": "code", "execution_count": 8, "id": "10f40fda", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-17T16:03:04.531489Z", + "iopub.status.busy": "2026-07-17T16:03:04.531351Z", + "iopub.status.idle": "2026-07-17T16:03:04.625420Z", + "shell.execute_reply": "2026-07-17T16:03:04.624908Z" + } + }, "outputs": [ { "name": "stdout", @@ -617,49 +660,6 @@ "gene_totals" ] }, - { - "cell_type": "markdown", - "id": "b7de3063", - "metadata": {}, - "source": [ - "### A bare AnnData, without Celldega's cat/color bookkeeping\n", - "\n", - "`calc_signature` already returns a ready-to-use `AnnData` in\n", - "`nbhd.mod[\"gene_cell_free\"]` (with `n_transcripts`, `cat`, `color` metadata\n", - "attached). If you already have your own entity-by-gene DataFrame -- built by\n", - "hand, or from a lower-level function directly -- `celldega.nbhd.df_to_anndata`\n", - "wraps it as a plain `AnnData` (`obs` = the DataFrame's index, `var` = its\n", - "columns, `X` = its values), with no normalization, PCA, neighbors, or\n", - "clustering computed." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "7ec22ce0", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "AnnData object with n_obs × n_vars = 120 × 6" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_gene_counts = pd.DataFrame(\n", - " nbhd_series[3.0].mod[\"gene_cell_free\"].X,\n", - " index=nbhd_series[3.0].mod[\"gene_cell_free\"].obs_names,\n", - " columns=nbhd_series[3.0].mod[\"gene_cell_free\"].var_names,\n", - ")\n", - "adata_bare = dega.nbhd.df_to_anndata(df_gene_counts)\n", - "adata_bare" - ] - }, { "cell_type": "markdown", "id": "081a93dd", @@ -675,15 +675,28 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "4a21421e", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-17T16:03:04.627620Z", + "iopub.status.busy": "2026-07-17T16:03:04.627503Z", + "iopub.status.idle": "2026-07-17T16:03:04.803338Z", + "shell.execute_reply": "2026-07-17T16:03:04.802774Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Calculating neighborhood-by-gene (cell-free, streaming)\n", + "Calculating neighborhood-by-gene (cell-free, streaming)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "gdf_trx and data_dir paths agree\n" ] }, @@ -737,9 +750,16 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "id": "f4ec2540", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-17T16:03:04.805411Z", + "iopub.status.busy": "2026-07-17T16:03:04.805282Z", + "iopub.status.idle": "2026-07-17T16:03:15.035240Z", + "shell.execute_reply": "2026-07-17T16:03:15.034300Z" + } + }, "outputs": [ { "name": "stderr", @@ -750,14 +770,12 @@ ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jishar/Documents/celldega/dega/lib/python3.12/site-packages/scanpy/plotting/_utils.py:364: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " plt.show()\n" + ] } ], "source": [ @@ -797,21 +815,17 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "id": "1a864fad", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-17T16:03:15.037358Z", + "iopub.status.busy": "2026-07-17T16:03:15.037212Z", + "iopub.status.idle": "2026-07-17T16:03:15.084565Z", + "shell.execute_reply": "2026-07-17T16:03:15.083954Z" } - ], + }, + "outputs": [], "source": [ "n_clusters = {radius: adata.obs[\"leiden\"].nunique() for radius, adata in adatas.items()}\n", "\n", @@ -844,7 +858,7 @@ "| `gdf_cells` / `gdf_cells2` (parsed from `..._Expanded_5um_cell_contour_coords.csv`) | `gdf_cells` passed to `calc_expansion` |\n", "| `expand_nuclei_within_cell(nuclei_gdf, expand_um)` loop building `nuclei_gdfs = {\"original\": ..., \"expanded_0_5um\": ..., ...}` | `nbhd_series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[0, 0.5, 1, 1.5, 2, 2.5, 3])` |\n", "| `assign_trx_to_entity_streaming_parquet_optimized(trx_parquet_path, entity_gdf, x_col=\"x\", y_col=\"y\", gene_col=\"name\", batch_size=1_000_000)` + manual `pivot_table` per radius | `nbhd.calc_signature(by=\"cell-free\", gdf_trx=gdf_trx, feature_col=\"name\")` per radius (or `data_dir=` for a Xenium-convention file, streamed internally) |\n", - "| Per-radius `pd.read_parquet(..._nuclei_by_gene.parquet)` -> `AnnData` (e.g. `ad.AnnData(X=nbg)`) | `nbhd.mod[\"gene_cell_free\"]` (already an `AnnData`), or `dega.nbhd.df_to_anndata(your_own_df)` for a bare one with no Celldega bookkeeping |\n", + "| Per-radius `pd.read_parquet(..._nuclei_by_gene.parquet)` -> `AnnData` (e.g. `ad.AnnData(X=nbg)`) | `nbhd.mod[\"gene_cell_free\"]` (already an `AnnData`) |\n", "| Per-radius `adata.write(...h5ad)` | `nbhd.mod[\"gene_cell_free\"].write_h5ad(...)`, or persist the whole collection (geometry + all modalities) with `nbhd.write(\"radius.h5mu\")` |\n", "| `safe_polygon`, `simple_format`, `transform_polygon`, `make_column_names_unique_fast` helper functions | available as `celldega.nbhd.safe_polygon` / `simple_format` / `transform_polygon` / `make_column_names_unique_fast`, unchanged -- not otherwise used in this notebook |\n", "\n", diff --git a/src/celldega/nbhd/__init__.py b/src/celldega/nbhd/__init__.py index cf50c14c..339a679f 100644 --- a/src/celldega/nbhd/__init__.py +++ b/src/celldega/nbhd/__init__.py @@ -10,7 +10,6 @@ _get_df_cell, _get_gdf_cell, _get_gdf_trx, - df_to_anndata, make_column_names_unique_fast, safe_polygon, simple_format, @@ -27,7 +26,6 @@ "_get_gdf_trx", "alpha_shape", "alpha_shape_cell_clusters", - "df_to_anndata", "filter_alpha_shapes", "generate_hextile", "hextile_niche", diff --git a/src/celldega/nbhd/neighborhoods.py b/src/celldega/nbhd/neighborhoods.py index 5ceff141..3eb9ab0a 100644 --- a/src/celldega/nbhd/neighborhoods.py +++ b/src/celldega/nbhd/neighborhoods.py @@ -21,7 +21,6 @@ from scipy import sparse from celldega.nbhd.collection import NeighborhoodCollection -from celldega.nbhd.utils import df_to_anndata def _nbhd_geometry_for_join(gdf_nbhd: gpd.GeoDataFrame, nbhd_col: str) -> gpd.GeoDataFrame: @@ -123,7 +122,14 @@ def _calc_nbhd_by_gene( # Reindex to preserve order df_result = df_result.reindex(filtered_gdf[nbhd_col]).fillna(0) - adata_nbg = df_to_anndata(df_result) + # Build AnnData + adata_nbg = AnnData( + X=df_result.values, + obs=pd.DataFrame(index=df_result.index), + var=pd.DataFrame(index=df_result.columns), + ) + + # Add cell counts adata_nbg.obs["n_cells"] = [cell_counts.get(n, 0) for n in adata_nbg.obs.index] elif by == "cell-free": @@ -168,7 +174,14 @@ def _calc_nbhd_by_gene( filtered_gdf = gdf_nbhd[gdf_nbhd[nbhd_col].isin(valid_nbhds)].reset_index(drop=True) - adata_nbg = df_to_anndata(df_result) + # Build AnnData + adata_nbg = AnnData( + X=df_result.values, + obs=pd.DataFrame(index=df_result.index), + var=pd.DataFrame(index=df_result.columns), + ) + + # Add transcript counts adata_nbg.obs["n_transcripts"] = trx_counts.loc[valid_nbhds].values else: diff --git a/src/celldega/nbhd/utils.py b/src/celldega/nbhd/utils.py index e00efd51..b088ef09 100644 --- a/src/celldega/nbhd/utils.py +++ b/src/celldega/nbhd/utils.py @@ -6,7 +6,6 @@ from typing import Any # Third-party imports -from anndata import AnnData import geopandas as gpd import numpy as np import pandas as pd @@ -196,18 +195,3 @@ def make_column_names_unique_fast(df: pd.DataFrame) -> pd.DataFrame: df.columns = new_cols return df - - -def df_to_anndata(df: pd.DataFrame) -> AnnData: - """ - Wrap a matrix DataFrame as a plain AnnData: `obs` = `df.index`, `var` = - `df.columns`, `X` = `df.values`. No normalization, filtering, or clustering - is computed -- just the container, e.g. for an entity-by-gene count table - (obs = neighborhoods/nuclei, var = genes) so you can run your own scanpy - pipeline from there. - """ - return AnnData( - X=df.values, - obs=pd.DataFrame(index=df.index), - var=pd.DataFrame(index=df.columns), - ) diff --git a/tests/unit/test_nbhd/test_utils.py b/tests/unit/test_nbhd/test_utils.py index 533b9105..74beaa2d 100644 --- a/tests/unit/test_nbhd/test_utils.py +++ b/tests/unit/test_nbhd/test_utils.py @@ -2,7 +2,6 @@ from shapely.geometry import Polygon from celldega.nbhd import ( - df_to_anndata, make_column_names_unique_fast, safe_polygon, simple_format, @@ -36,19 +35,3 @@ def test_make_column_names_unique_fast_dedupes_columns(): df = pd.DataFrame([[1, 2, 3]], columns=["gene", "gene", "gene"]) result = make_column_names_unique_fast(df) assert list(result.columns) == ["gene", "gene_1", "gene_2"] - - -def test_df_to_anndata_wraps_matrix_without_extra_computation(): - df = pd.DataFrame( - [[1, 2], [3, 4]], - index=["nbhd_1", "nbhd_2"], - columns=["GeneA", "GeneB"], - ) - - adata = df_to_anndata(df) - - assert list(adata.obs_names) == ["nbhd_1", "nbhd_2"] - assert list(adata.var_names) == ["GeneA", "GeneB"] - assert adata.X.tolist() == [[1, 2], [3, 4]] - assert "X_pca" not in adata.obsm - assert "neighbors" not in adata.uns From fd8fa63e661d39d0d854c87e369a5d45dbcc62b6 Mon Sep 17 00:00:00 2001 From: Jaspreet Ishar Date: Fri, 17 Jul 2026 12:24:51 -0400 Subject: [PATCH 08/14] removed unnecessary gdf_trx arg; cleaned the example notebook --- .../Nuclear_Expansion_Radial_Buffering.ipynb | 399 ++++-------------- src/celldega/nbhd/collection.py | 29 +- src/celldega/nbhd/neighborhoods.py | 67 +-- tests/unit/test_nbhd/test_expansion.py | 33 +- 4 files changed, 128 insertions(+), 400 deletions(-) diff --git a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb index cdbde706..8051c07b 100644 --- a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb +++ b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb @@ -24,14 +24,13 @@ " observation axis so results stay directly comparable across radii. Nucleus ->\n", " cell is just the running example below -- the same method works for any other\n", " pair of nested per-entity geometries.\n", - "- **`NeighborhoodCollection.calc_signature(by=\"cell-free\", ...)`** replaces the\n", - " custom `assign_trx_to_entity_streaming_parquet_optimized` + manual pivot. It\n", - " spatially joins transcripts to each radius's polygons and returns a cell-by-gene\n", - " `AnnData`, ready for the usual scanpy pipeline -- either from an in-memory\n", - " `GeoDataFrame` (`gdf_trx=`, custom column names) or from a Xenium-convention\n", - " `transcripts.parquet` directory (`data_dir=`), which is internally streamed in\n", - " batches so a whole-tile file doesn't need to be loaded into memory once per\n", - " radius.\n", + "- **`NeighborhoodCollection.calc_signature(by=\"cell-free\", data_dir=...)`**\n", + " replaces the custom `assign_trx_to_entity_streaming_parquet_optimized` +\n", + " manual pivot. It always streams a `transcripts.parquet` directory in batches\n", + " (narrowing candidate entities per batch with a spatial index before testing\n", + " exact polygons), so a whole-tile file doesn't need to be loaded into memory\n", + " once per radius; `feature_col`/`x_col`/`y_col` name its gene/x/y columns\n", + " (Xenium convention by default, but overridable for any column layout).\n", "\n", "Because the real instrument files (OME-TIFF, per-dataset contour CSVs, a full-tile\n", "`transcripts.parquet`) aren't available here, this notebook builds a small\n", @@ -47,10 +46,10 @@ "id": "4d0f46b0", "metadata": { "execution": { - "iopub.execute_input": "2026-07-17T16:03:00.229534Z", - "iopub.status.busy": "2026-07-17T16:03:00.229384Z", - "iopub.status.idle": "2026-07-17T16:03:03.406991Z", - "shell.execute_reply": "2026-07-17T16:03:03.406458Z" + "iopub.execute_input": "2026-07-17T16:22:58.565241Z", + "iopub.status.busy": "2026-07-17T16:22:58.565051Z", + "iopub.status.idle": "2026-07-17T16:23:01.914699Z", + "shell.execute_reply": "2026-07-17T16:23:01.913959Z" } }, "outputs": [ @@ -72,7 +71,6 @@ "import numpy as np\n", "import pandas as pd\n", "import geopandas as gpd\n", - "import scanpy as sc\n", "import matplotlib.pyplot as plt\n", "from shapely.geometry import Point\n", "\n", @@ -100,10 +98,10 @@ "id": "5f2394c8", "metadata": { "execution": { - "iopub.execute_input": "2026-07-17T16:03:03.409076Z", - "iopub.status.busy": "2026-07-17T16:03:03.408595Z", - "iopub.status.idle": "2026-07-17T16:03:03.422511Z", - "shell.execute_reply": "2026-07-17T16:03:03.421980Z" + "iopub.execute_input": "2026-07-17T16:23:01.917140Z", + "iopub.status.busy": "2026-07-17T16:23:01.916836Z", + "iopub.status.idle": "2026-07-17T16:23:01.930026Z", + "shell.execute_reply": "2026-07-17T16:23:01.929601Z" } }, "outputs": [ @@ -175,10 +173,10 @@ "id": "85a6f217", "metadata": { "execution": { - "iopub.execute_input": "2026-07-17T16:03:03.424335Z", - "iopub.status.busy": "2026-07-17T16:03:03.424229Z", - "iopub.status.idle": "2026-07-17T16:03:03.437671Z", - "shell.execute_reply": "2026-07-17T16:03:03.437157Z" + "iopub.execute_input": "2026-07-17T16:23:01.932091Z", + "iopub.status.busy": "2026-07-17T16:23:01.931913Z", + "iopub.status.idle": "2026-07-17T16:23:01.945604Z", + "shell.execute_reply": "2026-07-17T16:23:01.945131Z" } }, "outputs": [ @@ -276,10 +274,10 @@ "id": "658414fd", "metadata": { "execution": { - "iopub.execute_input": "2026-07-17T16:03:03.439190Z", - "iopub.status.busy": "2026-07-17T16:03:03.439074Z", - "iopub.status.idle": "2026-07-17T16:03:03.528128Z", - "shell.execute_reply": "2026-07-17T16:03:03.527579Z" + "iopub.execute_input": "2026-07-17T16:23:01.947104Z", + "iopub.status.busy": "2026-07-17T16:23:01.946997Z", + "iopub.status.idle": "2026-07-17T16:23:02.053360Z", + "shell.execute_reply": "2026-07-17T16:23:02.052696Z" } }, "outputs": [ @@ -311,10 +309,10 @@ "id": "140c06c5", "metadata": { "execution": { - "iopub.execute_input": "2026-07-17T16:03:03.529649Z", - "iopub.status.busy": "2026-07-17T16:03:03.529527Z", - "iopub.status.idle": "2026-07-17T16:03:04.368773Z", - "shell.execute_reply": "2026-07-17T16:03:04.368242Z" + "iopub.execute_input": "2026-07-17T16:23:02.055159Z", + "iopub.status.busy": "2026-07-17T16:23:02.055039Z", + "iopub.status.idle": "2026-07-17T16:23:02.892960Z", + "shell.execute_reply": "2026-07-17T16:23:02.892433Z" } }, "outputs": [], @@ -334,77 +332,6 @@ "fig.tight_layout()" ] }, - { - "cell_type": "markdown", - "id": "29cf4d67", - "metadata": {}, - "source": [ - "### Working in pixel space\n", - "\n", - "Segmentation pipelines often store nucleus/cell polygons in image-pixel\n", - "coordinates rather than microns -- e.g. the original notebook builds them via\n", - "`vertex_x * high_res_scale`, where `high_res_scale = 1 / scaling_factor` is a\n", - "pixels-per-micron factor (`scaling_factor` itself, from `PhysicalSizeX`, is\n", - "microns-per-pixel). `calc_expansion` needs to know that scale to convert\n", - "`radii_um` into the geometry's own units before buffering.\n", - "\n", - "Pass whichever factor your pipeline already has on hand:\n", - "\n", - "- `scale_um_per_pixel=` for a microns-per-pixel factor (e.g. OME-XML `PhysicalSizeX`) -- a micron distance is *divided* by this to get pixels.\n", - "- `pixels_per_micron=` for the reciprocal, pixels-per-micron convention (e.g. `high_res_scale` above) -- a micron distance is *multiplied* by this to get pixels, matching `buffer_dist = expand_um * high_res_scale` directly.\n", - "\n", - "Both are shown below on the same nuclei, scaled up into a toy \"pixel\" coordinate\n", - "space, and confirmed to reproduce the same real-world (micron) areas as the\n", - "micron-space series computed earlier." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "2f1d3bf5", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-17T16:03:04.371171Z", - "iopub.status.busy": "2026-07-17T16:03:04.371005Z", - "iopub.status.idle": "2026-07-17T16:03:04.478927Z", - "shell.execute_reply": "2026-07-17T16:03:04.478287Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "pixel-space geometry + pixels_per_micron reproduces the micron-space result\n" - ] - } - ], - "source": [ - "high_res_scale = 4.0 # pixels per micron, e.g. derived from an OME-XML PhysicalSizeX\n", - "\n", - "# stand-in for \"already-in-pixel-space\" geometry, as produced by a real\n", - "# segmentation pipeline's `vertex_x * high_res_scale` step\n", - "gdf_nuclei_px = gdf_nuclei.copy()\n", - "gdf_nuclei_px[\"geometry\"] = gdf_nuclei_px.geometry.scale(high_res_scale, high_res_scale, origin=(0, 0))\n", - "gdf_cells_px = gdf_cells.copy()\n", - "gdf_cells_px[\"geometry\"] = gdf_cells_px.geometry.scale(high_res_scale, high_res_scale, origin=(0, 0))\n", - "\n", - "nbhd_nuclei_px = dega.nbhd.NeighborhoodCollection(\n", - " gdf=gdf_nuclei_px, nbhd_type=\"nucleus\", nbhd_col=\"cell_id\"\n", - ")\n", - "nbhd_series_px = nbhd_nuclei_px.calc_expansion(\n", - " gdf_cells_px,\n", - " radii_um=radii_um,\n", - " is_pixel_space=True,\n", - " pixels_per_micron=high_res_scale, # same variable your own notebook already computes\n", - ")\n", - "\n", - "micron_areas = pd.Series({r: nbhd.gdf[\"area_um2\"].sum() for r, nbhd in nbhd_series.items()}).sort_index()\n", - "pixel_areas = pd.Series({r: nbhd.gdf[\"area_um2\"].sum() for r, nbhd in nbhd_series_px.items()}).sort_index()\n", - "pd.testing.assert_series_equal(micron_areas, pixel_areas, check_names=False, rtol=1e-6)\n", - "print(\"pixel-space geometry + pixels_per_micron reproduces the micron-space result\")" - ] - }, { "cell_type": "markdown", "id": "05b9882a", @@ -423,21 +350,21 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "09ef320b", "metadata": { "execution": { - "iopub.execute_input": "2026-07-17T16:03:04.480763Z", - "iopub.status.busy": "2026-07-17T16:03:04.480632Z", - "iopub.status.idle": "2026-07-17T16:03:04.529835Z", - "shell.execute_reply": "2026-07-17T16:03:04.529401Z" + "iopub.execute_input": "2026-07-17T16:23:02.895272Z", + "iopub.status.busy": "2026-07-17T16:23:02.895127Z", + "iopub.status.idle": "2026-07-17T16:23:03.008410Z", + "shell.execute_reply": "2026-07-17T16:23:03.007798Z" } }, "outputs": [ { "data": { "text/plain": [ - "((5490, 2),\n", + "((5490, 3),\n", " {np.str_('CytoGene1'): 1243,\n", " np.str_('CytoGene2'): 1157,\n", " np.str_('NucGene1'): 984,\n", @@ -446,7 +373,7 @@ " 'MarkerB': 625})" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -480,8 +407,12 @@ " trx_rows.append({\"x\": xy[0], \"y\": xy[1], \"name\": marker_gene})\n", "\n", "df_trx = pd.DataFrame(trx_rows)\n", - "gdf_trx = gpd.GeoDataFrame(df_trx[[\"name\"]], geometry=gpd.points_from_xy(df_trx[\"x\"], df_trx[\"y\"]))\n", - "gdf_trx.shape, gdf_trx[\"name\"].value_counts().to_dict()" + "\n", + "# calc_signature's cell-free mode always streams from a transcripts.parquet on\n", + "# disk, so persist these to a directory rather than keeping them in memory\n", + "trx_dir = tempfile.mkdtemp()\n", + "df_trx.to_parquet(f\"{trx_dir}/transcripts.parquet\")\n", + "df_trx.shape, df_trx[\"name\"].value_counts().to_dict()" ] }, { @@ -491,31 +422,27 @@ "source": [ "## 5. Cell-by-gene matrix at every radius\n", "\n", - "`calc_signature(by=\"cell-free\", ...)` spatially joins transcripts to each\n", - "radius's polygons and returns transcript counts as an `AnnData` in\n", + "`calc_signature(by=\"cell-free\", data_dir=...)` spatially joins transcripts to\n", + "each radius's polygons and returns transcript counts as an `AnnData` in\n", "`nbhd.mod[\"gene_cell_free\"]` -- one call per radius, no custom pivot code\n", - "needed. It accepts the same transcript source in two ways:\n", - "\n", - "- **`gdf_trx=`**: an in-memory `GeoDataFrame` of transcript points with a\n", - " `feature_col` gene column of your choosing -- what this notebook's synthetic,\n", - " custom-column (`x`/`y`/`name`) transcripts use below.\n", - "- **`data_dir=`**: a directory with a Xenium-convention `transcripts.parquet`\n", - " (`feature_name`/`x_location`/`y_location`). This path is streamed in batches\n", - " internally (narrowing candidate entities per batch with a spatial index\n", - " before testing exact polygons), so a whole-tile file doesn't need to be\n", - " loaded into memory once per radius -- see the sanity-check cell below." + "needed. `data_dir` points to a directory containing a `transcripts.parquet`;\n", + "`feature_col`/`x_col`/`y_col` name its gene/x/y columns (Xenium convention by\n", + "default, overridden below for this notebook's custom `name`/`x`/`y` columns).\n", + "The file is always streamed in batches internally -- narrowing candidate\n", + "entities per batch with a spatial index before testing exact polygons -- so a\n", + "whole-tile file doesn't need to be loaded into memory once per radius." ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "10f40fda", "metadata": { "execution": { - "iopub.execute_input": "2026-07-17T16:03:04.531489Z", - "iopub.status.busy": "2026-07-17T16:03:04.531351Z", - "iopub.status.idle": "2026-07-17T16:03:04.625420Z", - "shell.execute_reply": "2026-07-17T16:03:04.624908Z" + "iopub.execute_input": "2026-07-17T16:23:03.010401Z", + "iopub.status.busy": "2026-07-17T16:23:03.010273Z", + "iopub.status.idle": "2026-07-17T16:23:03.244960Z", + "shell.execute_reply": "2026-07-17T16:23:03.244436Z" } }, "outputs": [ @@ -523,13 +450,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Calculating neighborhood-by-gene (cell-free, provided gdf_trx)\n", - "Calculating neighborhood-by-gene (cell-free, provided gdf_trx)\n", - "Calculating neighborhood-by-gene (cell-free, provided gdf_trx)\n", - "Calculating neighborhood-by-gene (cell-free, provided gdf_trx)\n", - "Calculating neighborhood-by-gene (cell-free, provided gdf_trx)\n", - "Calculating neighborhood-by-gene (cell-free, provided gdf_trx)\n", - "Calculating neighborhood-by-gene (cell-free, provided gdf_trx)\n" + "Calculating neighborhood-by-gene (cell-free, streaming)\n", + "Calculating neighborhood-by-gene (cell-free, streaming)\n", + "Calculating neighborhood-by-gene (cell-free, streaming)\n", + "Calculating neighborhood-by-gene (cell-free, streaming)\n", + "Calculating neighborhood-by-gene (cell-free, streaming)\n", + "Calculating neighborhood-by-gene (cell-free, streaming)\n", + "Calculating neighborhood-by-gene (cell-free, streaming)\n" ] }, { @@ -640,14 +567,17 @@ "3.0 610.0 571.0 291.0 284.0 984.0 837.0" ] }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "for radius, nbhd in nbhd_series.items():\n", - " nbhd.calc_signature(by=\"cell-free\", gdf_trx=gdf_trx, feature_col=\"name\", drop_missing=False)\n", + " nbhd.calc_signature(\n", + " by=\"cell-free\", data_dir=trx_dir, feature_col=\"name\", x_col=\"x\", y_col=\"y\",\n", + " drop_missing=False,\n", + " )\n", "\n", "gene_totals = pd.DataFrame(\n", " {\n", @@ -660,191 +590,6 @@ "gene_totals" ] }, - { - "cell_type": "markdown", - "id": "081a93dd", - "metadata": {}, - "source": [ - "### `data_dir=` sanity check\n", - "\n", - "`data_dir=` expects a Xenium-convention `transcripts.parquet`\n", - "(`feature_name`/`x_location`/`y_location`) and is internally streamed in\n", - "batches rather than loaded fully into memory. Confirms it agrees with the\n", - "`gdf_trx=` path above, using the radius=3um collection as a spot check." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "4a21421e", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-17T16:03:04.627620Z", - "iopub.status.busy": "2026-07-17T16:03:04.627503Z", - "iopub.status.idle": "2026-07-17T16:03:04.803338Z", - "shell.execute_reply": "2026-07-17T16:03:04.802774Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Calculating neighborhood-by-gene (cell-free, streaming)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "gdf_trx and data_dir paths agree\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jishar/Documents/celldega/dega/lib/python3.12/site-packages/mudata/_core/mudata.py:931: UserWarning: Cannot join columns with the same name because var_names are intersecting.\n", - " warnings.warn(\n" - ] - } - ], - "source": [ - "xenium_dir = tempfile.mkdtemp()\n", - "df_trx.rename(columns={\"name\": \"feature_name\", \"x\": \"x_location\", \"y\": \"y_location\"}).to_parquet(\n", - " f\"{xenium_dir}/transcripts.parquet\"\n", - ")\n", - "\n", - "nbhd_check = nbhd_series[3.0]\n", - "nbhd_check.calc_signature(\n", - " by=\"cell-free\", data_dir=xenium_dir,\n", - " modality_name=\"gene_cell_free_via_data_dir\", drop_missing=False,\n", - ")\n", - "\n", - "in_memory = pd.DataFrame(\n", - " nbhd_check.mod[\"gene_cell_free\"].X, columns=nbhd_check.mod[\"gene_cell_free\"].var_names,\n", - " index=nbhd_check.mod[\"gene_cell_free\"].obs_names,\n", - ")\n", - "via_data_dir = pd.DataFrame(\n", - " nbhd_check.mod[\"gene_cell_free_via_data_dir\"].X,\n", - " columns=nbhd_check.mod[\"gene_cell_free_via_data_dir\"].var_names,\n", - " index=nbhd_check.mod[\"gene_cell_free_via_data_dir\"].obs_names,\n", - ")\n", - "assert in_memory.equals(via_data_dir[in_memory.columns])\n", - "print(\"gdf_trx and data_dir paths agree\")" - ] - }, - { - "cell_type": "markdown", - "id": "0566b5a3", - "metadata": {}, - "source": [ - "## 6. Downstream analysis per radius\n", - "\n", - "The same scanpy pipeline as the original notebook (normalize, log1p, scale, PCA,\n", - "neighbors, Leiden, UMAP), run once per radius on `nbhd.mod[\"gene_cell_free\"]`.\n", - "Pipeline parameters (`n_comps`, `n_neighbors`) are scaled down here for this small\n", - "synthetic demo -- use your usual settings (e.g. `n_top_genes=5000`,\n", - "`n_neighbors=30`) on real data." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "f4ec2540", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-17T16:03:04.805411Z", - "iopub.status.busy": "2026-07-17T16:03:04.805282Z", - "iopub.status.idle": "2026-07-17T16:03:15.035240Z", - "shell.execute_reply": "2026-07-17T16:03:15.034300Z" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jishar/Documents/celldega/dega/lib/python3.12/site-packages/scipy/sparse/_index.py:216: SparseEfficiencyWarning: Changing the sparsity structure of a csr_matrix is expensive. lil and dok are more efficient.\n", - " self._set_arrayXarray(i, j, x)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jishar/Documents/celldega/dega/lib/python3.12/site-packages/scanpy/plotting/_utils.py:364: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", - " plt.show()\n" - ] - } - ], - "source": [ - "adatas = {}\n", - "for radius, nbhd in nbhd_series.items():\n", - " adata = nbhd.mod[\"gene_cell_free\"].copy()\n", - " adata.X = adata.X.astype(\"float32\")\n", - " adata.obs[\"cell_type\"] = df_cell_meta.loc[adata.obs_names.astype(int), \"cell_type\"].to_numpy()\n", - "\n", - " sc.pp.normalize_total(adata)\n", - " sc.pp.log1p(adata)\n", - " sc.pp.scale(adata, max_value=10)\n", - "\n", - " n_comps = min(5, adata.n_vars - 1, adata.n_obs - 1)\n", - " sc.tl.pca(adata, n_comps=n_comps, random_state=0)\n", - " sc.pp.neighbors(adata, n_neighbors=10, use_rep=\"X_pca\", random_state=0)\n", - " sc.tl.leiden(adata, flavor=\"igraph\", key_added=\"leiden\", resolution=0.5, random_state=0)\n", - " sc.tl.umap(adata, random_state=0)\n", - "\n", - " adatas[radius] = adata\n", - "\n", - "sc.pl.umap(adatas[3.0], color=[\"leiden\", \"cell_type\"], title=[f\"radius=3um: leiden\", f\"radius=3um: true cell_type\"])" - ] - }, - { - "cell_type": "markdown", - "id": "62d274dc", - "metadata": {}, - "source": [ - "## 7. Compare across radii\n", - "\n", - "Nuclear genes are already fully captured at radius 0; cytoplasmic and marker genes\n", - "climb steadily as the buffer reaches further into the cell. Clustering into the two\n", - "true cell types only stabilizes once enough cytoplasmic/marker signal is\n", - "captured." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "1a864fad", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-17T16:03:15.037358Z", - "iopub.status.busy": "2026-07-17T16:03:15.037212Z", - "iopub.status.idle": "2026-07-17T16:03:15.084565Z", - "shell.execute_reply": "2026-07-17T16:03:15.083954Z" - } - }, - "outputs": [], - "source": [ - "n_clusters = {radius: adata.obs[\"leiden\"].nunique() for radius, adata in adatas.items()}\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(11, 4))\n", - "axes[0].plot(gene_totals.index, gene_totals[\"NucGene1\"] + gene_totals[\"NucGene2\"], \"o-\", label=\"nuclear genes\")\n", - "axes[0].plot(gene_totals.index, gene_totals[\"CytoGene1\"] + gene_totals[\"CytoGene2\"], \"o-\", label=\"cytoplasmic genes\")\n", - "axes[0].plot(gene_totals.index, gene_totals[\"MarkerA\"] + gene_totals[\"MarkerB\"], \"o-\", label=\"marker genes\")\n", - "axes[0].set_xlabel(\"buffer radius (um)\")\n", - "axes[0].set_ylabel(\"total transcripts captured\")\n", - "axes[0].legend()\n", - "axes[0].set_title(\"Transcript capture vs. nuclear buffer radius\")\n", - "\n", - "axes[1].plot(list(n_clusters.keys()), list(n_clusters.values()), \"o-\", color=\"crimson\")\n", - "axes[1].set_xlabel(\"buffer radius (um)\")\n", - "axes[1].set_ylabel(\"n leiden clusters\")\n", - "axes[1].set_title(\"Cluster count vs. nuclear buffer radius\")\n", - "fig.tight_layout()" - ] - }, { "cell_type": "markdown", "id": "fa4b647b-4dd6-42b0-9231-5896987aaa62", @@ -857,16 +602,18 @@ "| `gdf_nuclei_original` (parsed from `..._nuclei_contour_coords.csv`) | `gdf_nuclei` -> `NeighborhoodCollection(gdf=gdf_nuclei, nbhd_col=\"cell_id\")` |\n", "| `gdf_cells` / `gdf_cells2` (parsed from `..._Expanded_5um_cell_contour_coords.csv`) | `gdf_cells` passed to `calc_expansion` |\n", "| `expand_nuclei_within_cell(nuclei_gdf, expand_um)` loop building `nuclei_gdfs = {\"original\": ..., \"expanded_0_5um\": ..., ...}` | `nbhd_series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[0, 0.5, 1, 1.5, 2, 2.5, 3])` |\n", - "| `assign_trx_to_entity_streaming_parquet_optimized(trx_parquet_path, entity_gdf, x_col=\"x\", y_col=\"y\", gene_col=\"name\", batch_size=1_000_000)` + manual `pivot_table` per radius | `nbhd.calc_signature(by=\"cell-free\", gdf_trx=gdf_trx, feature_col=\"name\")` per radius (or `data_dir=` for a Xenium-convention file, streamed internally) |\n", + "| `assign_trx_to_entity_streaming_parquet_optimized(trx_parquet_path, entity_gdf, x_col=\"x\", y_col=\"y\", gene_col=\"name\", batch_size=1_000_000)` + manual `pivot_table` per radius | `nbhd.calc_signature(by=\"cell-free\", data_dir=trx_dir, feature_col=\"name\", x_col=\"x\", y_col=\"y\")` per radius -- same batched-parquet-plus-spatial-index mechanics, now built in and always used |\n", "| Per-radius `pd.read_parquet(..._nuclei_by_gene.parquet)` -> `AnnData` (e.g. `ad.AnnData(X=nbg)`) | `nbhd.mod[\"gene_cell_free\"]` (already an `AnnData`) |\n", "| Per-radius `adata.write(...h5ad)` | `nbhd.mod[\"gene_cell_free\"].write_h5ad(...)`, or persist the whole collection (geometry + all modalities) with `nbhd.write(\"radius.h5mu\")` |\n", "| `safe_polygon`, `simple_format`, `transform_polygon`, `make_column_names_unique_fast` helper functions | available as `celldega.nbhd.safe_polygon` / `simple_format` / `transform_polygon` / `make_column_names_unique_fast`, unchanged -- not otherwise used in this notebook |\n", "\n", - "`calc_signature`'s `gdf_trx=` path loads the whole transcript table into memory\n", - "for one spatial join -- fine once it's already loaded or pre-filtered. Its\n", - "`data_dir=` path (Xenium convention) is streamed in batches instead, so a\n", - "whole-tile `transcripts.parquet` re-joined once per radius across an expansion\n", - "series doesn't need to fit in memory -- see the sanity-check cell above." + "`calc_signature`'s `by=\"cell-free\"` mode always streams from a\n", + "`transcripts.parquet` under `data_dir=` in batches (narrowing candidate\n", + "entities per batch with a spatial index before testing exact polygons), so a\n", + "whole-tile file re-joined once per radius across an expansion series doesn't\n", + "need to fit in memory. `feature_col`/`x_col`/`y_col` name its columns --\n", + "Xenium convention (`feature_name`/`x_location`/`y_location`) by default, or\n", + "whatever your own `transcripts.parquet` uses." ] }, { diff --git a/src/celldega/nbhd/collection.py b/src/celldega/nbhd/collection.py index 0309c3f8..fb2a33e8 100644 --- a/src/celldega/nbhd/collection.py +++ b/src/celldega/nbhd/collection.py @@ -376,7 +376,7 @@ def calc_expansion( >>> nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_col="cell_id") >>> series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[0, 1, 2, 3]) >>> for radius, nbhd in series.items(): - ... nbhd.calc_signature(by="cell-free", gdf_trx=gdf_trx, drop_missing=False) + ... nbhd.calc_signature(by="cell-free", data_dir=data_dir, drop_missing=False) """ from celldega.nbhd.expansion import _calc_expansion @@ -543,7 +543,6 @@ def calc_signature( modality_name: str | None = None, min_cells: int = 1, data_dir: str | None = None, - gdf_trx: gpd.GeoDataFrame | None = None, feature_col: str = "feature_name", x_col: str = "x_location", y_col: str = "y_location", @@ -564,19 +563,14 @@ def calc_signature( min_cells: Minimum cells/transcripts for a neighborhood to be kept. data_dir: Directory with a ``transcripts.parquet`` (columns named ``feature_col``/``x_col``/``y_col``, Xenium convention by - default; streamed in batches); defaults to ``self.data_dir``. - Used for ``by="cell-free"`` when ``gdf_trx`` isn't given. - gdf_trx: Pre-loaded transcript points for ``by="cell-free"`` (custom - column names/paths); takes precedence over ``data_dir``. - feature_col: Gene/feature column — in ``gdf_trx``, or in - ``data_dir``'s ``transcripts.parquet`` (default - ``"feature_name"``). + default), streamed in batches; defaults to ``self.data_dir``. + Required for ``by="cell-free"``. + feature_col: Gene/feature column in ``data_dir``'s + ``transcripts.parquet`` (default ``"feature_name"``). x_col: Transcript x-coordinate column in ``data_dir``'s - ``transcripts.parquet`` (default ``"x_location"``; ignored for - ``gdf_trx``). + ``transcripts.parquet`` (default ``"x_location"``). y_col: Transcript y-coordinate column in ``data_dir``'s - ``transcripts.parquet`` (default ``"y_location"``; ignored for - ``gdf_trx``). + ``transcripts.parquet`` (default ``"y_location"``). drop_missing: When ``True`` (default), neighborhoods with fewer than ``min_cells`` cells (or transcripts) are removed from the collection entirely. When ``False``, the collection keeps all @@ -587,8 +581,8 @@ def calc_signature( ``None`` — the modality is attached to ``self.mod``. Raises: - ValueError: If ``adata`` is missing for ``by="cell"``, or neither - ``data_dir`` nor ``gdf_trx`` is given for ``by="cell-free"``. + ValueError: If ``adata`` is missing for ``by="cell"``, or + ``data_dir`` is missing for ``by="cell-free"``. """ from celldega.nbhd.neighborhoods import ( _calc_nbhd_by_gene, @@ -601,15 +595,14 @@ def calc_signature( resolved_data_dir = data_dir if data_dir is not None else self.data_dir if by == "cell" and adata is None: raise ValueError("adata is required when by='cell'") - if by == "cell-free" and gdf_trx is None and resolved_data_dir is None: - raise ValueError("data_dir or gdf_trx is required when by='cell-free'") + if by == "cell-free" and resolved_data_dir is None: + raise ValueError("data_dir is required when by='cell-free'") modality = _calc_nbhd_by_gene( self.gdf, by=by, adata=adata, data_dir=resolved_data_dir, - gdf_trx=gdf_trx, feature_col=feature_col, x_col=x_col, y_col=y_col, diff --git a/src/celldega/nbhd/neighborhoods.py b/src/celldega/nbhd/neighborhoods.py index 3eb9ab0a..7aa4b60a 100644 --- a/src/celldega/nbhd/neighborhoods.py +++ b/src/celldega/nbhd/neighborhoods.py @@ -32,7 +32,6 @@ def _calc_nbhd_by_gene( by: str = "cell", adata: AnnData | None = None, data_dir: str | None = None, - gdf_trx: gpd.GeoDataFrame | None = None, feature_col: str = "feature_name", x_col: str = "x_location", y_col: str = "y_location", @@ -47,30 +46,24 @@ def _calc_nbhd_by_gene( `by="cell"` averages cell-level expression per neighborhood; `by="cell-free"` counts transcripts per neighborhood, streamed in batches from `data_dir`'s - `transcripts.parquet`, or from a pre-loaded `gdf_trx`. + `transcripts.parquet`. Parameters ---------- gdf_nbhd : gpd.GeoDataFrame Neighborhood geometries, with a `geometry` column and a `nbhd_col` id column. by : str, default "cell" - "cell" (requires `adata`) or "cell-free" (requires `data_dir` or `gdf_trx`). + "cell" (requires `adata`) or "cell-free" (requires `data_dir`). adata : AnnData, optional Cell-level data with spatial coordinates in `obsm["spatial"]`; required for `by="cell"`. data_dir : str, optional Directory with a `transcripts.parquet` (columns named `feature_col`/ - `x_col`/`y_col`, Xenium convention by default). Used for `by="cell-free"` - when `gdf_trx` isn't given. - gdf_trx : gpd.GeoDataFrame, optional - Pre-loaded transcript points for `by="cell-free"` (custom column - names/paths); a `geometry` column plus a gene column named `feature_col`. - Takes precedence over `data_dir`. + `x_col`/`y_col`, Xenium convention by default). Required for `by="cell-free"`. feature_col : str, default "feature_name" - Gene/feature column — in `gdf_trx`, or in `data_dir`'s `transcripts.parquet`. + Gene/feature column in `data_dir`'s `transcripts.parquet`. x_col, y_col : str, default "x_location", "y_location" - Transcript coordinate columns in `data_dir`'s `transcripts.parquet` - (ignored for `gdf_trx`, which is already point geometry). + Transcript coordinate columns in `data_dir`'s `transcripts.parquet`. nbhd_col : str, default "name" Neighborhood id column in `gdf_nbhd`. min_cells : int, default 1 @@ -133,39 +126,25 @@ def _calc_nbhd_by_gene( adata_nbg.obs["n_cells"] = [cell_counts.get(n, 0) for n in adata_nbg.obs.index] elif by == "cell-free": - if gdf_trx is not None: - print("Calculating neighborhood-by-gene (cell-free, provided gdf_trx)") - joined = gdf_trx[[feature_col, "geometry"]].sjoin( - _nbhd_geometry_for_join(gdf_nbhd, nbhd_col), how="left", predicate="within" + if data_dir is None: + raise ValueError("data_dir is required when by='cell-free'") + + print("Calculating neighborhood-by-gene (cell-free, streaming)") + from celldega.nbhd.trx_streaming import _assign_trx_to_entity_streaming_parquet + + df_result = ( + _assign_trx_to_entity_streaming_parquet( + f"{data_dir}/transcripts.parquet", + gdf_nbhd, + id_col=nbhd_col, + x_col=x_col, + y_col=y_col, + gene_col=feature_col, ) - df_result = ( - joined.groupby([nbhd_col, feature_col]) - .size() - .unstack(fill_value=0) - .rename_axis(None, axis=1) - .reindex(gdf_nbhd[nbhd_col]) - .fillna(0) - .astype(int) - ) - elif data_dir is not None: - print("Calculating neighborhood-by-gene (cell-free, streaming)") - from celldega.nbhd.trx_streaming import _assign_trx_to_entity_streaming_parquet - - df_result = ( - _assign_trx_to_entity_streaming_parquet( - f"{data_dir}/transcripts.parquet", - gdf_nbhd, - id_col=nbhd_col, - x_col=x_col, - y_col=y_col, - gene_col=feature_col, - ) - .reindex(gdf_nbhd[nbhd_col]) - .fillna(0) - .astype(int) - ) - else: - raise ValueError("data_dir or gdf_trx is required when by='cell-free'") + .reindex(gdf_nbhd[nbhd_col]) + .fillna(0) + .astype(int) + ) # Filter by min_cells (here it's min transcripts total) trx_counts = df_result.sum(axis=1) diff --git a/tests/unit/test_nbhd/test_expansion.py b/tests/unit/test_nbhd/test_expansion.py index 8c525319..e0397959 100644 --- a/tests/unit/test_nbhd/test_expansion.py +++ b/tests/unit/test_nbhd/test_expansion.py @@ -2,7 +2,7 @@ import numpy as np import pandas as pd import pytest -from shapely.geometry import Point, Polygon +from shapely.geometry import Polygon from celldega.nbhd import NeighborhoodCollection from celldega.nbhd.expansion import _calc_expansion @@ -202,20 +202,26 @@ def test_neighborhood_collection_calc_expansion_returns_series(): assert nbhd.nbhd_type == "expansion" -def test_calc_signature_cell_free_accepts_custom_gdf_trx(): +def test_calc_signature_cell_free_accepts_custom_columns_across_radii(tmp_path): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[0, 5]) - # Custom transcript format: "name" for gene, arbitrary x/y columns already - # converted to points -- exercises the feature_col override end to end. - gdf_trx = gpd.GeoDataFrame( - {"name": ["GeneA", "GeneB", "GeneA"]}, - geometry=[Point(5, 5), Point(1, 1), Point(25, 25)], - ) + # Custom transcript format: "name" for gene, arbitrary x/y columns -- + # exercises the feature_col/x_col/y_col overrides end to end. + pd.DataFrame( + { + "name": ["GeneA", "GeneB", "GeneA"], + "x": [5, 1, 25], + "y": [5, 1, 25], + } + ).to_parquet(tmp_path / "transcripts.parquet") nbhd_r0 = series[0.0] - nbhd_r0.calc_signature(by="cell-free", gdf_trx=gdf_trx, feature_col="name", drop_missing=False) + nbhd_r0.calc_signature( + by="cell-free", data_dir=str(tmp_path), feature_col="name", x_col="x", y_col="y", + drop_missing=False, + ) modality_r0 = nbhd_r0.mod["gene_cell_free"] df_r0 = pd.DataFrame(modality_r0.X, index=modality_r0.obs_names, columns=modality_r0.var_names) # at radius 0 the source polygon doesn't reach (1, 1); only the point inside it counts @@ -225,7 +231,10 @@ def test_calc_signature_cell_free_accepts_custom_gdf_trx(): assert df_r0.loc["c2", "GeneA"] == 1 nbhd_r5 = series[5.0] - nbhd_r5.calc_signature(by="cell-free", gdf_trx=gdf_trx, feature_col="name", drop_missing=False) + nbhd_r5.calc_signature( + by="cell-free", data_dir=str(tmp_path), feature_col="name", x_col="x", y_col="y", + drop_missing=False, + ) modality_r5 = nbhd_r5.mod["gene_cell_free"] df_r5 = pd.DataFrame(modality_r5.X, index=modality_r5.obs_names, columns=modality_r5.var_names) # at radius 5 the source polygon has expanded to the full bound, now capturing (1, 1) too @@ -233,11 +242,11 @@ def test_calc_signature_cell_free_accepts_custom_gdf_trx(): assert df_r5.loc["c1", "GeneB"] == 1 -def test_calc_signature_cell_free_requires_data_dir_or_gdf_trx(): +def test_calc_signature_cell_free_requires_data_dir(): gdf_nuclei, _gdf_cells = _synthetic_nucleus_cell_inputs() nbhd = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") - with pytest.raises(ValueError, match="data_dir or gdf_trx"): + with pytest.raises(ValueError, match="data_dir is required"): nbhd.calc_signature(by="cell-free") From c4190008f4c5d0b84865e59a387ca794c5d843bb Mon Sep 17 00:00:00 2001 From: Jaspreet Ishar Date: Fri, 17 Jul 2026 12:26:54 -0400 Subject: [PATCH 09/14] lint ruff --- tests/unit/test_nbhd/test_expansion.py | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/tests/unit/test_nbhd/test_expansion.py b/tests/unit/test_nbhd/test_expansion.py index e0397959..27370aa6 100644 --- a/tests/unit/test_nbhd/test_expansion.py +++ b/tests/unit/test_nbhd/test_expansion.py @@ -107,9 +107,7 @@ def test_calc_expansion_raises_when_pixel_space_scale_missing(): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() with pytest.raises(ValueError, match="scale_um_per_pixel, pixels_per_micron, or technology"): - _calc_expansion( - gdf_nuclei, gdf_cells, radii_um=[1], id_col="cell_id", is_pixel_space=True - ) + _calc_expansion(gdf_nuclei, gdf_cells, radii_um=[1], id_col="cell_id", is_pixel_space=True) def test_neighborhood_collection_calc_expansion_accepts_pixels_per_micron(): @@ -157,9 +155,7 @@ def test_calc_expansion_works_for_non_nucleus_entities(): def test_calc_expansion_add_colors(): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() - with_colors = _calc_expansion( - gdf_nuclei, gdf_cells, radii_um=[0, 1, 2], id_col="cell_id" - ) + with_colors = _calc_expansion(gdf_nuclei, gdf_cells, radii_um=[0, 1, 2], id_col="cell_id") assert all("color" in gdf.columns for gdf in with_colors.values()) # one shade per radius, shared across entities within that radius assert with_colors[0.0]["color"].nunique() == 1 @@ -219,7 +215,11 @@ def test_calc_signature_cell_free_accepts_custom_columns_across_radii(tmp_path): nbhd_r0 = series[0.0] nbhd_r0.calc_signature( - by="cell-free", data_dir=str(tmp_path), feature_col="name", x_col="x", y_col="y", + by="cell-free", + data_dir=str(tmp_path), + feature_col="name", + x_col="x", + y_col="y", drop_missing=False, ) modality_r0 = nbhd_r0.mod["gene_cell_free"] @@ -232,7 +232,11 @@ def test_calc_signature_cell_free_accepts_custom_columns_across_radii(tmp_path): nbhd_r5 = series[5.0] nbhd_r5.calc_signature( - by="cell-free", data_dir=str(tmp_path), feature_col="name", x_col="x", y_col="y", + by="cell-free", + data_dir=str(tmp_path), + feature_col="name", + x_col="x", + y_col="y", drop_missing=False, ) modality_r5 = nbhd_r5.mod["gene_cell_free"] From a3f7518d995b781ca54dba516c602a50e73bc128 Mon Sep 17 00:00:00 2001 From: Jaspreet Ishar Date: Fri, 17 Jul 2026 15:22:49 -0400 Subject: [PATCH 10/14] removing redundant scaling args --- src/celldega/nbhd/collection.py | 31 +++++-------- src/celldega/nbhd/expansion.py | 64 ++++++++++---------------- tests/unit/test_nbhd/test_expansion.py | 60 +++++++++--------------- 3 files changed, 58 insertions(+), 97 deletions(-) diff --git a/src/celldega/nbhd/collection.py b/src/celldega/nbhd/collection.py index fb2a33e8..6c6a9154 100644 --- a/src/celldega/nbhd/collection.py +++ b/src/celldega/nbhd/collection.py @@ -317,13 +317,11 @@ def calc_gradient( def calc_expansion( self, gdf_bounds: gpd.GeoDataFrame, - radii_um: Sequence[float] = (0, 0.5, 1, 1.5, 2, 2.5, 3), + radii_um: Sequence[float] = (0.5, 1, 1.5, 2, 2.5), nbhd_type: str = "expansion", *, technology: str | None = None, scale_um_per_pixel: float | None = None, - pixels_per_micron: float | None = None, - is_pixel_space: bool = False, join_style: int = 2, mitre_limit: float = 5.0, add_colors: bool = True, @@ -345,17 +343,13 @@ def calc_expansion( (validity-repaired) entity geometry, clipped to its bound. nbhd_type: Label recorded on each returned collection. technology: Imaging platform used to look up ``scale_um_per_pixel`` - for pixel-space geometry (e.g. ``"Xenium"``). - scale_um_per_pixel: Microns per pixel (divide a micron distance by - this to get pixels). Required, directly or via ``technology``/ - ``pixels_per_micron``, when ``is_pixel_space=True``; takes - precedence over ``pixels_per_micron`` if both are given. - pixels_per_micron: Pixels per micron — the reciprocal convention - (multiply a micron distance by this to get pixels, e.g. a - notebook's own ``high_res_scale``); equivalent to - ``scale_um_per_pixel=1 / pixels_per_micron``. - is_pixel_space: ``True`` if this collection's geometry is in pixel - units; ``False`` (default) if already in microns. + (e.g. ``"Xenium"``). Ignored if ``scale_um_per_pixel`` is given. + scale_um_per_pixel: Microns per pixel — a micron distance is + *divided* by this to get the geometry's native units. Defaults + to ``1.0`` (geometry already in microns, i.e. no conversion). + If this collection's geometry is in pixel space and you only + have a pixels-per-micron factor, pass its reciprocal + (``1 / pixels_per_micron``). join_style: Shapely buffer join style (``1``=round, ``2``=mitre (default), ``3``=bevel). mitre_limit: Shapely mitre limit, used when ``join_style=2``. @@ -368,13 +362,12 @@ def calc_expansion( that radius's buffered, clipped geometries. Raises: - ValueError: If this collection has no geometry, if ids fail to - match ``gdf_bounds``, or if ``is_pixel_space=True`` without a - resolvable scale. + ValueError: If this collection has no geometry, or if ids fail to + match ``gdf_bounds``. Examples: >>> nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_col="cell_id") - >>> series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[0, 1, 2, 3]) + >>> series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[1, 2, 3]) >>> for radius, nbhd in series.items(): ... nbhd.calc_signature(by="cell-free", data_dir=data_dir, drop_missing=False) """ @@ -393,8 +386,6 @@ def calc_expansion( id_col=self.nbhd_col, technology=technology, scale_um_per_pixel=scale_um_per_pixel, - pixels_per_micron=pixels_per_micron, - is_pixel_space=is_pixel_space, join_style=join_style, mitre_limit=mitre_limit, add_colors=add_colors, diff --git a/src/celldega/nbhd/expansion.py b/src/celldega/nbhd/expansion.py index 39cf4cd2..5ed9972f 100644 --- a/src/celldega/nbhd/expansion.py +++ b/src/celldega/nbhd/expansion.py @@ -12,13 +12,12 @@ from collections.abc import Sequence import geopandas as gpd -import numpy as np from shapely.validation import make_valid from .gradient import _get_micron_per_pixel, _ring_colors -_DEFAULT_RADII_UM: tuple[float, ...] = (0, 0.5, 1, 1.5, 2, 2.5, 3) +_DEFAULT_RADII_UM: tuple[float, ...] = (0.5, 1, 1.5, 2, 2.5) def _calc_expansion( @@ -29,8 +28,6 @@ def _calc_expansion( id_col: str = "id", technology: str | None = None, scale_um_per_pixel: float | None = None, - pixels_per_micron: float | None = None, - is_pixel_space: bool = False, join_style: int = 2, mitre_limit: float = 5.0, add_colors: bool = True, @@ -51,17 +48,12 @@ def _calc_expansion( (validity-repaired) source geometry, clipped to its bound. id_col: Column identifying each entity, shared by both frames. technology: Imaging platform (e.g. ``"Xenium"``) used to look up - ``scale_um_per_pixel`` for pixel-space geometry. - scale_um_per_pixel: Microns per pixel (divide a micron distance by this - to get pixels). Required, directly or via ``technology``/ - ``pixels_per_micron``, when ``is_pixel_space=True``; takes - precedence over ``pixels_per_micron`` if both are given. - pixels_per_micron: Pixels per micron — the reciprocal convention - (multiply a micron distance by this to get pixels, e.g. a - notebook's own ``high_res_scale``); equivalent to - ``scale_um_per_pixel=1 / pixels_per_micron``. - is_pixel_space: ``True`` if the geometry is in pixel units; ``False`` - (default) if already in microns. + ``scale_um_per_pixel``. Ignored if ``scale_um_per_pixel`` is given. + scale_um_per_pixel: Microns per pixel — a micron distance is *divided* + by this to get the geometry's native units. Defaults to ``1.0`` + (geometry already in microns, i.e. no conversion). If your + geometry is in pixel space and you only have a pixels-per-micron + factor, pass its reciprocal (``1 / pixels_per_micron``). join_style: Shapely buffer join style (``1``=round, ``2``=mitre (default), ``3``=bevel). mitre_limit: Shapely mitre limit, used when ``join_style=2``. @@ -77,30 +69,26 @@ def _calc_expansion( Raises: KeyError: If ``id_col`` is missing from either frame. - ValueError: If ids are duplicated or fail to match between frames, or - if ``is_pixel_space=True`` without a resolvable scale. + ValueError: If ids are duplicated in ``gdf_bounds`` or fail to match + between frames. Examples: - >>> series = nbhd_nuclei.calc_expansion( - ... gdf_cells, radii_um=[0, 1, 2, 3], - ... is_pixel_space=True, pixels_per_micron=high_res_scale, - ... ) + >>> series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[1, 2, 3]) + + If geometry is in pixel space (e.g. an OME-XML ``PhysicalSizeX``, or + the reciprocal of a notebook's own ``high_res_scale``):: + + >>> series = nbhd_nuclei.calc_expansion( + ... gdf_cells, radii_um=[1, 2, 3], scale_um_per_pixel=1 / high_res_scale, + ... ) """ if id_col not in gdf_source.columns: raise KeyError(f"gdf_source missing '{id_col}'") if id_col not in gdf_bounds.columns: raise KeyError(f"gdf_bounds missing '{id_col}'") - if scale_um_per_pixel is None and technology is not None: - scale_um_per_pixel = _get_micron_per_pixel(technology) - if scale_um_per_pixel is None and pixels_per_micron is not None: - scale_um_per_pixel = 1.0 / pixels_per_micron - if is_pixel_space and scale_um_per_pixel is None: - raise ValueError( - "scale_um_per_pixel, pixels_per_micron, or technology is required " - "when is_pixel_space=True" - ) - effective_scale = scale_um_per_pixel if is_pixel_space else 1.0 + if scale_um_per_pixel is None: + scale_um_per_pixel = _get_micron_per_pixel(technology) if technology is not None else 1.0 source = gdf_source[[id_col, "geometry"]].copy() source[id_col] = source[id_col].astype(str) @@ -132,7 +120,7 @@ def _calc_expansion( results: dict[float, gpd.GeoDataFrame] = {} for radius_um in radii_sorted: - radius_native = radius_um / effective_scale + radius_native = radius_um / scale_um_per_pixel buffered = source["geometry"].buffer( radius_native, join_style=join_style, mitre_limit=mitre_limit @@ -152,15 +140,11 @@ def _calc_expansion( gdf_radius["center_x"] = gdf_radius.centroid.x gdf_radius["center_y"] = gdf_radius.centroid.y + # area_native is in the geometry's own (native/pixel) units; scale_um_per_pixel + # converts to microns (identity when geometry is already in microns). area_native = gdf_radius.geometry.area - if is_pixel_space: - gdf_radius["area_px2"] = area_native - gdf_radius["area_um2"] = area_native * (scale_um_per_pixel**2) - else: - gdf_radius["area_um2"] = area_native - gdf_radius["area_px2"] = ( - area_native / (scale_um_per_pixel**2) if scale_um_per_pixel else np.nan - ) + gdf_radius["area_px2"] = area_native + gdf_radius["area_um2"] = area_native * (scale_um_per_pixel**2) gdf_radius["area"] = gdf_radius["area_um2"] if add_colors: diff --git a/tests/unit/test_nbhd/test_expansion.py b/tests/unit/test_nbhd/test_expansion.py index 27370aa6..8ef0f98e 100644 --- a/tests/unit/test_nbhd/test_expansion.py +++ b/tests/unit/test_nbhd/test_expansion.py @@ -53,70 +53,56 @@ def test_calc_expansion_grows_and_clips_to_bound(): np.testing.assert_allclose(sorted(gdf_5["area_um2"]), [100.0, 100.0]) -def test_calc_expansion_pixels_per_micron_matches_scale_um_per_pixel(): +def test_calc_expansion_scale_um_per_pixel_converts_pixel_space_geometry(): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() high_res_scale = 2.0 # pixels per micron, e.g. a notebook's own scale variable - scaling_factor = 1.0 / high_res_scale # microns per pixel + scale_um_per_pixel = 1.0 / high_res_scale # microns per pixel -- what calc_expansion wants - via_pixels_per_micron = _calc_expansion( - gdf_nuclei, - gdf_cells, - radii_um=[1], - id_col="cell_id", - is_pixel_space=True, - pixels_per_micron=high_res_scale, - ) - via_scale_um_per_pixel = _calc_expansion( + result = _calc_expansion( gdf_nuclei, gdf_cells, radii_um=[1], id_col="cell_id", - is_pixel_space=True, - scale_um_per_pixel=scaling_factor, - ) - - pd.testing.assert_frame_equal( - via_pixels_per_micron[1.0].drop(columns="color"), - via_scale_um_per_pixel[1.0].drop(columns="color"), + scale_um_per_pixel=scale_um_per_pixel, ) # matches `buffer_dist = expand_um * high_res_scale`: a 2x2 nucleus buffered by # 1um * 2px/um = 2px on each side -> 6x6 = 36 px^2, well inside the 10x10 bound - gdf_1 = via_pixels_per_micron[1.0] + gdf_1 = result[1.0] np.testing.assert_allclose(sorted(gdf_1["area_px2"]), [36.0, 36.0]) # area_um2 = area_px2 * scale_um_per_pixel**2 = 36 * 0.25 = 9 np.testing.assert_allclose(sorted(gdf_1["area_um2"]), [9.0, 9.0]) -def test_calc_expansion_scale_um_per_pixel_takes_precedence(): +def test_calc_expansion_default_scale_treats_geometry_as_microns(): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() - result = _calc_expansion( - gdf_nuclei, - gdf_cells, - radii_um=[1], - id_col="cell_id", - is_pixel_space=True, - scale_um_per_pixel=0.5, - pixels_per_micron=999, # should be ignored since scale_um_per_pixel is given - ) - np.testing.assert_allclose(sorted(result[1.0]["area_px2"]), [36.0, 36.0]) + result = _calc_expansion(gdf_nuclei, gdf_cells, radii_um=[1], id_col="cell_id") + + # no conversion: a 2x2 nucleus buffered by 1um -> 4x4 = 16 um^2 + gdf_1 = result[1.0] + np.testing.assert_allclose(sorted(gdf_1["area_um2"]), [16.0, 16.0]) -def test_calc_expansion_raises_when_pixel_space_scale_missing(): +def test_calc_expansion_resolves_scale_from_technology(): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() - with pytest.raises(ValueError, match="scale_um_per_pixel, pixels_per_micron, or technology"): - _calc_expansion(gdf_nuclei, gdf_cells, radii_um=[1], id_col="cell_id", is_pixel_space=True) + result = _calc_expansion( + gdf_nuclei, gdf_cells, radii_um=[1], id_col="cell_id", technology="Xenium" + ) + expected = _calc_expansion( + gdf_nuclei, gdf_cells, radii_um=[1], id_col="cell_id", scale_um_per_pixel=0.2125 + ) + pd.testing.assert_frame_equal( + result[1.0].drop(columns="color"), expected[1.0].drop(columns="color") + ) -def test_neighborhood_collection_calc_expansion_accepts_pixels_per_micron(): +def test_neighborhood_collection_calc_expansion_accepts_scale_um_per_pixel(): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") - series = nbhd_nuclei.calc_expansion( - gdf_cells, radii_um=[1], is_pixel_space=True, pixels_per_micron=2.0 - ) + series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[1], scale_um_per_pixel=0.5) np.testing.assert_allclose(sorted(series[1.0].gdf["area_px2"]), [36.0, 36.0]) From d5585083017b30f725b26fa1c670e353f9d8f15a Mon Sep 17 00:00:00 2001 From: Jaspreet Ishar Date: Fri, 17 Jul 2026 15:23:00 -0400 Subject: [PATCH 11/14] updated notebook --- .../Nuclear_Expansion_Radial_Buffering.ipynb | 44 +++++-------------- 1 file changed, 12 insertions(+), 32 deletions(-) diff --git a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb index 8051c07b..e9bbb95d 100644 --- a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb +++ b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb @@ -577,43 +577,15 @@ " nbhd.calc_signature(\n", " by=\"cell-free\", data_dir=trx_dir, feature_col=\"name\", x_col=\"x\", y_col=\"y\",\n", " drop_missing=False,\n", - " )\n", - "\n", - "gene_totals = pd.DataFrame(\n", - " {\n", - " radius: pd.DataFrame(\n", - " nbhd.mod[\"gene_cell_free\"].X, columns=nbhd.mod[\"gene_cell_free\"].var_names\n", - " ).sum()\n", - " for radius, nbhd in nbhd_series.items()\n", - " }\n", - ").T\n", - "gene_totals" + " )" ] }, { "cell_type": "markdown", - "id": "fa4b647b-4dd6-42b0-9231-5896987aaa62", + "id": "dfa3ca39-f40a-4873-ac59-9bea47541d39", "metadata": {}, "source": [ - "## Mapping this onto a real pipeline\n", - "\n", - "| Original notebook | This notebook / Celldega API |\n", - "| --- | --- |\n", - "| `gdf_nuclei_original` (parsed from `..._nuclei_contour_coords.csv`) | `gdf_nuclei` -> `NeighborhoodCollection(gdf=gdf_nuclei, nbhd_col=\"cell_id\")` |\n", - "| `gdf_cells` / `gdf_cells2` (parsed from `..._Expanded_5um_cell_contour_coords.csv`) | `gdf_cells` passed to `calc_expansion` |\n", - "| `expand_nuclei_within_cell(nuclei_gdf, expand_um)` loop building `nuclei_gdfs = {\"original\": ..., \"expanded_0_5um\": ..., ...}` | `nbhd_series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[0, 0.5, 1, 1.5, 2, 2.5, 3])` |\n", - "| `assign_trx_to_entity_streaming_parquet_optimized(trx_parquet_path, entity_gdf, x_col=\"x\", y_col=\"y\", gene_col=\"name\", batch_size=1_000_000)` + manual `pivot_table` per radius | `nbhd.calc_signature(by=\"cell-free\", data_dir=trx_dir, feature_col=\"name\", x_col=\"x\", y_col=\"y\")` per radius -- same batched-parquet-plus-spatial-index mechanics, now built in and always used |\n", - "| Per-radius `pd.read_parquet(..._nuclei_by_gene.parquet)` -> `AnnData` (e.g. `ad.AnnData(X=nbg)`) | `nbhd.mod[\"gene_cell_free\"]` (already an `AnnData`) |\n", - "| Per-radius `adata.write(...h5ad)` | `nbhd.mod[\"gene_cell_free\"].write_h5ad(...)`, or persist the whole collection (geometry + all modalities) with `nbhd.write(\"radius.h5mu\")` |\n", - "| `safe_polygon`, `simple_format`, `transform_polygon`, `make_column_names_unique_fast` helper functions | available as `celldega.nbhd.safe_polygon` / `simple_format` / `transform_polygon` / `make_column_names_unique_fast`, unchanged -- not otherwise used in this notebook |\n", - "\n", - "`calc_signature`'s `by=\"cell-free\"` mode always streams from a\n", - "`transcripts.parquet` under `data_dir=` in batches (narrowing candidate\n", - "entities per batch with a spatial index before testing exact polygons), so a\n", - "whole-tile file re-joined once per radius across an expansion series doesn't\n", - "need to fit in memory. `feature_col`/`x_col`/`y_col` name its columns --\n", - "Xenium convention (`feature_name`/`x_location`/`y_location`) by default, or\n", - "whatever your own `transcripts.parquet` uses." + "## 6. Save NeighborhoodCollections to disk" ] }, { @@ -622,7 +594,15 @@ "id": "14cd97bd-fa73-40c3-ab90-49a3328d5efc", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "out_dir = Path(f\"{data_dir}/NeighborhoodCollections/\")\n", + "out_dir.mkdir(exist_ok=True)\n", + "\n", + "for res, nbhd in nbhd_series.items():\n", + " out_path = out_dir / f\"nbhd_expansion_{res}.h5mu\"\n", + " nbhd.write(out_path) # or nbhd.write_h5mu(out_path) if .write isn't available\n", + " print(f\"Saved resolution {res} -> {out_path}\")" + ] } ], "metadata": { From 9b24588eb19d62c1eb993112f45a902b2c92ac91 Mon Sep 17 00:00:00 2001 From: Jaspreet Ishar Date: Fri, 17 Jul 2026 15:35:44 -0400 Subject: [PATCH 12/14] cleaned markdown in notebook --- .../Nuclear_Expansion_Radial_Buffering.ipynb | 258 ++++-------------- 1 file changed, 58 insertions(+), 200 deletions(-) diff --git a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb index e9bbb95d..5eb3bc37 100644 --- a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb +++ b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb @@ -10,13 +10,11 @@ "This notebook is a runnable companion to a nucleus/cell segmentation-sensitivity\n", "analysis: starting from a nucleus polygon, grow it outward in fixed steps until it\n", "reaches the boundary of its corresponding (larger) cell segmentation, and compute a\n", - "cell-by-gene matrix at every step -- the original nucleus radius plus each expanded\n", - "radius.\n", + "cell-by-gene matrix at every step.\n", "\n", "That workflow is now a first-class part of Celldega's neighborhood API:\n", "\n", - "- **`NeighborhoodCollection.calc_expansion`** replaces the manual\n", - " `expand_nuclei_within_cell` buffering loop. It is deliberately generic: give it a\n", + "- **`NeighborhoodCollection.calc_expansion`** Give it a\n", " `NeighborhoodCollection` of *any* entity and a matching per-entity bounding\n", " `GeoDataFrame`; it buffers every entity outward at each requested radius (in\n", " microns), clips each one to its own bound so growth never overshoots it, and\n", @@ -25,33 +23,22 @@ " cell is just the running example below -- the same method works for any other\n", " pair of nested per-entity geometries.\n", "- **`NeighborhoodCollection.calc_signature(by=\"cell-free\", data_dir=...)`**\n", - " replaces the custom `assign_trx_to_entity_streaming_parquet_optimized` +\n", - " manual pivot. It always streams a `transcripts.parquet` directory in batches\n", + " It always streams a `transcripts.parquet` directory in batches\n", " (narrowing candidate entities per batch with a spatial index before testing\n", - " exact polygons), so a whole-tile file doesn't need to be loaded into memory\n", + " exact polygons), so a whole file doesn't need to be loaded into memory\n", " once per radius; `feature_col`/`x_col`/`y_col` name its gene/x/y columns\n", " (Xenium convention by default, but overridable for any column layout).\n", "\n", - "Because the real instrument files (OME-TIFF, per-dataset contour CSVs, a full-tile\n", - "`transcripts.parquet`) aren't available here, this notebook builds a small\n", + "Because the real instrument files aren't available here, this notebook builds a small\n", "**synthetic** nucleus/cell/transcript dataset with the same shape as a real\n", - "segmentation export, so every cell below runs standalone. The final section maps\n", - "each synthetic variable back to the real pipeline's inputs so you can swap in your\n", - "own paths." + "segmentation export, so every cell below runs standalone." ] }, { "cell_type": "code", "execution_count": 1, "id": "4d0f46b0", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-17T16:22:58.565241Z", - "iopub.status.busy": "2026-07-17T16:22:58.565051Z", - "iopub.status.idle": "2026-07-17T16:23:01.914699Z", - "shell.execute_reply": "2026-07-17T16:23:01.913959Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -96,14 +83,7 @@ "cell_type": "code", "execution_count": 2, "id": "5f2394c8", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-17T16:23:01.917140Z", - "iopub.status.busy": "2026-07-17T16:23:01.916836Z", - "iopub.status.idle": "2026-07-17T16:23:01.930026Z", - "shell.execute_reply": "2026-07-17T16:23:01.929601Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -171,14 +151,7 @@ "cell_type": "code", "execution_count": 3, "id": "85a6f217", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-17T16:23:01.932091Z", - "iopub.status.busy": "2026-07-17T16:23:01.931913Z", - "iopub.status.idle": "2026-07-17T16:23:01.945604Z", - "shell.execute_reply": "2026-07-17T16:23:01.945131Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -270,33 +243,24 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "658414fd", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-17T16:23:01.947104Z", - "iopub.status.busy": "2026-07-17T16:23:01.946997Z", - "iopub.status.idle": "2026-07-17T16:23:02.053360Z", - "shell.execute_reply": "2026-07-17T16:23:02.052696Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "radius= 0.0 um -> n= 120 mean_area= 28.34 um^2\n", "radius= 0.5 um -> n= 120 mean_area= 38.52 um^2\n", "radius= 1.0 um -> n= 120 mean_area= 50.28 um^2\n", "radius= 1.5 um -> n= 120 mean_area= 63.58 um^2\n", "radius= 2.0 um -> n= 120 mean_area= 78.40 um^2\n", - "radius= 2.5 um -> n= 120 mean_area= 94.52 um^2\n", - "radius= 3.0 um -> n= 120 mean_area=111.39 um^2\n" + "radius= 2.5 um -> n= 120 mean_area= 94.52 um^2\n" ] } ], "source": [ - "radii_um = [0, 0.5, 1, 1.5, 2, 2.5, 3]\n", + "radii_um = [0.5, 1, 1.5, 2, 2.5]\n", "nbhd_series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=radii_um)\n", "\n", "for radius, nbhd in nbhd_series.items():\n", @@ -305,17 +269,21 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "140c06c5", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-17T16:23:02.055159Z", - "iopub.status.busy": "2026-07-17T16:23:02.055039Z", - "iopub.status.idle": "2026-07-17T16:23:02.892960Z", - "shell.execute_reply": "2026-07-17T16:23:02.892433Z" + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } - }, - "outputs": [], + ], "source": [ "# visual sanity check for one example cell, mirroring the original notebook's plot\n", "example_id = str(int(df_cell_meta.index[7]))\n", @@ -350,16 +318,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "09ef320b", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-17T16:23:02.895272Z", - "iopub.status.busy": "2026-07-17T16:23:02.895127Z", - "iopub.status.idle": "2026-07-17T16:23:03.008410Z", - "shell.execute_reply": "2026-07-17T16:23:03.007798Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -373,7 +334,7 @@ " 'MarkerB': 625})" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -420,31 +381,23 @@ "id": "103af3bf", "metadata": {}, "source": [ - "## 5. Cell-by-gene matrix at every radius\n", + "## 4. Cell-by-gene matrix at every radius\n", "\n", "`calc_signature(by=\"cell-free\", data_dir=...)` spatially joins transcripts to\n", "each radius's polygons and returns transcript counts as an `AnnData` in\n", - "`nbhd.mod[\"gene_cell_free\"]` -- one call per radius, no custom pivot code\n", - "needed. `data_dir` points to a directory containing a `transcripts.parquet`;\n", + "`nbhd.mod[\"gene_cell_free\"]`. `data_dir` points to a directory containing a `transcripts.parquet`;\n", "`feature_col`/`x_col`/`y_col` name its gene/x/y columns (Xenium convention by\n", "default, overridden below for this notebook's custom `name`/`x`/`y` columns).\n", "The file is always streamed in batches internally -- narrowing candidate\n", "entities per batch with a spatial index before testing exact polygons -- so a\n", - "whole-tile file doesn't need to be loaded into memory once per radius." + "whole file doesn't need to be loaded into memory once per radius." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "10f40fda", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-17T16:23:03.010401Z", - "iopub.status.busy": "2026-07-17T16:23:03.010273Z", - "iopub.status.idle": "2026-07-17T16:23:03.244960Z", - "shell.execute_reply": "2026-07-17T16:23:03.244436Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -454,122 +407,8 @@ "Calculating neighborhood-by-gene (cell-free, streaming)\n", "Calculating neighborhood-by-gene (cell-free, streaming)\n", "Calculating neighborhood-by-gene (cell-free, streaming)\n", - "Calculating neighborhood-by-gene (cell-free, streaming)\n", - "Calculating neighborhood-by-gene (cell-free, streaming)\n", "Calculating neighborhood-by-gene (cell-free, streaming)\n" ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
CytoGene1CytoGene2MarkerAMarkerBNucGene1NucGene2
0.0NaNNaNNaNNaN970.0824.0
0.582.079.037.041.0982.0834.0
1.0171.0162.076.075.0984.0837.0
1.5274.0255.0118.0121.0984.0837.0
2.0379.0367.0170.0172.0984.0837.0
2.5485.0463.0228.0217.0984.0837.0
3.0610.0571.0291.0284.0984.0837.0
\n", - "
" - ], - "text/plain": [ - " CytoGene1 CytoGene2 MarkerA MarkerB NucGene1 NucGene2\n", - "0.0 NaN NaN NaN NaN 970.0 824.0\n", - "0.5 82.0 79.0 37.0 41.0 982.0 834.0\n", - "1.0 171.0 162.0 76.0 75.0 984.0 837.0\n", - "1.5 274.0 255.0 118.0 121.0 984.0 837.0\n", - "2.0 379.0 367.0 170.0 172.0 984.0 837.0\n", - "2.5 485.0 463.0 228.0 217.0 984.0 837.0\n", - "3.0 610.0 571.0 291.0 284.0 984.0 837.0" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ @@ -590,19 +429,38 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "14cd97bd-fa73-40c3-ab90-49a3328d5efc", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved resolution 0.5 -> /var/folders/_6/bhs42vt57t1dkb59k4sy0p440000gp/T/tmpbfnv6n46/nbhd_expansion_0.5.h5mu\n", + "Saved resolution 1.0 -> /var/folders/_6/bhs42vt57t1dkb59k4sy0p440000gp/T/tmpbfnv6n46/nbhd_expansion_1.0.h5mu\n", + "Saved resolution 1.5 -> /var/folders/_6/bhs42vt57t1dkb59k4sy0p440000gp/T/tmpbfnv6n46/nbhd_expansion_1.5.h5mu\n", + "Saved resolution 2.0 -> /var/folders/_6/bhs42vt57t1dkb59k4sy0p440000gp/T/tmpbfnv6n46/nbhd_expansion_2.0.h5mu\n", + "Saved resolution 2.5 -> /var/folders/_6/bhs42vt57t1dkb59k4sy0p440000gp/T/tmpbfnv6n46/nbhd_expansion_2.5.h5mu\n" + ] + } + ], "source": [ - "out_dir = Path(f\"{data_dir}/NeighborhoodCollections/\")\n", - "out_dir.mkdir(exist_ok=True)\n", + "nbhd_dir = tempfile.mkdtemp()\n", "\n", "for res, nbhd in nbhd_series.items():\n", - " out_path = out_dir / f\"nbhd_expansion_{res}.h5mu\"\n", + " out_path = f\"{nbhd_dir}/nbhd_expansion_{res}.h5mu\"\n", " nbhd.write(out_path) # or nbhd.write_h5mu(out_path) if .write isn't available\n", " print(f\"Saved resolution {res} -> {out_path}\")" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4841e593-cad8-4e6f-9178-9caced708205", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From baedb1ed188c88b6f6cb434039d37ae5bde4d3e1 Mon Sep 17 00:00:00 2001 From: Jaspreet Ishar Date: Fri, 17 Jul 2026 16:11:13 -0400 Subject: [PATCH 13/14] enable finding any transcripts file ending with "transcripts.parquet" --- .../Nuclear_Expansion_Radial_Buffering.ipynb | 111 +++++++++++++----- src/celldega/nbhd/collection.py | 19 +-- src/celldega/nbhd/neighborhoods.py | 11 +- src/celldega/nbhd/utils.py | 24 +++- tests/unit/test_nbhd/test_expansion.py | 25 ++++ tests/unit/test_nbhd/test_nbhd_collection.py | 19 +++ tests/unit/test_nbhd/test_utils.py | 34 ++++++ 7 files changed, 201 insertions(+), 42 deletions(-) diff --git a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb index 5eb3bc37..757d24c9 100644 --- a/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb +++ b/docs/examples/brief_notebooks/Nuclear_Expansion_Radial_Buffering.ipynb @@ -38,7 +38,14 @@ "cell_type": "code", "execution_count": 1, "id": "4d0f46b0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-17T20:08:45.268799Z", + "iopub.status.busy": "2026-07-17T20:08:45.268702Z", + "iopub.status.idle": "2026-07-17T20:08:48.148942Z", + "shell.execute_reply": "2026-07-17T20:08:48.148095Z" + } + }, "outputs": [ { "data": { @@ -83,7 +90,14 @@ "cell_type": "code", "execution_count": 2, "id": "5f2394c8", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-17T20:08:48.151771Z", + "iopub.status.busy": "2026-07-17T20:08:48.151381Z", + "iopub.status.idle": "2026-07-17T20:08:48.166227Z", + "shell.execute_reply": "2026-07-17T20:08:48.165419Z" + } + }, "outputs": [ { "data": { @@ -151,7 +165,14 @@ "cell_type": "code", "execution_count": 3, "id": "85a6f217", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-17T20:08:48.167907Z", + "iopub.status.busy": "2026-07-17T20:08:48.167766Z", + "iopub.status.idle": "2026-07-17T20:08:48.182136Z", + "shell.execute_reply": "2026-07-17T20:08:48.181644Z" + } + }, "outputs": [ { "data": { @@ -243,9 +264,16 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "658414fd", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-17T20:08:48.184092Z", + "iopub.status.busy": "2026-07-17T20:08:48.183960Z", + "iopub.status.idle": "2026-07-17T20:08:48.268152Z", + "shell.execute_reply": "2026-07-17T20:08:48.267650Z" + } + }, "outputs": [ { "name": "stdout", @@ -269,21 +297,17 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "140c06c5", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-17T20:08:48.269740Z", + "iopub.status.busy": "2026-07-17T20:08:48.269622Z", + "iopub.status.idle": "2026-07-17T20:08:48.724554Z", + "shell.execute_reply": "2026-07-17T20:08:48.723975Z" } - ], + }, + "outputs": [], "source": [ "# visual sanity check for one example cell, mirroring the original notebook's plot\n", "example_id = str(int(df_cell_meta.index[7]))\n", @@ -318,9 +342,16 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "09ef320b", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-17T20:08:48.726457Z", + "iopub.status.busy": "2026-07-17T20:08:48.726342Z", + "iopub.status.idle": "2026-07-17T20:08:48.822022Z", + "shell.execute_reply": "2026-07-17T20:08:48.821542Z" + } + }, "outputs": [ { "data": { @@ -334,7 +365,7 @@ " 'MarkerB': 625})" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -395,9 +426,16 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "10f40fda", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-17T20:08:48.823730Z", + "iopub.status.busy": "2026-07-17T20:08:48.823611Z", + "iopub.status.idle": "2026-07-17T20:08:48.990788Z", + "shell.execute_reply": "2026-07-17T20:08:48.990170Z" + } + }, "outputs": [ { "name": "stdout", @@ -429,19 +467,32 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 8, "id": "14cd97bd-fa73-40c3-ab90-49a3328d5efc", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-17T20:08:48.992366Z", + "iopub.status.busy": "2026-07-17T20:08:48.992255Z", + "iopub.status.idle": "2026-07-17T20:08:49.106001Z", + "shell.execute_reply": "2026-07-17T20:08:49.105495Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Saved resolution 0.5 -> /var/folders/_6/bhs42vt57t1dkb59k4sy0p440000gp/T/tmpbfnv6n46/nbhd_expansion_0.5.h5mu\n", - "Saved resolution 1.0 -> /var/folders/_6/bhs42vt57t1dkb59k4sy0p440000gp/T/tmpbfnv6n46/nbhd_expansion_1.0.h5mu\n", - "Saved resolution 1.5 -> /var/folders/_6/bhs42vt57t1dkb59k4sy0p440000gp/T/tmpbfnv6n46/nbhd_expansion_1.5.h5mu\n", - "Saved resolution 2.0 -> /var/folders/_6/bhs42vt57t1dkb59k4sy0p440000gp/T/tmpbfnv6n46/nbhd_expansion_2.0.h5mu\n", - "Saved resolution 2.5 -> /var/folders/_6/bhs42vt57t1dkb59k4sy0p440000gp/T/tmpbfnv6n46/nbhd_expansion_2.5.h5mu\n" + "Saved resolution 0.5 -> /var/folders/_6/bhs42vt57t1dkb59k4sy0p440000gp/T/tmpyvdqmiu4/nbhd_expansion_0.5.h5mu\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved resolution 1.0 -> /var/folders/_6/bhs42vt57t1dkb59k4sy0p440000gp/T/tmpyvdqmiu4/nbhd_expansion_1.0.h5mu\n", + "Saved resolution 1.5 -> /var/folders/_6/bhs42vt57t1dkb59k4sy0p440000gp/T/tmpyvdqmiu4/nbhd_expansion_1.5.h5mu\n", + "Saved resolution 2.0 -> /var/folders/_6/bhs42vt57t1dkb59k4sy0p440000gp/T/tmpyvdqmiu4/nbhd_expansion_2.0.h5mu\n", + "Saved resolution 2.5 -> /var/folders/_6/bhs42vt57t1dkb59k4sy0p440000gp/T/tmpyvdqmiu4/nbhd_expansion_2.5.h5mu\n" ] } ], diff --git a/src/celldega/nbhd/collection.py b/src/celldega/nbhd/collection.py index 6c6a9154..8c406361 100644 --- a/src/celldega/nbhd/collection.py +++ b/src/celldega/nbhd/collection.py @@ -552,10 +552,12 @@ def calc_signature( modality_name: Key for the modality; defaults to ``"gene"`` (cell-derived) or ``"gene_cell_free"`` (transcript-derived). min_cells: Minimum cells/transcripts for a neighborhood to be kept. - data_dir: Directory with a ``transcripts.parquet`` (columns named - ``feature_col``/``x_col``/``y_col``, Xenium convention by - default), streamed in batches; defaults to ``self.data_dir``. - Required for ``by="cell-free"``. + data_dir: Directory containing a transcripts parquet file — any + file whose name ends with ``transcripts.parquet`` (e.g. + ``transcripts.parquet``, ``data1_transcripts.parquet``), with + columns named ``feature_col``/``x_col``/``y_col`` (Xenium + convention by default), streamed in batches; defaults to + ``self.data_dir``. Required for ``by="cell-free"``. feature_col: Gene/feature column in ``data_dir``'s ``transcripts.parquet`` (default ``"feature_name"``). x_col: Transcript x-coordinate column in ``data_dir``'s @@ -690,8 +692,10 @@ def calc_transcript_assignment( ) -> None: """Add per-neighborhood transcript-assignment columns to ``obs``. - From ``transcripts.parquet`` in ``data_dir``, adds three ``obs`` columns - (on the underlying MuData) for each neighborhood: + From the transcripts parquet file in ``data_dir`` (any file whose name + ends with ``transcripts.parquet``, e.g. ``transcripts.parquet`` or + ``data1_transcripts.parquet``), adds three ``obs`` columns (on the + underlying MuData) for each neighborhood: - ``total_transcripts`` — transcripts falling inside the neighborhood. - ``unassigned_transcripts`` — those with ``cell_id == "UNASSIGNED"``. @@ -704,7 +708,8 @@ def calc_transcript_assignment( Only transcripts are needed — no ``adata`` or cell polygons. Args: - data_dir: Directory containing ``transcripts.parquet``; defaults to + data_dir: Directory containing a transcripts parquet file (any + name ending with ``transcripts.parquet``); defaults to ``self.data_dir``. Returns: diff --git a/src/celldega/nbhd/neighborhoods.py b/src/celldega/nbhd/neighborhoods.py index 7aa4b60a..74ec7c3d 100644 --- a/src/celldega/nbhd/neighborhoods.py +++ b/src/celldega/nbhd/neighborhoods.py @@ -58,10 +58,12 @@ def _calc_nbhd_by_gene( Cell-level data with spatial coordinates in `obsm["spatial"]`; required for `by="cell"`. data_dir : str, optional - Directory with a `transcripts.parquet` (columns named `feature_col`/ - `x_col`/`y_col`, Xenium convention by default). Required for `by="cell-free"`. + Directory containing a transcripts parquet file — any file whose name + ends with `transcripts.parquet` (e.g. `transcripts.parquet`, + `data1_transcripts.parquet`), with columns named `feature_col`/ + `x_col`/`y_col` (Xenium convention by default). Required for `by="cell-free"`. feature_col : str, default "feature_name" - Gene/feature column in `data_dir`'s `transcripts.parquet`. + Gene/feature column in `data_dir`'s transcripts parquet file. x_col, y_col : str, default "x_location", "y_location" Transcript coordinate columns in `data_dir`'s `transcripts.parquet`. nbhd_col : str, default "name" @@ -131,10 +133,11 @@ def _calc_nbhd_by_gene( print("Calculating neighborhood-by-gene (cell-free, streaming)") from celldega.nbhd.trx_streaming import _assign_trx_to_entity_streaming_parquet + from celldega.nbhd.utils import _find_transcripts_parquet df_result = ( _assign_trx_to_entity_streaming_parquet( - f"{data_dir}/transcripts.parquet", + _find_transcripts_parquet(data_dir), gdf_nbhd, id_col=nbhd_col, x_col=x_col, diff --git a/src/celldega/nbhd/utils.py b/src/celldega/nbhd/utils.py index b088ef09..5d5e74a8 100644 --- a/src/celldega/nbhd/utils.py +++ b/src/celldega/nbhd/utils.py @@ -3,6 +3,7 @@ # Standard library imports from collections import defaultdict from collections.abc import Sequence +from pathlib import Path from typing import Any # Third-party imports @@ -106,6 +107,27 @@ def _get_gdf_cell(adata: Any) -> gpd.GeoDataFrame: ) +def _find_transcripts_parquet(data_dir: str) -> str: + """ + Find the transcripts parquet file in `data_dir`. + + Matches any file whose name ends with `transcripts.parquet` (e.g. + `transcripts.parquet`, `data1_transcripts.parquet`, + `aziz_1_20260217_5_transcripts.parquet`), not just the literal Xenium + convention `transcripts.parquet`. + """ + candidates = sorted(p for p in Path(data_dir).iterdir() if p.name.endswith("transcripts.parquet")) + if not candidates: + raise FileNotFoundError(f"No file ending with 'transcripts.parquet' found in '{data_dir}'") + if len(candidates) > 1: + raise ValueError( + f"Multiple files ending with 'transcripts.parquet' found in '{data_dir}': " + f"{[p.name for p in candidates]}. Keep only one, or point data_dir at a " + "directory containing a single transcripts file." + ) + return str(candidates[0]) + + def _get_gdf_trx(data_dir: str) -> gpd.GeoDataFrame: """ Load transcript data as a GeoDataFrame with spatial coordinates. @@ -113,7 +135,7 @@ def _get_gdf_trx(data_dir: str) -> gpd.GeoDataFrame: No CRS is set since coordinates are in micron imaging space, not geospatial. """ df_trx = pd.read_parquet( - f"{data_dir}/transcripts.parquet", + _find_transcripts_parquet(data_dir), columns=["feature_name", "x_location", "y_location", "cell_id"], engine="pyarrow", ) diff --git a/tests/unit/test_nbhd/test_expansion.py b/tests/unit/test_nbhd/test_expansion.py index 8ef0f98e..2447a936 100644 --- a/tests/unit/test_nbhd/test_expansion.py +++ b/tests/unit/test_nbhd/test_expansion.py @@ -276,6 +276,31 @@ def test_calc_signature_cell_free_streams_from_data_dir_across_radii(tmp_path): assert df_r5.loc["c1", "GeneB"] == 1 +def test_calc_signature_cell_free_finds_prefixed_transcripts_filename(tmp_path): + gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() + nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") + series = nbhd_nuclei.calc_expansion(gdf_cells, radii_um=[5]) + + # not every transcripts file is literally named "transcripts.parquet" + pd.DataFrame( + { + "feature_name": ["GeneA", "GeneA"], + "x_location": [5, 25], + "y_location": [5, 25], + } + ).to_parquet(tmp_path / "aziz_1_20260217_5_transcripts.parquet") + + nbhd_r5 = series[5.0] + nbhd_r5.calc_signature(by="cell-free", data_dir=str(tmp_path), drop_missing=False) + df_r5 = pd.DataFrame( + nbhd_r5.mod["gene_cell_free"].X, + index=nbhd_r5.mod["gene_cell_free"].obs_names, + columns=nbhd_r5.mod["gene_cell_free"].var_names, + ) + assert df_r5.loc["c1", "GeneA"] == 1 + assert df_r5.loc["c2", "GeneA"] == 1 + + def test_calc_signature_cell_free_data_dir_accepts_custom_columns(tmp_path): gdf_nuclei, gdf_cells = _synthetic_nucleus_cell_inputs() nbhd_nuclei = NeighborhoodCollection(gdf=gdf_nuclei, nbhd_type="nucleus", nbhd_col="cell_id") diff --git a/tests/unit/test_nbhd/test_nbhd_collection.py b/tests/unit/test_nbhd/test_nbhd_collection.py index 2ff2924e..7ccef25d 100644 --- a/tests/unit/test_nbhd/test_nbhd_collection.py +++ b/tests/unit/test_nbhd/test_nbhd_collection.py @@ -194,6 +194,25 @@ def test_neighborhood_collection_transcript_assignment(tmp_path): assert obs["transcript_assignment_proportion"].loc["B"] == 0.0 +def test_transcript_assignment_finds_prefixed_transcripts_filename(tmp_path): + gdf, _adata = _synthetic_nbhd_inputs() + trx = pd.DataFrame( + { + "feature_name": ["g"] * 3, + "x_location": [1, 2, 11], + "y_location": [1, 2, 1], + "cell_id": ["c1", "c2", "UNASSIGNED"], + } + ) + # not every transcripts file is literally named "transcripts.parquet" + trx.to_parquet(tmp_path / "aziz_1_20260217_5_transcripts.parquet") + + collection = NeighborhoodCollection(gdf=gdf, nbhd_type="manual") + collection.calc_transcript_assignment(data_dir=str(tmp_path)) + + assert list(collection.obs["total_transcripts"]) == [2, 1] + + def test_transcript_assignment_warns_when_no_unassigned_sentinel(tmp_path): gdf, _adata = _synthetic_nbhd_inputs() # cell_id present but no "UNASSIGNED" sentinel -> warns (may be fully assigned) diff --git a/tests/unit/test_nbhd/test_utils.py b/tests/unit/test_nbhd/test_utils.py index 74beaa2d..7d249383 100644 --- a/tests/unit/test_nbhd/test_utils.py +++ b/tests/unit/test_nbhd/test_utils.py @@ -1,4 +1,5 @@ import pandas as pd +import pytest from shapely.geometry import Polygon from celldega.nbhd import ( @@ -7,6 +8,7 @@ simple_format, transform_polygon, ) +from celldega.nbhd.utils import _find_transcripts_parquet def test_safe_polygon_builds_from_vertex_columns(): @@ -35,3 +37,35 @@ def test_make_column_names_unique_fast_dedupes_columns(): df = pd.DataFrame([[1, 2, 3]], columns=["gene", "gene", "gene"]) result = make_column_names_unique_fast(df) assert list(result.columns) == ["gene", "gene_1", "gene_2"] + + +def test_find_transcripts_parquet_matches_literal_name(tmp_path): + (tmp_path / "transcripts.parquet").write_bytes(b"") + assert _find_transcripts_parquet(str(tmp_path)) == str(tmp_path / "transcripts.parquet") + + +def test_find_transcripts_parquet_matches_prefixed_name(tmp_path): + (tmp_path / "aziz_1_20260217_5_transcripts.parquet").write_bytes(b"") + assert _find_transcripts_parquet(str(tmp_path)) == str( + tmp_path / "aziz_1_20260217_5_transcripts.parquet" + ) + + +def test_find_transcripts_parquet_ignores_unrelated_files(tmp_path): + (tmp_path / "data1_transcripts.parquet").write_bytes(b"") + (tmp_path / "cells.parquet").write_bytes(b"") + (tmp_path / "notes.txt").write_bytes(b"") + assert _find_transcripts_parquet(str(tmp_path)) == str(tmp_path / "data1_transcripts.parquet") + + +def test_find_transcripts_parquet_raises_when_none_found(tmp_path): + (tmp_path / "cells.parquet").write_bytes(b"") + with pytest.raises(FileNotFoundError, match=r"transcripts\.parquet"): + _find_transcripts_parquet(str(tmp_path)) + + +def test_find_transcripts_parquet_raises_when_ambiguous(tmp_path): + (tmp_path / "data1_transcripts.parquet").write_bytes(b"") + (tmp_path / "data2_transcripts.parquet").write_bytes(b"") + with pytest.raises(ValueError, match="Multiple files"): + _find_transcripts_parquet(str(tmp_path)) From 1741cde74026bd91232dac5382c207d6e0390bde Mon Sep 17 00:00:00 2001 From: Jaspreet Ishar Date: Fri, 17 Jul 2026 21:58:23 -0400 Subject: [PATCH 14/14] ruff --- src/celldega/nbhd/utils.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/celldega/nbhd/utils.py b/src/celldega/nbhd/utils.py index 5d5e74a8..5a1788c0 100644 --- a/src/celldega/nbhd/utils.py +++ b/src/celldega/nbhd/utils.py @@ -116,7 +116,9 @@ def _find_transcripts_parquet(data_dir: str) -> str: `aziz_1_20260217_5_transcripts.parquet`), not just the literal Xenium convention `transcripts.parquet`. """ - candidates = sorted(p for p in Path(data_dir).iterdir() if p.name.endswith("transcripts.parquet")) + candidates = sorted( + p for p in Path(data_dir).iterdir() if p.name.endswith("transcripts.parquet") + ) if not candidates: raise FileNotFoundError(f"No file ending with 'transcripts.parquet' found in '{data_dir}'") if len(candidates) > 1: