PyNutil 0.2.25__tar.gz → 0.3.0__tar.gz

{pynutil-0.2.25 → pynutil-0.3.0}/PKG-INFO

@@ -1,19 +1,19 @@
 Metadata-Version: 2.4
 Name: PyNutil
-Version: 0.2.25
+Version: 0.3.0
 Summary: a package to quantify atlas registered brain data
 Home-page: https://github.com/Neural-Systems-at-UIO/PyNutil
 License: MIT
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy
+Requires-Dist: numpy==2.4
 Requires-Dist: brainglobe-atlasapi
 Requires-Dist: pandas
-Requires-Dist: requests
 Requires-Dist: pynrrd
 Requires-Dist: xmltodict
 Requires-Dist: opencv-python
-Requires-Dist: scikit-image
+Requires-Dist: scipy
+Requires-Dist: nibabel
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
@@ -25,7 +25,12 @@ Dynamic: summary
 # PyNutil
 PyNutil is under development. 
 
-PyNutil is a Python library for brain-wide quantification and spatial analysis of features in serial section images from mouse and rat brain. It aims to replicate the Quantifier feature of the Nutil software (RRID: SCR_017183). It builds on registration to a standardised reference atlas with the QuickNII (RRID:SCR_016854) and VisuAlign software (RRID:SCR_017978) and feature extraction by segmentation with an image analysis software such as ilastik (RRID:SCR_015246). 
+**Warning:** There are known errors in the PyNutil reports (incorrect results). Please use Nutil until these are fixed. 
+
+PyNutil is a Python library for brain-wide quantification and spatial analysis of features in serial section images from the brain. It aims to replicate the Quantifier feature of the Nutil software (RRID: SCR_017183). 
+
+PyNutil is able to integrate outputs from atlas registration software and image segmentation software in order to produce atlas based quantifications, 3D point clouds, and 3D heatmaps of brain derived data. 
+![alt text](docs/assets/PyNutil_fig1.png)
 
 For more information about the QUINT workflow:
 https://quint-workflow.readthedocs.io/en/latest/ 
@@ -34,17 +39,26 @@ https://quint-workflow.readthedocs.io/en/latest/
 
 PyNutil can be run using a custom atlas in .nrrd format (e.g. tests/test_data/Allen_mouse_2017_atlas)  
 
-Pynutil can also be used with the atlases available in the [BrainGlobe_Atlas API](https://github.com/brainglobe/brainglobe-atlasapi). 
+PyNutil can also be used with the atlases available in the [BrainGlobe_Atlas API](https://GitHub.com/brainglobe/brainglobe-atlasapi). 
 
 # Installation
 ## Python package
 ```
-pip install PyNutil
+pip install PyNutil 
+```
+
+## Running demos
+
+The scripts in `demos/` assume PyNutil is importable as an installed package.
+For development, install in editable mode from the repository root:
+
+```bash
+pip install -e .
 ```
 ## GUI
-download the executable for windows and macOS via the [github releases tab](https://github.com/Neural-Systems-at-UIO/PyNutil/releases)
+download the executable for Windows and macOS via the [GitHub releases tab](https://GitHub.com/Neural-Systems-at-UIO/PyNutil/releases)
 
-![image](https://github.com/user-attachments/assets/c3b3ca11-f0ef-4e2c-96d7-498ecf96514d)
+![image](https://GitHub.com/user-attachments/assets/c3b3ca11-f0ef-4e2c-96d7-498ecf96514d)
 
 # Usage
 
@@ -74,8 +88,13 @@ pnt = PyNutil(
     alignment_json='../tests/test_data/non_linear_allen_mouse/alignment.json',
     colour=[0, 0, 0],
     atlas_name='allen_mouse_25um'
+    #If you would like to use cellpose segmentations add:
+    #cellpose = True
 )
 
+#optionally, if you want to generate a 3D heatmap
+pnt.interpolate_volume()
+
 pnt.get_coordinates(object_cutoff=0)
 
 pnt.quantify_coordinates()
@@ -85,23 +104,32 @@ pnt.save_analysis("PyNutil/test_result/myResults")
 PyNutil generates a series of reports in the folder which you specify.
 
 ## Per-Hemisphere Quantification
-If you use an atlas which has a hemisphere map (All brainglobe atlases have this, it is a volume in the shape of the atlas with 1 in the lft hemisphere and 2 in the right) PyNutil will generate per-hemisphere quantifications in addition to total numbers. In addition, PyNutil will also genearte additional per-hemisphere point cloud files for viewing in meshview.
+If you use an atlas which has a hemisphere map (All brainglobe atlases have this, it is a volume in the shape of the atlas with 1 in the left hemisphere and 2 in the right) PyNutil will generate per-hemisphere quantifications in addition to total numbers. In addition, PyNutil will also genearte additional per-hemisphere point cloud files for viewing in meshview.
 ## Damage Quantification
-[The QCAlign tool](https://www.nitrc.org/projects/qcalign) allows you to mark damaged areas on your section. This means that these damaged areas are excluded from your point clouds. In addition, PyNutil will seperately quantify damaged and undamaged areas. Note the undamaged, and damaged column names. 
+[The QCAlign tool](https://www.nitrc.org/projects/qcalign) allows you to mark damaged areas on your section. This means that these damaged areas are excluded from your point clouds. In addition, PyNutil will separately quantify damaged and undamaged areas. Note the undamaged and damaged column names. 
 # Meshview json files
-PyNutil will produce meshview json files. This can be opened in [MeshView for the Allen Mouse](https://meshview.apps.ebrains.eu/?atlas=ABA_Mouse_CCFv3_2017_25um) or for [the Waxholm Rat](https://meshview.apps.ebrains.eu/)
+PyNutil will produce meshview json files. These can be opened in [MeshView for the Allen Mouse](https://meshview.apps.ebrains.eu/?atlas=ABA_Mouse_CCFv3_2017_25um) or for [the Waxholm Rat](https://meshview.apps.ebrains.eu/)
 
 https://github.com/user-attachments/assets/d3a43ca9-133e-40d1-a1b9-9a359deabf2d 
 
+
+# Siibra explorer compatible NifTI  files
+If you have interpolated your volume you will find an interpolated NifTI volume in your output directory. This can be dragged and dropped directly into [siibra explorer](https://atlases.ebrains.eu/viewer/#/). If you share your data you can also include a shareable link to your data in the Siibra viewer. These files are also viewable in [ITK-SNAP](https://github.com/pyushkevich/itksnap). 
+
+
+
+https://github.com/user-attachments/assets/30ca7f7f-92f5-4d83-a92a-b29603181b8f
+
+
 # Interpreting the Results
 Each column name has the following definition
 | Column        | Definition                                                                          |
-|---------------|--------------------------------------------------------------------------------------|
+|---------------|-------------------------------------------------------------------------------------|
 | idx           | The atlas ID of the region.                                                         |
 | name          | The name of atlas region.                                                           |
-| r             | The amount of red in the RGB value for for the region colour.                       |
-| g             | The amount of green in the RGB value for for the region colour.                     |
-| b             | The amount of blue in the RGB value for for the region colour.                      |
+| r             | The amount of red in the RGB value for the region colour.                           |
+| g             | The amount of green in the RGB value for the region colour.                         |
+| b             | The amount of blue in the RGB value for the region colour.                          |
 | Region area   | Area representing the region on the segmentation in pixel values.                   |
 | Object count  | Number of objects located in the region. An object is a disconnected group of pixels|
 | Object pixels | Number of pixels representing objects in this region.                               |
@@ -111,9 +139,13 @@ Each column name has the following definition
 | Right hemi    | For each of the other columns, what is that value for the right hemisphere alone    |
 | Damaged       | For each of the other columns, what is that value for the areas marked damaged alone|
 | Undamaged     | For each of the other columns, what is that value for the areas marked undamaged alone|
-
+If you choose to measure the intensity of images rather than segmentations you will not get object counts. Instead you will get
+| Column        | Definition                                                                          |
+|---------------|-------------------------------------------------------------------------------------|
+| Sum intensity | The sum of all image pixels in a region.                                            |
+| Mean inensity | The mean of all image pixels in a region.                                           |
  # Feature Requests
-We are open to feature requests 😊 Simply open an issue in the github describing the feature you would like to see. 
+We are open to feature requests 😊 Simply open an issue in the GitHub describing the feature you would like to see. 
 
 # Acknowledgements
 PyNutil is developed at the Neural Systems Laboratory at the Institute of Basic Medical Sciences, University of Oslo, Norway with support from the EBRAINS infrastructure, and funding support from the European Union’s Horizon 2020 Framework Programme for Research and Innovation under the Framework Partnership Agreement No. 650003 (HBP FPA).
@@ -136,4 +168,4 @@ Carey H, Pegios M, Martin L, Saleeba C, Turner A, Everett N, Puchades M, Bjaalie
 Berg S., Kutra D., Kroeger T., Straehle C.N., Kausler B.X., Haubold C., et al. (2019) ilastik:interactive machine learning for (bio) image analysis. Nat Methods. 16, 1226–1232. https://doi.org/10.1038/s41592-019-0582-9
 
 # Contact us
-Report issues here on Github or email: support@ebrains.eu
+Report issues here on GitHub or email: support@ebrains.eu

pynutil-0.3.0/PyNutil/config.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+
+def _unwrap_singleton_list(value: Any) -> Any:
+    """Unwrap legacy settings fields like [null] -> None, ["x"] -> "x"."""
+    if isinstance(value, list) and len(value) == 1:
+        return value[0]
+    return value
+
+
+@dataclass
+class PyNutilConfig:
+    segmentation_folder: Optional[str] = None
+    image_folder: Optional[str] = None
+    alignment_json: Optional[str] = None
+    colour: Optional[list] = None
+    intensity_channel: Optional[str] = None
+    atlas_name: Optional[str] = None
+    atlas_path: Optional[str] = None
+    label_path: Optional[str] = None
+    hemi_path: Optional[str] = None
+    custom_region_path: Optional[str] = None
+    voxel_size_um: Optional[float] = None
+    min_intensity: Optional[int] = None
+    max_intensity: Optional[int] = None
+    cellpose: bool = False
+
+    @classmethod
+    def from_settings_file(cls, settings_file: str) -> "PyNutilConfig":
+        with open(settings_file, "r") as f:
+            settings = json.load(f)
+        return cls.from_settings_dict(settings)
+
+    @classmethod
+    def from_settings_dict(cls, settings: Dict[str, Any]) -> "PyNutilConfig":
+        # Be tolerant of legacy settings saved as singleton lists.
+        def g(key: str, default: Any = None) -> Any:
+            return _unwrap_singleton_list(settings.get(key, default))
+
+        # alignment_json is required in settings files.
+        if "alignment_json" not in settings:
+            raise KeyError(
+                "Settings file must contain alignment_json, and either atlas_path and label_path or atlas_name. It should also contain either segmentation_folder or image_folder."
+            )
+
+        cfg = cls(
+            segmentation_folder=g("segmentation_folder"),
+            image_folder=g("image_folder"),
+            alignment_json=settings["alignment_json"],
+            colour=g("colour"),
+            intensity_channel=g("intensity_channel"),
+            atlas_name=g("atlas_name"),
+            atlas_path=g("atlas_path"),
+            label_path=g("label_path"),
+            hemi_path=g("hemi_path"),
+            custom_region_path=g("custom_region_path"),
+            voxel_size_um=g("voxel_size_um"),
+            min_intensity=g("min_intensity"),
+            max_intensity=g("max_intensity"),
+            cellpose=bool(g("cellpose", False)),
+        )
+
+        # If atlas_path/label_path are present but empty/null, treat as not provided.
+        if not cfg.atlas_path or not cfg.label_path:
+            cfg.atlas_path = None
+            cfg.label_path = None
+            cfg.hemi_path = None
+
+        return cfg
+
+    def normalize(self, *, logger=None) -> "PyNutilConfig":
+        # If atlas_name is provided, voxel size is inferred from atlas name and
+        # any manually provided voxel_size_um is ignored (existing behavior).
+        if self.atlas_name is not None and self.voxel_size_um is not None:
+            if logger is not None:
+                logger.warning(
+                    f"Voxel size ({self.voxel_size_um} um) was specified but will be ignored because atlas_name ({self.atlas_name}) is provided. Voxel size will be inferred from the atlas name."
+                )
+            self.voxel_size_um = None
+        return self
+
+    def validate(self) -> None:
+        if self.segmentation_folder and self.image_folder:
+            raise ValueError(
+                "Please specify either segmentation_folder or image_folder, not both."
+            )
+
+        if self.segmentation_folder and (
+            self.min_intensity is not None or self.max_intensity is not None
+        ):
+            raise ValueError(
+                "min_intensity and max_intensity are only supported when using image_folder, not segmentation_folder."
+            )
+
+        if self.image_folder and (self.colour is not None):
+            raise ValueError(
+                "You can't specify both colour and image_folder since there are no segmentations"
+            )
+
+        if (self.atlas_path or self.label_path) and self.atlas_name:
+            raise ValueError(
+                "Please specify either atlas_path and label_path or atlas_name. Atlas and label paths are only used for loading custom atlases."
+            )
+
+        if not (self.atlas_path and self.label_path) and not self.atlas_name:
+            raise ValueError(
+                "When atlas_path and label_path are not specified, atlas_name must be specified."
+            )

{pynutil-0.2.25 → pynutil-0.3.0}/PyNutil/io/atlas_loader.py

@@ -2,6 +2,8 @@ import brainglobe_atlasapi
 import pandas as pd
 import numpy as np
 import nrrd
+from functools import lru_cache
+
 
 def load_atlas_labels(atlas=None, atlas_name=None):
     if atlas_name:
@@ -23,6 +25,8 @@ def load_atlas_labels(atlas=None, atlas_name=None):
     atlas_labels = pd.DataFrame(atlas_structures)
     return atlas_labels
 
+
+@lru_cache(maxsize=8)
 def load_atlas_data(atlas_name):
     """
     Loads atlas data using the brainglobe_atlasapi.
@@ -66,32 +70,18 @@ def process_atlas_volume(vol):
     return np.transpose(vol, [2, 0, 1])[::-1, ::-1, ::-1]
 
 
+@lru_cache(maxsize=8)
 def load_custom_atlas(atlas_path, hemi_path, label_path):
     """
     Loads a custom atlas from provided file paths.
-
-    Parameters
-    ----------
-    atlas_path : str
-        Path to the custom atlas volume file.
-    hemi_path : str or None
-        Path to the hemisphere file, if any.
-    label_path : str
-        Path to the label CSV file for region info.
-
-    Returns
-    -------
-    numpy.ndarray
-        The loaded atlas volume.
-    numpy.ndarray or None
-        The hemisphere array, or None if hemi_path is not provided.
-    pandas.DataFrame
-        A dataframe containing atlas labels.
     """
     atlas_volume, _ = nrrd.read(atlas_path)
+
     if hemi_path:
         hemi_volume, _ = nrrd.read(hemi_path)
     else:
         hemi_volume = None
+
     atlas_labels = pd.read_csv(label_path)
+
     return atlas_volume, hemi_volume, atlas_labels

{pynutil-0.2.25 → pynutil-0.3.0}/PyNutil/io/file_operations.py

@@ -3,6 +3,17 @@ import json
 from .read_and_write import write_hemi_points_to_meshview
 
 
+def _ensure_analysis_output_dirs(output_folder: str) -> None:
+    os.makedirs(output_folder, exist_ok=True)
+    for subdir in (
+        "whole_series_report",
+        "per_section_meshview",
+        "per_section_reports",
+        "whole_series_meshview",
+    ):
+        os.makedirs(f"{output_folder}/{subdir}", exist_ok=True)
+
+
 def save_analysis_output(
     pixel_points,
     centroids,
@@ -18,14 +29,18 @@ def save_analysis_output(
     atlas_labels,
     output_folder,
     segmentation_folder=None,
+    image_folder=None,
     alignment_json=None,
     colour=None,
+    intensity_channel=None,
     atlas_name=None,
     custom_region_path=None,
     atlas_path=None,
     label_path=None,
     settings_file=None,
     prepend=None,
+    point_intensities=None,
+    **kwargs,
 ):
     """
     Save the analysis output to the specified folder.
@@ -37,10 +52,14 @@ def save_analysis_output(
         The folder where the output will be saved.
     segmentation_folder : str, optional
         The folder containing the segmentation files (default is None).
+    image_folder : str, optional
+        The folder containing the original images (default is None).
     alignment_json : str, optional
         The path to the alignment JSON file (default is None).
     colour : list, optional
         The RGB colour of the object to be quantified in the segmentation (default is None).
+    intensity_channel : str, optional
+        The channel used for intensity quantification (default is None).
     atlas_name : str, optional
         The name of the atlas in the brainglobe api to be used for quantification (default is None).
     atlas_path : str, optional
@@ -51,83 +70,67 @@ def save_analysis_output(
         The path to the settings file that was used (default is None).
     """
     # Create the output folder if it doesn't exist
-    os.makedirs(output_folder, exist_ok=True)
-    os.makedirs(f"{output_folder}/whole_series_report", exist_ok=True)
-    os.makedirs(f"{output_folder}/per_section_meshview", exist_ok=True)
-    os.makedirs(f"{output_folder}/per_section_reports", exist_ok=True)
-    os.makedirs(f"{output_folder}/whole_series_meshview", exist_ok=True)
+    _ensure_analysis_output_dirs(output_folder)
     # Filter out rows where 'region_area' is 0 in label_df
     # if label_df is not None and "region_area" in label_df.columns:
     #     label_df = label_df[label_df["region_area"] != 0]
     if label_df is not None:
+        report_name = "intensity.csv" if image_folder else "counts.csv"
         label_df.to_csv(
-            f"{output_folder}/whole_series_report/{prepend}counts.csv",
+            f"{output_folder}/whole_series_report/{prepend}{report_name}",
             sep=";",
             na_rep="",
             index=False,
         )
-    else:
+    elif not prepend:
         print("No quantification found, so only coordinates will be saved.")
         print(
             "If you want to save the quantification, please run quantify_coordinates."
         )
 
-    _save_per_section_reports(
-        per_section_df,
-        segmentation_filenames,
-        points_len,
-        centroids_len,
-        pixel_points,
-        centroids,
-        labeled_points,
-        labeled_points_centroids,
-        points_hemi_labels,
-        centroids_hemi_labels,
-        atlas_labels,
-        output_folder,
-        prepend,
-    )
-    _save_whole_series_meshview(
-        pixel_points,
-        labeled_points,
-        centroids,
-        labeled_points_centroids,
-        points_hemi_labels,
-        centroids_hemi_labels,
-        atlas_labels,
-        output_folder,
-        prepend,
-    )
+    if per_section_df is not None and segmentation_filenames is not None:
+        _save_per_section_reports(
+            per_section_df,
+            segmentation_filenames,
+            points_len,
+            centroids_len,
+            pixel_points,
+            centroids,
+            labeled_points,
+            labeled_points_centroids,
+            points_hemi_labels,
+            centroids_hemi_labels,
+            atlas_labels,
+            output_folder,
+            prepend,
+            point_intensities,
+            colormap=kwargs.get("colormap", "gray"),
+        )
+    if pixel_points is not None:
+        _save_whole_series_meshview(
+            pixel_points,
+            labeled_points,
+            centroids,
+            labeled_points_centroids,
+            points_hemi_labels,
+            centroids_hemi_labels,
+            atlas_labels,
+            output_folder,
+            prepend,
+            point_intensities,
+            colormap=kwargs.get("colormap", "gray"),
+        )
 
     # Save settings to JSON file for reference
     settings_dict = {
         "segmentation_folder": segmentation_folder,
+        "image_folder": image_folder,
         "alignment_json": alignment_json,
         "colour": colour,
+        "intensity_channel": intensity_channel,
         "custom_region_path": custom_region_path,
     }
-    pixel_points,
-    centroids,
-    label_df,
-    per_section_df,
-    labeled_points,
-    labeled_points_centroids,
-    points_hemi_labels,
-    centroids_hemi_labels,
-    points_len,
-    centroids_len,
-    segmentation_filenames,
-    atlas_labels,
-    output_folder,
-    segmentation_folder = (None,)
-    alignment_json = (None,)
-    colour = (None,)
-    atlas_name = (None,)
-    custom_region_path = (None,)
-    atlas_path = (None,)
-    label_path = (None,)
-    settings_file = (None,)
-    prepend = (None,)
+
     # Add atlas information to settings
     if atlas_name:
         settings_dict["atlas_name"] = atlas_name
@@ -137,8 +140,7 @@ def save_analysis_output(
         settings_dict["label_path"] = label_path
     if settings_file:
         settings_dict["settings_file"] = settings_file
-    if custom_region_path:
-        settings_dict["custom_region_path"] = custom_region_path
+
     # Write settings to file
     settings_file_path = os.path.join(output_folder, "pynutil_settings.json")
     with open(settings_file_path, "w") as f:
@@ -159,10 +161,18 @@ def _save_per_section_reports(
     atlas_labels,
     output_folder,
     prepend,
+    point_intensities=None,
+    colormap="gray",
 ):
     prev_pl = 0
     prev_cl = 0
 
+    # Handle None for points_len and centroids_len (e.g. in intensity mode)
+    if points_len is None:
+        points_len = [0] * len(segmentation_filenames)
+    if centroids_len is None:
+        centroids_len = [0] * len(segmentation_filenames)
+
     for pl, cl, fn, df in zip(
         points_len,
         centroids_len,
@@ -176,22 +186,27 @@ def _save_per_section_reports(
             na_rep="",
             index=False,
         )
-        _save_per_section_meshview(
-            split_fn,
-            pl,
-            cl,
-            prev_pl,
-            prev_cl,
-            pixel_points,
-            centroids,
-            labeled_points,
-            labeled_points_centroids,
-            points_hemi_labels,
-            centroids_hemi_labels,
-            atlas_labels,
-            output_folder,
-            prepend,
-        )
+        if pixel_points is not None or centroids is not None:
+            _save_per_section_meshview(
+                split_fn,
+                pl,
+                cl,
+                prev_pl,
+                prev_cl,
+                pixel_points,
+                centroids,
+                labeled_points,
+                labeled_points_centroids,
+                points_hemi_labels,
+                centroids_hemi_labels,
+                atlas_labels,
+                output_folder,
+                prepend,
+                point_intensities[prev_pl : pl + prev_pl]
+                if point_intensities is not None
+                else None,
+                colormap=colormap,
+            )
         prev_cl += cl
         prev_pl += pl
 
@@ -211,21 +226,29 @@ def _save_per_section_meshview(
     atlas_labels,
     output_folder,
     prepend,
+    point_intensities=None,
+    colormap="gray",
 ):
     write_hemi_points_to_meshview(
-        pixel_points[prev_pl : pl + prev_pl],
-        labeled_points[prev_pl : pl + prev_pl],
-        points_hemi_labels[prev_pl : pl + prev_pl],
+        pixel_points[prev_pl : pl + prev_pl] if pixel_points is not None else None,
+        labeled_points[prev_pl : pl + prev_pl] if labeled_points is not None else None,
+        points_hemi_labels[prev_pl : pl + prev_pl]
+        if points_hemi_labels is not None
+        else None,
         f"{output_folder}/per_section_meshview/{prepend}{split_fn}_pixels.json",
         atlas_labels,
+        point_intensities,
+        colormap=colormap,
     )
-    write_hemi_points_to_meshview(
-        centroids[prev_cl : cl + prev_cl],
-        labeled_points_centroids[prev_cl : cl + prev_cl],
-        centroids_hemi_labels[prev_cl : cl + prev_cl],
-        f"{output_folder}/per_section_meshview/{prepend}{split_fn}_centroids.json",
-        atlas_labels,
-    )
+    if centroids is not None:
+        write_hemi_points_to_meshview(
+            centroids[prev_cl : cl + prev_cl],
+            labeled_points_centroids[prev_cl : cl + prev_cl],
+            centroids_hemi_labels[prev_cl : cl + prev_cl],
+            f"{output_folder}/per_section_meshview/{prepend}{split_fn}_centroids.json",
+            atlas_labels,
+            colormap=colormap,
+        )
 
 
 def _save_whole_series_meshview(
@@ -238,6 +261,8 @@ def _save_whole_series_meshview(
     atlas_labels,
     output_folder,
     prepend,
+    point_intensities=None,
+    colormap="gray",
 ):
     write_hemi_points_to_meshview(
         pixel_points,
@@ -245,11 +270,15 @@ def _save_whole_series_meshview(
         points_hemi_labels,
         f"{output_folder}/whole_series_meshview/{prepend}pixels_meshview.json",
         atlas_labels,
+        point_intensities,
+        colormap=colormap,
     )
-    write_hemi_points_to_meshview(
-        centroids,
-        labeled_points_centroids,
-        centroids_hemi_labels,
-        f"{output_folder}/whole_series_meshview/{prepend}objects_meshview.json",
-        atlas_labels,
-    )
+    if centroids is not None:
+        write_hemi_points_to_meshview(
+            centroids,
+            labeled_points_centroids,
+            centroids_hemi_labels,
+            f"{output_folder}/whole_series_meshview/{prepend}objects_meshview.json",
+            atlas_labels,
+            colormap=colormap,
+        )

pynutil-0.3.0/PyNutil/io/nifti_writer.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+import numpy as np
+
+
+def write_nifti(
+    volume: np.ndarray,
+    voxel_size_um: float,
+    output_path: str,
+    origin_offsets_um: Optional[np.ndarray] = None,
+) -> None:
+    """Write a NIfTI volume with a microns-based affine.
+
+    The header is written with both qform and sform set and units set to microns.
+
+    Args:
+        volume: 3D volume array. Saved as uint8.
+        voxel_size_um: Isotropic voxel size in microns.
+        output_path: Output path without extension; ".nii.gz" is appended.
+        origin_offsets_um: Optional XYZ translation offsets in microns.
+    """
+
+    try:
+        import nibabel as nib  # type: ignore
+    except Exception as exc:  # pragma: no cover
+        raise ImportError("nibabel is required for write_nifti") from exc
+
+    if origin_offsets_um is None:
+        origin_offsets_um = np.array([0, 0, 0], dtype=np.float32)
+
+    dims = np.array(volume.shape, dtype=np.float32)
+    affine = np.eye(4, dtype=np.float32)
+    affine[:3, :3] *= float(voxel_size_um)
+    affine[:3, 3] = -0.5 * dims * float(voxel_size_um) + np.asarray(
+        origin_offsets_um, dtype=np.float32
+    )
+
+    img = nib.Nifti1Image(np.asarray(volume, dtype=np.uint8), affine)
+    img.set_qform(affine, code=1)
+    img.set_sform(affine, code=1)
+    img.header["xyzt_units"] = 3
+
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    nib.save(img, output_path + ".nii.gz")