siibra 1.0a9__py3-none-any.whl → 1.0a11__py3-none-any.whl

siibra/features/tabular/regional_timeseries_activity.py

@@ -18,7 +18,7 @@ from ..feature import Compoundable
 
 from ...core import region as _region
 from .. import anchor as _anchor
-from ...commons import QUIET
+from ...commons import QUIET, siibra_tqdm
 from ...locations import pointset
 from ...retrieval.repositories import RepositoryConnector
 from ...retrieval.requests import HttpRequest
@@ -48,7 +48,8 @@ class RegionalTimeseriesActivity(tabular.Tabular, Compoundable):
         timestep: str,
         description: str = "",
         datasets: list = [],
-        subject: str = "average"
+        subject: str = "average",
+        id: str = None
     ):
         """
         """
@@ -58,7 +59,8 @@ class RegionalTimeseriesActivity(tabular.Tabular, Compoundable):
             description=description,
             anchor=anchor,
             datasets=datasets,
-            data=None  # lazy loading below
+            data=None,  # lazy loading below
+            id=id
         )
         self.cohort = cohort.upper()
         if isinstance(connector, str) and connector:
@@ -75,12 +77,12 @@ class RegionalTimeseriesActivity(tabular.Tabular, Compoundable):
 
     @property
     def subject(self):
-        """Returns the subject identifiers for which the matrix represents."""
+        """Returns the subject identifiers for which the table represents."""
         return self._subject
 
     @property
     def name(self):
-        return f"{super().name} with cohort {self.cohort} - subject {self.subject}"
+        return f"{self.subject} - " + super().name + f" cohort: {self.cohort}"
 
     @property
     def data(self) -> pd.DataFrame:
@@ -91,16 +93,61 @@ class RegionalTimeseriesActivity(tabular.Tabular, Compoundable):
             self._load_table()
         return self._table.copy()
 
+    @classmethod
+    def _merge_elements(
+        cls,
+        elements: List["RegionalTimeseriesActivity"],
+        description: str,
+        modality: str,
+        anchor: _anchor.AnatomicalAnchor,
+    ):
+        assert len({f.cohort for f in elements}) == 1
+        assert len({f.timestep for f in elements}) == 1
+        merged = cls(
+            cohort=elements[0].cohort,
+            regions=elements[0].regions,
+            connector=elements[0]._connector,
+            decode_func=elements[0]._decode_func,
+            filename="",
+            timestep=" ".join(str(val) for val in elements[0].timestep),
+            subject="average",
+            description=description,
+            modality=modality,
+            anchor=anchor,
+            **{"paradigm": "average"} if getattr(elements[0], "paradigm") else {}
+        )
+        if isinstance(elements[0]._connector, HttpRequest):
+            getter = lambda elm: elm._connector.get()
+        else:
+            getter = lambda elm: elm._connector.get(elm._filename, decode_func=elm._decode_func)
+        all_arrays = [
+            getter(elm)
+            for elm in siibra_tqdm(
+                elements,
+                total=len(elements),
+                desc=f"Averaging {len(elements)} activity tables"
+            )
+        ]
+        merged._table = elements[0]._arraylike_to_dataframe(
+            np.stack(all_arrays).mean(0)
+        )
+        return merged
+
     def _load_table(self):
         """
         Extract the timeseries table.
         """
-        array = self._connector.get(self._filename, decode_func=self._decode_func)
+        if isinstance(self._connector, HttpRequest):
+            array = self._connector.data
+        else:
+            array = self._connector.get(self._filename, decode_func=self._decode_func)
+        self._table = self._arraylike_to_dataframe(array)
+
+    def _arraylike_to_dataframe(self, array: Union[np.ndarray, pd.DataFrame]) -> pd.DataFrame:
         if not isinstance(array, np.ndarray):
-            assert isinstance(array, pd.DataFrame)
             array = array.to_numpy()
         ncols = array.shape[1]
-        self._table = pd.DataFrame(
+        table = pd.DataFrame(
             array,
             index=pd.TimedeltaIndex(
                 np.arange(0, array.shape[0]) * self.timestep[0],
@@ -121,7 +168,9 @@ class RegionalTimeseriesActivity(tabular.Tabular, Compoundable):
                 label - min(columnmap.keys()): region
                 for label, region in columnmap.items()
             }
-            self._table = self._table.rename(columns=remapper)
+            table = table.rename(columns=remapper)
+
+        return table
 
     def __str__(self):
         return self.name
@@ -240,4 +289,4 @@ class RegionalBOLD(
 
     @property
     def name(self):
-        return f"{super().name}, paradigm {self.paradigm}"
+        return super().name + f", paradigm: {self.paradigm}"

siibra/features/tabular/tabular.py

@@ -44,14 +44,16 @@ class Tabular(feature.Feature):
         modality: str,
         anchor: _anchor.AnatomicalAnchor,
         data: pd.DataFrame,  # sample x feature dimension
-        datasets: list = []
+        datasets: list = [],
+        id: str = None
     ):
         feature.Feature.__init__(
             self,
             modality=modality,
             description=description,
             anchor=anchor,
-            datasets=datasets
+            datasets=datasets,
+            id=id
         )
         self._data_cached = data
 

siibra/livequeries/bigbrain.py

@@ -22,6 +22,7 @@ from ..commons import logger
 from ..locations import point, pointset
 from ..core import structure
 from ..retrieval import requests, cache
+from ..retrieval.datasets import GenericDataset
 
 import numpy as np
 from typing import List
@@ -37,6 +38,37 @@ class WagstylProfileLoader:
     _profiles = None
     _vertices = None
     _boundary_depths = None
+    DATASET = GenericDataset(
+        name="HIBALL workshop on cortical layers",
+        contributors=[
+            'Konrad Wagstyl',
+            'Stéphanie Larocque',
+            'Guillem Cucurull',
+            'Claude Lepage',
+            'Joseph Paul Cohen',
+            'Sebastian Bludau',
+            'Nicola Palomero-Gallagher',
+            'Lindsay B. Lewis',
+            'Thomas Funck',
+            'Hannah Spitzer',
+            'Timo Dickscheid',
+            'Paul C. Fletcher',
+            'Adriana Romero',
+            'Karl Zilles',
+            'Katrin Amunts',
+            'Yoshua Bengio',
+            'Alan C. Evans'
+        ],
+        url="https://github.com/kwagstyl/cortical_layers_tutorial/",
+        description="Cortical profiles of BigBrain staining intensities computed by Konrad Wagstyl, "
+        "as described in the publication 'Wagstyl, K., et al (2020). BigBrain 3D atlas of "
+        "cortical layers: Cortical and laminar thickness gradients diverge in sensory and "
+        "motor cortices. PLoS Biology, 18(4), e3000678. "
+        "http://dx.doi.org/10.1371/journal.pbio.3000678."
+        "The data is taken from the tutorial at "
+        "https://github.com/kwagstyl/cortical_layers_tutorial. Each vertex is "
+        "assigned to the regional map when queried."
+    )
 
     def __init__(self):
         if self._profiles is None:
@@ -113,6 +145,7 @@ class BigBrainProfileQuery(query.LiveQuery, args=[], FeatureType=bigbrain_intens
                 qualification=_anchor.Qualification.CONTAINED,
                 explanation=f"Surface vertex of BigBrain cortical profile was filtered using {concept}"
             )
+            prof.datasets = [WagstylProfileLoader.DATASET]
             features.append(prof)
 
         return features
@@ -159,5 +192,6 @@ class LayerwiseBigBrainIntensityQuery(query.LiveQuery, args=[], FeatureType=laye
             qualification=_anchor.Qualification.CONTAINED,
             explanation=f"Surface vertices of BigBrain cortical profiles were filtered using {concept}"
         )
+        result.datasets = [WagstylProfileLoader.DATASET]
 
         return [result]

siibra/retrieval/cache.py

@@ -121,15 +121,20 @@ class Cache:
         """ Iterate all element names in the cache directory. """
         return (os.path.join(self.folder, f) for f in os.listdir(self.folder))
 
-    def build_filename(self, str_rep: str, suffix=None):
-        """Generate a filename in the cache.
-
-        Args:
-            str_rep (str): Unique string representation of the item. Will be used to compute a hash.
-            suffix (str, optional): Optional file suffix, in order to allow filetype recognition by the name. Defaults to None.
-
-        Returns:
-            filename
+    def build_filename(self, str_rep: str, suffix=None) -> str:
+        """
+        Generate a filename in the cache.
+
+        Parameters
+        ----------
+        str_rep: str
+            Unique string representation of the item. Will be used to compute a hash.
+        suffix: str. Default: None
+            Optional file suffix, in order to allow filetype recognition by the name.
+
+        Returns
+        -------
+            str
         """
         hashfile = os.path.join(
             self.folder, str(hashlib.sha256(str_rep.encode("ascii")).hexdigest())

siibra/retrieval/requests.py

@@ -30,7 +30,7 @@ import json
 from zipfile import ZipFile
 import requests
 import os
-from nibabel import Nifti1Image, GiftiImage, streamlines
+from nibabel import Nifti1Image, GiftiImage, streamlines, freesurfer
 from skimage import io as skimage_io
 import gzip
 from io import BytesIO
@@ -48,6 +48,34 @@ if TYPE_CHECKING:
 
 USER_AGENT_HEADER = {"User-Agent": f"siibra-python/{__version__}"}
 
+
+def read_as_bytesio(function: Callable, suffix: str, bytesio: BytesIO):
+    """
+    Helper method to provide BytesIO to methods that only takes file path and
+    cannot handle BytesIO normally (e.g., `nibabel.freesurfer.read_annot()`).
+
+    Writes the bytes to a temporary file on cache and reads with the
+    original function.
+
+    Parameters
+    ----------
+    function : Callable
+    suffix : str
+        Must match the suffix expected by the function provided.
+    bytesio : BytesIO
+
+    Returns
+    -------
+    Return type of the provided function.
+    """
+    tempfile = CACHE.build_filename(f"temp_{suffix}") + suffix
+    with open(tempfile, "wb") as bf:
+        bf.write(bytesio.getbuffer())
+    result = function(tempfile)
+    os.remove(tempfile)
+    return result
+
+
 DECODERS = {
     ".nii": lambda b: Nifti1Image.from_bytes(b),
     ".gii": lambda b: GiftiImage.from_bytes(b),
@@ -59,6 +87,7 @@ DECODERS = {
     ".zip": lambda b: ZipFile(BytesIO(b)),
     ".png": lambda b: skimage_io.imread(BytesIO(b)),
     ".npy": lambda b: np.load(BytesIO(b)),
+    ".annot": lambda b: read_as_bytesio(freesurfer.read_annot, '.annot', BytesIO(b)),
 }
 
 

siibra/volumes/parcellationmap.py

@@ -21,7 +21,7 @@ from ..commons import (
     MapIndex,
     MapType,
     compare_arrays,
-    resample_array_to_array,
+    resample_img_to_img,
     connected_components,
     clear_name,
     create_key,
@@ -512,10 +512,10 @@ class Map(concept.AtlasConcept, configuration_folder="maps"):
             raise RuntimeError("The map cannot be merged since there are no multiple volumes or fragments.")
 
         # initialize empty volume according to the template
-        template = self.space.get_template().fetch(**kwargs)
-        result_data = np.zeros_like(np.asanyarray(template.dataobj))
-        result_affine = template.affine
-        voxelwise_max = np.zeros_like(result_data)
+        template_img = self.space.get_template().fetch(**kwargs)
+        result_arr = np.zeros_like(np.asanyarray(template_img.dataobj))
+        result_affine = template_img.affine
+        voxelwise_max = np.zeros_like(result_arr)
         interpolation = 'nearest' if self.is_labelled else 'linear'
         next_labelindex = 1
         region_indices = defaultdict(list)
@@ -532,13 +532,13 @@ class Map(concept.AtlasConcept, configuration_folder="maps"):
             ):
                 mapindex = MapIndex(volume=volidx, fragment=frag)
                 img = self.fetch(mapindex)
-                if np.linalg.norm(result_affine - img.affine) > 1e-14:
+                if np.allclose(img.affine, result_affine):
+                    img_data = np.asanyarray(img.dataobj)
+                else:
                     logger.debug(f"Compression requires to resample volume {volidx} ({interpolation})")
-                    img_data = resample_array_to_array(
-                        img.get_fdata(), img.affine, result_data, result_affine
+                    img_data = np.asanyarray(
+                        resample_img_to_img(img, template_img).dataobj
                     )
-                else:
-                    img_data = img.get_fdata()
 
                 if self.is_labelled:
                     labels = set(np.unique(img_data)) - {0}
@@ -557,7 +557,7 @@ class Map(concept.AtlasConcept, configuration_folder="maps"):
                         update_voxels = (img_data > voxelwise_max)
                     else:
                         update_voxels = (img_data == label)
-                    result_data[update_voxels] = next_labelindex
+                    result_arr[update_voxels] = next_labelindex
                     voxelwise_max[update_voxels] = img_data[update_voxels]
                     next_labelindex += 1
 
@@ -568,7 +568,7 @@ class Map(concept.AtlasConcept, configuration_folder="maps"):
             parcellation_spec=self._parcellation_spec,
             indices=region_indices,
             volumes=[_volume.from_array(
-                result_data, result_affine, self._space_spec, name=self.name + " compressed"
+                result_arr, result_affine, self._space_spec, name=self.name + " compressed"
             )]
         )
 
@@ -973,7 +973,7 @@ class Map(concept.AtlasConcept, configuration_folder="maps"):
         """
         assign a PointSet to this parcellation map.
 
-        Parameters:
+        Parameters
         -----------
         lower_threshold: float, default: 0
             Lower threshold on values in the statistical map. Values smaller than
@@ -1076,7 +1076,7 @@ class Map(concept.AtlasConcept, configuration_folder="maps"):
         """
         Assign an image volume to this parcellation map.
 
-        Parameters:
+        Parameters
         -----------
         queryvolume: Volume
             the volume to be compared with maps
@@ -1101,7 +1101,6 @@ class Map(concept.AtlasConcept, configuration_folder="maps"):
             iter_components = lambda arr: [(0, arr)]
 
         queryimg = queryvolume.fetch()
-        queryimgarr = np.asanyarray(queryimg.dataobj)
         assignments = []
         all_indices = [
             index
@@ -1120,11 +1119,8 @@ class Map(concept.AtlasConcept, configuration_folder="maps"):
                 region_map_arr = np.asanyarray(region_map.dataobj)
                 # the shape and affine are checked by `nilearn.image.resample_to_img()`
                 # and returns the original data if resampling is not necessary.
-                queryimgarr_res = resample_array_to_array(
-                    queryimgarr,
-                    queryimg.affine,
-                    region_map_arr,
-                    region_map.affine
+                queryimgarr_res = np.asanyarray(
+                    resample_img_to_img(queryimg, region_map).dataobj
                 )
                 for compmode, voxelmask in iter_components(queryimgarr_res):
                     scores = compare_arrays(
@@ -1159,7 +1155,7 @@ def from_volume(
     """
     Add a custom labelled parcellation map to siibra from a labelled NIfTI file.
 
-    Parameters:
+    Parameters
     ------------
     name: str
         Human-readable name of the parcellation.

siibra/volumes/providers/__init__.py

@@ -17,3 +17,4 @@
 from .neuroglancer import NeuroglancerProvider, NeuroglancerMesh
 from .nifti import NiftiProvider
 from .gifti import GiftiSurfaceLabeling, GiftiMesh
+from .freesurfer import ZippedFreesurferAnnot, FreesurferAnnot

siibra/volumes/providers/freesurfer.py

@@ -0,0 +1,113 @@
+# Copyright 2018-2021
+# Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Handles reading and preparing gii files."""
+
+from . import provider as _provider
+
+from ...retrieval.requests import HttpRequest, ZipfileRequest
+
+import numpy as np
+from typing import Union, Dict, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...locations import boundingbox as _boundingbox
+
+
+class FreesurferAnnot(_provider.VolumeProvider, srctype="freesurfer-annot"):
+    def __init__(self, url: Union[str, dict]):
+        self._init_url = url
+        if isinstance(url, str):  # single mesh labelling
+            self._loaders = {None: HttpRequest(url)}
+        elif isinstance(url, dict):   # named label fragments
+            self._loaders = {lbl: HttpRequest(u) for lbl, u in url.items()}
+        else:
+            raise NotImplementedError(f"Urls for {self.__class__.__name__} are expected to be of type str.")
+
+    def fetch(self, fragment: str = None, label: int = None, **kwargs):
+        """Returns a 1D numpy array of label indices."""
+        vertex_labels = []
+        if fragment is None:
+            matched_frags = list(self._loaders.keys())
+        else:
+            matched_frags = [frg for frg in self._loaders.keys() if fragment.lower() in frg.lower()]
+            if len(matched_frags) != 1:
+                raise ValueError(
+                    f"Requested fragment '{fragment}' could not be matched uniquely "
+                    f"to [{', '.join(self._loaders)}]"
+                )
+        for frag in matched_frags:
+            frag_labels, *_ = self._loaders[frag].data
+            if label is not None:  # create the mask
+                selected_label = frag_labels == label
+                frag_labels[selected_label] = 1
+                frag_labels[~selected_label] = 0
+            else:
+                frag_labels[frag_labels == -1] = 0  # annot files store backgorund as -1 while siibra uses 0
+            vertex_labels.append(frag_labels)
+
+        return {"labels": np.hstack(vertex_labels)}
+
+    def get_boundingbox(self, clip=False, background=0.0) -> '_boundingbox.BoundingBox':
+        raise NotImplementedError(
+            f"Bounding box access to {self.__class__.__name__} objects not yet implemented."
+        )
+
+    @property
+    def _url(self) -> Union[str, Dict[str, str]]:
+        return self._init_url
+
+
+class ZippedFreesurferAnnot(_provider.VolumeProvider, srctype="zip/freesurfer-annot"):
+    def __init__(self, url: Union[str, dict]):
+        self._init_url = url
+        if isinstance(url, str):  # single mesh labelling
+            self._loaders = {None: ZipfileRequest(*url.split(" "))}
+        elif isinstance(url, dict):   # named label fragments
+            self._loaders = {lbl: ZipfileRequest(*u.split(" ")) for lbl, u in url.items()}
+        else:
+            raise NotImplementedError(f"Urls for {self.__class__.__name__} are expected to be of type str.")
+
+    def fetch(self, fragment: str = None, label: int = None, **kwargs):
+        """Returns a 1D numpy array of label indices."""
+        vertex_labels = []
+        if fragment is None:
+            matched_frags = list(self._loaders.keys())
+        else:
+            matched_frags = [frg for frg in self._loaders.keys() if fragment.lower() in frg.lower()]
+            if len(matched_frags) != 1:
+                raise ValueError(
+                    f"Requested fragment '{fragment}' could not be matched uniquely "
+                    f"to [{', '.join(self._loaders)}]"
+                )
+        for frag in matched_frags:
+            frag_labels, *_ = self._loaders[frag].data
+            if label is not None:  # create the mask
+                selected_label = frag_labels == label
+                frag_labels[selected_label] = 1
+                frag_labels[~selected_label] = 0
+            else:
+                frag_labels[frag_labels == -1] = 0  # annot files store backgorund as -1 while siibra uses 0
+            vertex_labels.append(frag_labels)
+
+        return {"labels": np.hstack(vertex_labels)}
+
+    def get_boundingbox(self, clip=False, background=0.0) -> '_boundingbox.BoundingBox':
+        raise NotImplementedError(
+            f"Bounding box access to {self.__class__.__name__} objects not yet implemented."
+        )
+
+    @property
+    def _url(self) -> Union[str, Dict[str, str]]:
+        return self._init_url

siibra/volumes/providers/neuroglancer.py

@@ -15,7 +15,14 @@
 
 from . import provider as _provider
 
-from ...commons import logger, MapType, merge_meshes, SIIBRA_MAX_FETCH_SIZE_GIB
+from ...commons import (
+    logger,
+    MapType,
+    merge_meshes,
+    SIIBRA_MAX_FETCH_SIZE_GIB,
+    QUIET,
+    resample_img_to_img
+)
 from ...retrieval import requests, cache
 from ...locations import boundingbox as _boundingbox
 
@@ -86,10 +93,11 @@ class NeuroglancerProvider(_provider.VolumeProvider, srctype="neuroglancer/preco
 
         if len(self._fragments) > 1:
             if fragment is None:
-                raise RuntimeError(
-                    f"Merging of fragments not yet implemented in {self.__class__.__name__}. "
-                    f"Specify one of [{', '.join(self._fragments.keys())}] using fetch(fragment=<name>). "
+                logger.info(
+                    f"Merging fragments [{', '.join(self._fragments.keys())}]. "
+                    f"You can select one using `fragment` kwarg."
                 )
+                result = self._merge_fragments(resolution_mm=resolution_mm, voi=voi, **kwargs)
             else:
                 matched_names = [n for n in self._fragments if fragment.lower() in n.lower()]
                 if len(matched_names) != 1:
@@ -157,45 +165,67 @@ class NeuroglancerProvider(_provider.VolumeProvider, srctype="neuroglancer/preco
                     np.asanyarray(img.dataobj), threshold=background, space=None
                 ).transform(img.affine)  # use the affine of the image matching fetch_kwargs
             else:
-                shape = frag.shape[:3]
+                resolution_mm = fetch_kwargs.get("resolution_mm")
+                if resolution_mm is None:
+                    affine = frag.affine
+                    shape = frag.shape[:3]
+                else:
+                    scale = frag._select_scale(resolution_mm=resolution_mm)
+                    affine = scale.affine
+                    shape = scale.size[:3]
                 next_bbox = _boundingbox.BoundingBox(
                     (0, 0, 0), shape, space=None
-                ).transform(frag.affine)
+                ).transform(affine)
             bbox = next_bbox if bbox is None else bbox.union(next_bbox)
         return bbox
 
-    def _merge_fragments(self) -> nib.Nifti1Image:
-        # TODO this only performs nearest neighbor interpolation, optimized for float types.
-        bbox = self.get_boundingbox(clip=False, background=0.0)
+    def _merge_fragments(
+        self,
+        resolution_mm: float = None,
+        voi: _boundingbox.BoundingBox = None,
+        **kwargs
+    ) -> nib.Nifti1Image:
+        with QUIET:
+            bbox = self.get_boundingbox(
+                clip=False,
+                background=0,
+                resolution_mm=resolution_mm,
+                voi=voi
+            )
+
         num_conflicts = 0
         result = None
-
-        for loader in self._img_loaders.values():
-            img = loader()
+        for frag_vol in self._fragments.values():
+            frag_scale = frag_vol._select_scale(
+                resolution_mm=resolution_mm,
+                bbox=voi,
+                max_bytes=kwargs.pop("maxbytes", NeuroglancerVolume.MAX_BYTES)
+            )
+            img = frag_scale.fetch(voi=voi)
             if result is None:
                 # build the empty result image with its own affine and voxel space
                 s0 = np.identity(4)
                 s0[:3, -1] = list(bbox.minpoint.transform(np.linalg.inv(img.affine)))
                 result_affine = np.dot(img.affine, s0)  # adjust global bounding box offset to get global affine
-                voxdims = np.asanyarray(bbox.transform(result_affine).shape, dtype="int")
+                voxdims = np.asanyarray(np.ceil(
+                    bbox.transform(np.linalg.inv(result_affine)).shape  # transform to the voxel space
+                ), dtype="int")
                 result_arr = np.zeros(voxdims, dtype=img.dataobj.dtype)
                 result = nib.Nifti1Image(dataobj=result_arr, affine=result_affine)
 
-            arr = np.asanyarray(img.dataobj)
-            Xs, Ys, Zs = np.where(arr != 0)
-            Xt, Yt, Zt, _ = np.split(
-                (np.dot(
-                    np.linalg.inv(result_affine),
-                    np.dot(img.affine, np.c_[Xs, Ys, Zs, Zs * 0 + 1].T)
-                ) + .5).astype('int'),
-                4, axis=0
-            )
-            num_conflicts += np.count_nonzero(result_arr[Xt, Yt, Zt])
-            result_arr[Xt, Yt, Zt] = arr[Xs, Ys, Zs]
+            # resample to merge template and update it
+            resampled_img = resample_img_to_img(source_img=img, target_img=result)
+            arr = np.asanyarray(resampled_img.dataobj)
+            nonzero_voxels = arr != 0
+            num_conflicts += np.count_nonzero(result_arr[nonzero_voxels])
+            result_arr[nonzero_voxels] = arr[nonzero_voxels]
 
         if num_conflicts > 0:
             num_voxels = np.count_nonzero(result_arr)
-            logger.warning(f"Merging fragments required to overwrite {num_conflicts} conflicting voxels ({num_conflicts / num_voxels * 100.:2.1f}%).")
+            logger.warning(
+                f"Merging fragments required to overwrite {num_conflicts} "
+                f"conflicting voxels ({num_conflicts / num_voxels * 100.:2.3f}%)."
+            )
 
         return result