cellmap-analyze 0.0.1__tar.gz

cellmap_analyze-0.0.1/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, CellMap Project Team
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

cellmap_analyze-0.0.1/MANIFEST.in

@@ -0,0 +1 @@
+include src/cellmap_analyze/cythonizing/*.pyx

cellmap_analyze-0.0.1/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: cellmap-analyze
+Version: 0.0.1
+Summary: Code to perform analysis on segmentations like those produced by CellMap
+Author-email: David Ackerman <ackermand@janelia.hhmi.org>
+Maintainer-email: David Ackerman <ackermand@janelia.hhmi.org>
+Requires-Python: <3.13,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bokeh>=3.1.0
+Requires-Dist: fastremap
+Requires-Dist: funlib.geometry
+Requires-Dist: funlib.persistence==0.3.0
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: connected-components-3d
+Requires-Dist: dask[distributed]
+Requires-Dist: dask-jobqueue
+Requires-Dist: fastmorph
+Requires-Dist: scipy
+Requires-Dist: scikit-image
+Requires-Dist: tensorstore
+Requires-Dist: tqdm
+Requires-Dist: zarr==2.18.5
+Requires-Dist: numcodecs==0.13.0
+Requires-Dist: mwatershed
+Requires-Dist: pyarrow
+Requires-Dist: neuroglancer
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Dynamic: license-file
+
+![CI](https://github.com/janelia-cellmap/cellmap-analyze/actions/workflows/tests.yml/badge.svg)
+[![codecov](https://codecov.io/gh/janelia-cellmap/cellmap-analyze/branch/refactor_for_release/graph/badge.svg)](https://codecov.io/gh/janelia-cellmap/cellmap-analyze)
+
+# Tools For Analyzing Large 3D Datasets
+
+This repository is a set of tools for processing and analyzing terabyte size 3D segmentation datasets using Dask. Processing tools involve reading in dataset(s) and outputting another - processed - dataset. These processing tools include the calculation of:
+
+1. `Connected Components`: includes thresholding and masking
+2. `Clean Connected Components`: tools for cleaning up an existing segmentation
+3. `Contact Sites`: includes setting a distance for contact sites
+4. `Filling holes`: fills holes in segmentations
+5. `Filtering ids`: filters segmented ids to remove unwanted ones.
+
+In addition, there are also tools for analysis of the 3D datasets including:
+
+1. `Measurement`: measures a variety of properties of the segmented ids (volume, surface area, etc.) as well as properties of contact sites (volume, surface area, contacting objects, etc.).
+2. `Fitting lines to segmentations`: useful for cylindrical-type objects.
+3. `Assigning to cells`: Assigns objects to the cells they are in based on the center of mass lcoations of the cells.
+
+TODO: Include a detailed description of installation and running the code
+</div>
+
+### Acknowledgements
+Code for finding centers was taken from [funlib.evaluate](https://github.com/funkelab/funlib.evaluate).

cellmap_analyze-0.0.1/README.md

@@ -0,0 +1,24 @@
+![CI](https://github.com/janelia-cellmap/cellmap-analyze/actions/workflows/tests.yml/badge.svg)
+[![codecov](https://codecov.io/gh/janelia-cellmap/cellmap-analyze/branch/refactor_for_release/graph/badge.svg)](https://codecov.io/gh/janelia-cellmap/cellmap-analyze)
+
+# Tools For Analyzing Large 3D Datasets
+
+This repository is a set of tools for processing and analyzing terabyte size 3D segmentation datasets using Dask. Processing tools involve reading in dataset(s) and outputting another - processed - dataset. These processing tools include the calculation of:
+
+1. `Connected Components`: includes thresholding and masking
+2. `Clean Connected Components`: tools for cleaning up an existing segmentation
+3. `Contact Sites`: includes setting a distance for contact sites
+4. `Filling holes`: fills holes in segmentations
+5. `Filtering ids`: filters segmented ids to remove unwanted ones.
+
+In addition, there are also tools for analysis of the 3D datasets including:
+
+1. `Measurement`: measures a variety of properties of the segmented ids (volume, surface area, etc.) as well as properties of contact sites (volume, surface area, contacting objects, etc.).
+2. `Fitting lines to segmentations`: useful for cylindrical-type objects.
+3. `Assigning to cells`: Assigns objects to the cells they are in based on the center of mass lcoations of the cells.
+
+TODO: Include a detailed description of installation and running the code
+</div>
+
+### Acknowledgements
+Code for finding centers was taken from [funlib.evaluate](https://github.com/funkelab/funlib.evaluate).

cellmap_analyze-0.0.1/pyproject.toml

@@ -0,0 +1,65 @@
+[project]
+name = "cellmap-analyze"
+version = "0.0.1"
+description = "Code to perform analysis on segmentations like those produced by CellMap"
+readme = "README.md"
+license-files = ["LICENSE"]
+requires-python = ">=3.10,<3.13"
+
+authors = [
+  { name = "David Ackerman", email = "ackermand@janelia.hhmi.org" },
+]
+
+maintainers = [
+  { name = "David Ackerman", email = "ackermand@janelia.hhmi.org" },
+]
+
+dependencies = [
+  "bokeh>=3.1.0",
+  "fastremap",
+  "funlib.geometry",
+  "funlib.persistence==0.3.0",
+  "numpy",
+  "pandas",
+  "connected-components-3d",
+  "dask[distributed]",
+  "dask-jobqueue",
+  "fastmorph",
+  "scipy",
+  "scikit-image",
+  "tensorstore",
+  "tqdm",
+  "zarr==2.18.5",
+  "numcodecs==0.13.0",
+  "mwatershed",
+  "pyarrow",
+  "neuroglancer",
+]
+
+[project.optional-dependencies]
+dev = ["pytest", "pytest-cov", "coverage", "build"]
+
+[project.scripts]
+connected-components = "cli.cli:connected_components"
+clean-connected-components = "cli.cli:clean_connected_components"
+contact-sites = "cli.cli:contact_sites"
+mutex-watershed = "cli.cli:mutex_watershed"
+filter-ids = "cli.cli:filter_ids"
+measure = "cli.cli:measure"
+fit-lines-to-segmentations = "cli.cli:fit_lines_to_segmentations"
+assign-to-cells = "cli.cli:assign_to_cells"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[build-system]
+requires = [
+  "setuptools>=61",
+  "wheel",
+  "Cython>=0.29",
+  "numpy"
+]
+build-backend = "setuptools.build_meta"

cellmap_analyze-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cellmap_analyze-0.0.1/setup.py

@@ -0,0 +1,25 @@
+from setuptools import setup, Extension
+from Cython.Build import cythonize
+import numpy as np
+
+extensions = [
+    Extension(
+        "cellmap_analyze.cythonizing.bresenham3D",
+        ["src/cellmap_analyze/cythonizing/bresenham3D.pyx"],
+    ),
+    Extension(
+        "cellmap_analyze.cythonizing.process_arrays",
+        ["src/cellmap_analyze/cythonizing/process_arrays.pyx"],
+    ),
+    Extension(
+        "cellmap_analyze.cythonizing.centers",
+        ["src/cellmap_analyze/cythonizing/centers.pyx"],
+        language="c++",
+        include_dirs=[np.get_include()],
+        extra_compile_args=["-std=c++11"],
+    ),
+]
+
+setup(
+    ext_modules=cythonize(extensions, language_level="3"),
+)

cellmap_analyze-0.0.1/src/cellmap_analyze/analyze/assign_to_cells.py

@@ -0,0 +1,216 @@
+# %%
+from typing import Union, List
+from cellmap_analyze.util import io_util
+from cellmap_analyze.util.image_data_interface import (
+    ImageDataInterface,
+)
+import logging
+import pandas as pd
+import numpy as np
+import os
+from scipy import spatial
+from tqdm import tqdm
+import fastremap
+import fastmorph
+
+logging.basicConfig(
+    format="%(asctime)s %(levelname)-8s %(message)s",
+    level=logging.INFO,
+    datefmt="%Y-%m-%d %H:%M:%S",
+)
+logger = logging.getLogger(__name__)
+
+
+class AssignToCells:
+    def __init__(
+        self,
+        organelle_csvs: Union[str, List[str]],
+        cell_ds_path: str,
+        output_path: str,
+        cell_assignment_type: int = 0,
+        iteration_distance_nm=10_000,
+    ):
+        if isinstance(organelle_csvs, str):
+            organelle_csvs = [organelle_csvs]
+
+        self.organelle_info_dict = {}
+
+        for organelle_csv in organelle_csvs:
+            df = pd.read_csv(organelle_csv)
+            if "Total Objects" in df.columns:
+                # delete last two columns of dataframe
+                df = df.iloc[:, :-2]
+            self.organelle_info_dict[organelle_csv] = df
+
+        self.cell_idi = ImageDataInterface(cell_ds_path)
+        self.cell_assignment_type = cell_assignment_type
+        self.output_path = output_path
+        self.iteration_distance_nm = iteration_distance_nm
+
+    @staticmethod
+    def assign_to_containing_cell(cell_idi, df):
+        cell_data = cell_idi.to_ndarray_ts()
+        coms = df[["COM Z (nm)", "COM Y (nm)", "COM X (nm)"]].to_numpy()
+        # Already have top left corners aligned since in measure_util get_region_properties we already center on voxel so that top left corners are aligned
+        inds = np.astype(coms // cell_idi.voxel_size, int)
+        in_bounds = np.all((inds >= cell_idi.domain.inclusive_min), axis=1) & np.all(
+            (inds < cell_idi.domain.exclusive_max), axis=1
+        )
+
+        df.loc[in_bounds, "Cell ID"] = cell_data[
+            inds[in_bounds, 0], inds[in_bounds, 1], inds[in_bounds, 2]
+        ]
+        df["Cell ID"] = df["Cell ID"].astype(int)
+
+    @staticmethod
+    def assign_to_n_nearest_cells(cell_idi, df, n, iteration_distance_nm):
+        coms = df[["COM Z (nm)", "COM Y (nm)", "COM X (nm)"]].to_numpy()
+        inds = np.astype(coms // cell_idi.voxel_size, int)
+        cell_data = cell_idi.to_ndarray_ts()
+        if len(fastremap.unique(cell_data[cell_data > 0])) < n:
+            raise ValueError(
+                f"Number of unique cell ids in the segmentation ({fastremap.unique(cell_data[cell_data > 0])}) is less than n ({n})."
+                " Please choose a smaller n or use a different assignment method."
+            )
+
+        num_points = len(coms)
+        boundaries = cell_data - fastmorph.erode(cell_data, erode_border=False)
+        unique_ids = fastremap.unique(boundaries[boundaries > 0])
+
+        # Initialize arrays to store the n closest distances and corresponding ids.
+        # Every query point gets an array of size n.
+        closest_distances = np.full((num_points, n), np.inf)
+        closest_ids = np.zeros((num_points, n), dtype=int)
+
+        boundary_coords = np.argwhere(boundaries)
+        boundary_ids = boundaries[
+            boundary_coords[:, 0], boundary_coords[:, 1], boundary_coords[:, 2]
+        ]
+
+        maximum_distance = iteration_distance_nm
+        iteration = 0
+
+        # Continue looping until every query point has n finite (non-inf) distances.
+        while np.any(np.any(np.isinf(closest_distances), axis=1)):
+            iteration += 1
+            # Global update mask: select only those query points that still have at least one np.inf.
+            global_update_mask = np.any(np.isinf(closest_distances), axis=1)
+            if not np.any(global_update_mask):
+                break
+
+            # Loop over each unique boundary id.
+            for unique_id in tqdm(unique_ids):
+                # Create an update mask for query points that need updates and do not already have this unique_id.
+                # We check along the row: if the current candidate list already contains this unique_id, skip updating it.
+                already_has_id = np.any(closest_ids == unique_id, axis=1)
+                update_mask = global_update_mask & ~already_has_id
+                if not np.any(update_mask):
+                    continue
+
+                # For the current unique object, get its boundary voxel coordinates, adjust by 0.5 for centering and scale.
+                coords = (
+                    boundary_coords[boundary_ids == unique_id] + 0.5
+                ) * cell_idi.voxel_size
+                tree = spatial.KDTree(coords)
+
+                # Query only for the points (coms) that need updating.
+                current_distances, _ = tree.query(
+                    coms[update_mask], distance_upper_bound=maximum_distance * iteration
+                )
+                # Check if coms are within a cell
+                updated_inds = inds[update_mask]
+                in_bounds = np.all(
+                    (updated_inds >= cell_idi.domain.inclusive_min), axis=1
+                ) & np.all((updated_inds < cell_idi.domain.exclusive_max), axis=1)
+                valid_inds = updated_inds[in_bounds]
+
+                # Initialize an array of False of the same length as updated_inds.
+                within_cell = np.full(updated_inds.shape[0], False, dtype=bool)
+
+                # For the indices that are in bounds, assign the comparison result.
+                within_cell[in_bounds] = (
+                    cell_data[valid_inds[:, 0], valid_inds[:, 1], valid_inds[:, 2]]
+                    == unique_id
+                )
+
+                # If the com is within a cell, set the distance to 0
+                current_distances[within_cell] = 0
+
+                # Combine the current n best distances with the new candidate (this gives n+1 candidates per query point).
+                combined_distances = np.column_stack(
+                    [closest_distances[update_mask], current_distances]
+                )
+                combined_ids = np.column_stack(
+                    [
+                        closest_ids[update_mask],
+                        np.full(np.sum(update_mask), unique_id, dtype=int),
+                    ]
+                )
+
+                # For each query point, sort candidates so that the smallest distances come first.
+                sort_order = np.argsort(combined_distances, axis=1)
+                sorted_distances = np.take_along_axis(
+                    combined_distances, sort_order, axis=1
+                )
+                sorted_ids = np.take_along_axis(combined_ids, sort_order, axis=1)
+
+                # Update the candidate arrays for only the query points that needed an update.
+                closest_distances[update_mask] = sorted_distances[:, :n]
+                closest_ids[update_mask] = sorted_ids[:, :n]
+
+        # Update the DataFrame columns.
+        if n > 1:
+            df["Cell ID"] = [row.tolist() for row in closest_ids]
+            df["Cell Distance (nm)"] = [row.tolist() for row in closest_distances]
+        else:
+            df["Cell ID"] = closest_ids[:, 0]
+            df["Cell Distance (nm)"] = closest_distances[:, 0]
+
+    def assign_to_cells(self):
+        with io_util.Timing_Messager("Assigning objects to cells", logger):
+            for organelle_csv, df in self.organelle_info_dict.items():
+                # get filename from organelle_csv
+                filename = os.path.basename(organelle_csv)
+                if filename == "cell.csv":
+                    continue
+                df["Cell ID"] = 0
+                if "er.csv" in organelle_csv:
+                    df["Cell ID"] = df["Object ID"]
+                    continue
+                if self.cell_assignment_type == 0:
+                    self.assign_to_containing_cell(self.cell_idi, df)
+                    continue
+                df["Cell Distance (nm)"] = 0
+                self.assign_to_n_nearest_cells(
+                    self.cell_idi,
+                    df,
+                    self.cell_assignment_type,
+                    self.iteration_distance_nm,
+                )
+
+    def write_updated_csvs(self):
+        with io_util.Timing_Messager("Writing out updated dataframes", logger):
+            os.makedirs(self.output_path, exist_ok=True)
+            for csv, df in self.organelle_info_dict.items():
+                csv_name = os.path.basename(csv.split(".csv")[0])
+                output_path = self.output_path
+                if csv_name.endswith("contacts"):  # pragma: no cover
+                    output_path = self.output_path + "/contact_sites/"
+                    os.makedirs(output_path, exist_ok=True)
+
+                if self.cell_assignment_type == 0:
+                    output_name = (
+                        f"{output_path}/{csv_name}_assigned_to_containing_cell"
+                    )
+                elif self.cell_assignment_type == 1:
+                    output_name = f"{output_path}/{csv_name}_assigned_to_nearest_cell"
+                else:
+                    output_name = f"{output_path}/{csv_name}_assigned_to_{self.cell_assignment_type}_nearest_cells"
+                df["Object ID"] = df["Object ID"].astype(
+                    int
+                )  # in case was converted to float
+                df.to_csv(output_name + ".csv", index=False)
+
+    def get_cell_assignments(self):
+        self.assign_to_cells()
+        self.write_updated_csvs()

cellmap_analyze-0.0.1/src/cellmap_analyze/analyze/fit_lines_to_segmentations.py

@@ -0,0 +1,157 @@
+# %%
+from funlib.geometry import Roi
+import numpy as np
+from cellmap_analyze.util.dask_util import (
+    dask_computer,
+    guesstimate_npartitions,
+    start_dask,
+)
+from cellmap_analyze.util import io_util
+from cellmap_analyze.util.image_data_interface import ImageDataInterface
+import logging
+import pandas as pd
+import dask.dataframe as dd
+from cellmap_analyze.util.neuroglancer_util import write_out_annotations
+import fastremap
+import cc3d
+
+logging.basicConfig(
+    format="%(asctime)s %(levelname)-8s %(message)s",
+    level=logging.INFO,
+    datefmt="%Y-%m-%d %H:%M:%S",
+)
+logger = logging.getLogger(__name__)
+
+
+class FitLinesToSegmentations:
+    def __init__(
+        self,
+        input_csv,
+        input_path,
+        output_csv=None,
+        output_annotations_dir=None,
+        num_workers=8,
+    ):
+        self.df = pd.read_csv(input_csv)  # , nrows=1000)
+        self.segmentation_idi = ImageDataInterface(input_path)
+        self.voxel_size = self.segmentation_idi.voxel_size
+        self.num_workers = num_workers
+        self.output_csv = output_csv
+        if self.output_csv is None:
+            self.output_csv = input_csv.replace(".csv", "_lines.csv")
+
+        self.output_annotations_dir = output_annotations_dir
+        self.compute_args = {}
+        if self.num_workers == 1:
+            self.compute_args = {"scheduler": "single-threaded"}
+
+    @staticmethod
+    def find_min_max_projected_points(points, line_point, line_direction):
+        # chatgpt
+        line_direction = line_direction / np.linalg.norm(
+            line_direction
+        )  # Normalize direction vector
+
+        # Calculate the vector from line_point to each point
+        point_vectors = points - line_point
+
+        # Calculate the projection scalar for each point using dot product and broadcasting
+        projection_scalars = np.sum(point_vectors * line_direction, axis=1)
+
+        # Calculate the projected points for each point
+        projected_points = (
+            line_point + projection_scalars[:, np.newaxis] * line_direction
+        )
+
+        # Find the minimum and maximum projection scalar indices
+        min_projection_idx = np.argmin(projection_scalars)
+        max_projection_idx = np.argmax(projection_scalars)
+
+        return (
+            projected_points[min_projection_idx],
+            projected_points[max_projection_idx],
+        )
+
+    @staticmethod
+    def fit_line_to_points(points, voxel_size, offset, line_origin):
+        # fit line to object voxels
+        _, _, vv = np.linalg.svd(points - np.mean(points, axis=0), full_matrices=False)
+        line_direction = vv[0]
+
+        # find endpoints of line segment so that we can write it as neuroglancer annotations
+        start_point, end_point = FitLinesToSegmentations.find_min_max_projected_points(
+            points * voxel_size + offset,
+            line_origin,
+            line_direction,
+        )
+
+        return start_point, end_point
+
+    @staticmethod
+    def fit_line_to_object(data, id, voxel_size, offset):
+        # only take largest component
+        data = cc3d.connected_components(data == id, connectivity=6, binary_image=True)
+        ids, counts = fastremap.unique(data[data > 0], return_counts=True)
+        id = ids[np.argmax(counts)]
+        points = np.column_stack(np.where(data == id))
+        com = np.mean(points, axis=0) * voxel_size + offset
+        start_point, end_point = FitLinesToSegmentations.fit_line_to_points(
+            points, voxel_size, offset, com
+        )
+        return start_point, end_point
+
+    def fit_lines_to_objects(self, df):
+        results_df = []
+        for _, row in df.iterrows():
+            id = row["Object ID"]
+            box_min = np.array([row[f"MIN {d} (nm)"] for d in ["Z", "Y", "X"]])
+            box_max = np.array([row[f"MAX {d} (nm)"] for d in ["Z", "Y", "X"]])
+            # define an roi to actually ecompass the bounding box
+            roi = Roi(
+                box_min - self.voxel_size, (box_max - box_min) + self.voxel_size * 2
+            )
+            data = self.segmentation_idi.to_ndarray_ts(roi)
+            line_start, line_end = FitLinesToSegmentations.fit_line_to_object(
+                data, id, self.voxel_size, roi.offset
+            )
+            result_df = pd.DataFrame([row])
+
+            for point_string, point_coords in zip(
+                ["Start", "End"], [line_start, line_end]
+            ):
+                for dim_idx, dim in enumerate(["Z", "Y", "X"]):
+                    result_df[f"Line {point_string} {dim} (nm)"] = point_coords[dim_idx]
+            results_df.append(result_df)
+
+        results_df = pd.concat(results_df, ignore_index=True)
+        return results_df
+
+    def get_fit_lines_to_segmentations(self):
+        # append column with default values to df
+        for s_e in ["Start", "End"]:
+            for dim in ["Z", "Y", "X"]:
+                self.df[f"Line {s_e} {dim} (nm)"] = np.nan
+
+        ddf = dd.from_pandas(
+            self.df, npartitions=guesstimate_npartitions(self.df, self.num_workers)
+        )
+
+        meta = pd.DataFrame(columns=self.df.columns)
+        ddf_out = ddf.map_partitions(self.fit_lines_to_objects, meta=meta)
+        with start_dask(self.num_workers, "line fits", logger):
+            with io_util.Timing_Messager("Fitting lines", logger):
+                # results = ddf_out.compute()
+                df = dask_computer(ddf_out, self.num_workers, **self.compute_args)
+        df["Object ID"] = df["Object ID"].astype(int)
+        df.to_csv(self.output_csv, index=False)
+
+        if self.output_annotations_dir is not None:
+            with io_util.Timing_Messager("Writing annotations", logger):
+                cols = [f"Line Start {d} (nm)" for d in ["Z", "Y", "X"]] + [
+                    f"Line End {d} (nm)" for d in ["Z", "Y", "X"]
+                ]
+                write_out_annotations(
+                    self.output_annotations_dir,
+                    df["Object ID"].values,
+                    df[cols].to_numpy(),
+                )