siibra 0.4a76__py3-none-any.whl → 0.5a1__py3-none-any.whl

siibra/VERSION

@@ -1 +1 @@
-0.4a76
+0.5a01

siibra/commons.py

@@ -45,8 +45,9 @@ KEYCLOAK_CLIENT_SECRET = os.getenv("KEYCLOAK_CLIENT_SECRET")
 SIIBRA_CACHEDIR = os.getenv("SIIBRA_CACHEDIR")
 SIIBRA_LOG_LEVEL = os.getenv("SIIBRA_LOG_LEVEL", "INFO")
 SIIBRA_USE_CONFIGURATION = os.getenv("SIIBRA_USE_CONFIGURATION")
-
 SIIBRA_USE_LOCAL_SNAPSPOT = os.getenv("SIIBRA_USE_LOCAL_SNAPSPOT")
+SKIP_CACHEINIT_MAINTENANCE = os.getenv("SKIP_CACHEINIT_MAINTENANCE")
+NEUROGLANCER_MAX_GIB = os.getenv("NEUROGLANCER_MAX_GIB", 0.2)
 
 with open(os.path.join(ROOT_DIR, "VERSION"), "r") as fp:
     __version__ = fp.read().strip()
@@ -735,7 +736,7 @@ class Species(Enum):
             if key in cls.__members__.keys():
                 return getattr(cls, key)
         else:
-            if isinstance(spec, list):
+            if isinstance(spec, (list, set)):
                 next_specs = spec
             elif isinstance(spec, dict):
                 next_specs = spec.values()

siibra/configuration/configuration.py

@@ -159,15 +159,19 @@ class Configuration:
                 **{'filename': specloaders[0][0]}
             )
         )
+        obj_class = obj0[0].__class__.__name__ if isinstance(obj0, list) else obj0.__class__.__name__
 
         for fname, loader in siibra_tqdm(
             specloaders,
             total=len(specloaders),
-            desc=f"Loading preconfigured {obj0.__class__.__name__} instances"
+            desc=f"Loading preconfigured {obj_class} instances"
         ):
             # filename is added to allow Factory creating reasonable default object identifiers\
             obj = Factory.from_json(dict(loader.data, **{'filename': fname}))
-            result.append(obj)
+            if isinstance(obj, list):
+                result.extend(obj)
+            else:
+                result.append(obj)
 
         return result
 

siibra/configuration/factory.py

@@ -448,56 +448,77 @@ class Factory:
             raise ValueError(f"No method for building image section feature type {modality}.")
 
     @classmethod
-    @build_type("siibra/feature/connectivitymatrix/v0.2")
+    @build_type("siibra/feature/connectivitymatrix/v0.3")
     def build_connectivity_matrix(cls, spec):
+        files = spec.get("files", {})
         modality = spec["modality"]
+        try:
+            conn_cls = getattr(connectivity, modality)
+        except Exception:
+            raise ValueError(f"No method for building connectivity matrix of type {modality}.")
+
+        decoder_func = cls.extract_decoder(spec)
+        repo_connector = cls.extract_connector(spec) if spec.get('repository', None) else None
+        if repo_connector is None:
+            base_url = spec.get("base_url", "")
         kwargs = {
             "cohort": spec.get("cohort", ""),
             "modality": modality,
             "regions": spec["regions"],
-            "connector": cls.extract_connector(spec),
-            "decode_func": cls.extract_decoder(spec),
-            "files": spec.get("files", {}),
+            "connector": repo_connector,
+            "decode_func": decoder_func,
             "anchor": cls.extract_anchor(spec),
             "description": spec.get("description", ""),
-            "datasets": cls.extract_datasets(spec),
+            "datasets": cls.extract_datasets(spec)
         }
-        if modality == "StreamlineCounts":
-            return connectivity.StreamlineCounts(**kwargs)
-        elif modality == "StreamlineLengths":
-            return connectivity.StreamlineLengths(**kwargs)
-        elif modality == "Functional":
-            kwargs["paradigm"] = spec.get("paradigm")
-            return connectivity.FunctionalConnectivity(**kwargs)
-        elif modality == "RestingState":
-            kwargs["paradigm"] = spec.get("paradigm", "RestingState")
-            return connectivity.FunctionalConnectivity(**kwargs)
-        elif modality == "Tracing":
-            return connectivity.TracingConnectivity(**kwargs)
-        else:
-            raise ValueError(f"No method for building connectivity matrix of type {modality}.")
+        paradigm = spec.get("paradigm")
+        if paradigm:
+            kwargs["paradigm"] = paradigm
+        files_indexed_by = spec.get("files_indexed_by", "subject")
+        assert files_indexed_by in ["subject", "feature"]
+        conn_by_file = []
+        for fkey, filename in files.items():
+            kwargs.update({
+                "filename": filename,
+                "subject": fkey if files_indexed_by == "subject" else "average",
+                "feature": fkey if files_indexed_by == "feature" else None,
+                "connector": repo_connector or base_url + filename
+            })
+            conn_by_file.append(conn_cls(**kwargs))
+        return conn_by_file
 
     @classmethod
     @build_type("siibra/feature/timeseries/activity/v0.1")
     def build_activity_timeseries(cls, spec):
+        files = spec.get("files", {})
         modality = spec["modality"]
+        try:
+            timeseries_cls = getattr(regional_timeseries_activity, modality)
+        except Exception:
+            raise ValueError(f"No method for building signal table of type {modality}.")
+
         kwargs = {
-            "cohort": spec["cohort"],
+            "cohort": spec.get("cohort", ""),
             "modality": modality,
             "regions": spec["regions"],
             "connector": cls.extract_connector(spec),
             "decode_func": cls.extract_decoder(spec),
-            "files": spec.get("files", {}),
             "anchor": cls.extract_anchor(spec),
             "description": spec.get("description", ""),
             "datasets": cls.extract_datasets(spec),
-            "timestep": spec.get("timestep", ("1 no_unit"))
+            "timestep": spec.get("timestep")
         }
-        if modality == "Regional BOLD signal":
-            kwargs["paradigm"] = spec.get("paradigm", "")
-            return regional_timeseries_activity.RegionalBOLD(**kwargs)
-        else:
-            raise ValueError(f"No method for building signal table of type {modality}.")
+        paradigm = spec.get("paradigm")
+        if paradigm:
+            kwargs["paradigm"] = paradigm
+        timeseries_by_file = []
+        for fkey, filename in files.items():
+            kwargs.update({
+                "filename": filename,
+                "subject": fkey
+            })
+            timeseries_by_file.append(timeseries_cls(**kwargs))
+        return timeseries_by_file
 
     @classmethod
     def from_json(cls, spec: dict):

siibra/explorer/__init__.py

@@ -0,0 +1 @@
+from .url import encode_url, decode_url

siibra/explorer/url.py

@@ -0,0 +1,162 @@
+from typing import Optional, TYPE_CHECKING
+from urllib.parse import quote_plus
+from numpy import int32
+import numpy as np
+import re
+from dataclasses import dataclass
+import math
+
+from .util import encode_number, separator, cipher, neg, decode_number, post_process
+
+if TYPE_CHECKING:
+    from siibra.core.atlas import Atlas
+    from siibra.core.space import Space
+    from siibra.locations import BoundingBox, Point
+    from siibra.core.parcellation import Parcellation
+    from siibra.core.region import Region
+    from siibra.features.feature import Feature
+
+class DecodeNavigationException(Exception): pass
+
+min_int32=-2_147_483_648
+max_int32=2_147_483_647
+
+
+default_root_url='https://atlases.ebrains.eu/viewer/'
+
+def sanitize_id(id: str):
+    return id.replace('/', ':')
+
+def get_perspective_zoom(atlas: "Atlas", space: "Space", parc: "Parcellation", region: Optional["Region"]):
+    import siibra
+    if atlas is siibra.atlases['rat'] or atlas is siibra.atlases['mouse']:
+        return 200000
+    return 2000000
+
+def get_zoom(atlas: "Atlas", space: "Space", parc: "Parcellation", region: Optional["Region"]):
+    import siibra
+    if atlas is siibra.atlases['rat'] or atlas is siibra.atlases['mouse']:
+        return 35000
+    return 350000
+
+supported_prefix = (
+  "nifti://",
+  "swc://",
+  "precomputed://",
+  "deepzoom://"
+)
+
+def append_query_params(url: str, *args, query_params={}, **kwargs):
+    query_str = "&".join([f"{key}={quote_plus(value)}" for key, value in query_params.items()])
+    if len(query_str) > 0:
+        query_str = "?" + query_str
+    return url + query_str
+
+@post_process(append_query_params)
+def encode_url(atlas: "Atlas", space: "Space", parc: "Parcellation", region: Optional["Region"]=None, *, root_url=default_root_url, external_url:str=None, feature: "Feature"=None, ignore_warning=False, query_params={}):
+    
+    overlay_url = None
+    if external_url:
+        assert any([external_url.startswith(prefix) for prefix in supported_prefix]), f"url needs to start with {(' , '.join(supported_prefix))}"
+        overlay_url = '/x-overlay-layer:{url}'.format(
+            url=external_url.replace("/", "%2F")
+        )
+
+    zoom = get_zoom(atlas, space, parc, region)
+    pzoom = get_perspective_zoom(atlas, space, parc, region)
+    
+    zoom_kwargs = {
+        "encoded_pzoom": encode_number(pzoom, False),
+        "encoded_zoom": encode_number(zoom, False)
+    }
+    nav_string='/@:0.0.0.-W000.._eCwg.2-FUe3._-s_W.2_evlu..{encoded_pzoom}..{encoded_nav}..{encoded_zoom}'
+
+    return_url='{root_url}#/a:{atlas_id}/t:{template_id}/p:{parc_id}{overlay_url}'.format(
+        root_url    = root_url,
+        atlas_id    = sanitize_id(atlas.id),
+        template_id = sanitize_id(space.id),
+        parc_id     = sanitize_id(parc.id),
+        overlay_url = overlay_url if overlay_url else "",
+    )
+
+    if feature is not None:
+        return_url = return_url + f"/f:{sanitize_id(feature.id)}"
+
+    if region is None:
+        return return_url + nav_string.format(encoded_nav='0.0.0', **zoom_kwargs)
+    
+    return_url=f'{return_url}/rn:{get_hash(region.name)}'
+
+    try:
+        result_props=region.spatial_props(space, maptype='labelled')
+        if len(result_props.components) == 0:
+            return return_url + nav_string.format(encoded_nav='0.0.0', **zoom_kwargs)
+    except Exception as e:
+        print(f'Cannot get_spatial_props {str(e)}')
+        if not ignore_warning:
+            raise e
+        return return_url + nav_string.format(encoded_nav='0.0.0', **zoom_kwargs)
+
+    centroid=result_props.components[0].centroid
+
+    encoded_centroid=separator.join([ encode_number(math.floor(val * 1e6)) for val in centroid ])
+    return_url=return_url + nav_string.format(encoded_nav=encoded_centroid, **zoom_kwargs)
+    return return_url
+
+@dataclass
+class DecodedUrl:
+    bounding_box: "BoundingBox"
+
+def decode_url(url: str, vp_length=1000):
+    import siibra
+    try:
+        space_match = re.search(r'/t:(?P<space_id>[^/]+)', url)
+        space_id = space_match.group("space_id")
+        space_id = space_id.replace(":", "/")
+        space = siibra.spaces[space_id]
+    except Exception as e:
+        raise DecodeNavigationException from e
+
+    nav_match = re.search(r'/@:(?P<navigation_str>.+)/?', url)
+    navigation_str = nav_match.group("navigation_str")
+    for char in navigation_str:
+        assert char in cipher or char in [neg, separator], f"char {char} not in cipher, nor separator/neg"
+    
+    try:
+        ori_enc, pers_ori_enc, pers_zoom_enc, pos_enc, zoomm_enc = navigation_str.split(f"{separator}{separator}")
+    except Exception as e:
+        raise DecodeNavigationException from e
+    
+    try:
+        x_enc, y_enc, z_enc = pos_enc.split(separator)
+        pos = [decode_number(val) for val in [x_enc, y_enc, z_enc]]
+        zoom = decode_number(zoomm_enc)
+
+        # zoom = nm/pixel
+        pt1 = [(coord - (zoom * vp_length / 2)) / 1e6 for coord in pos]
+        pt1 = Point(pt1, space)
+        
+        pt2 = [(coord + (zoom * vp_length / 2)) / 1e6 for coord in pos]
+        pt2 = Point(pt2, space)
+
+    except Exception as e:
+        raise DecodeNavigationException from e
+
+    bbx = BoundingBox(pt1, pt2, space)
+    return DecodedUrl(bounding_box=bbx)
+    
+def get_hash(full_string: str):
+    return_val=0
+    with np.errstate(over="ignore"):
+        for char in full_string:
+            # overflowing is expected and in fact the whole reason why convert number to int32
+            
+            # in windows, int32((0 - min_int32) << 5), rather than overflow to wraper around, raises OverflowError
+            shifted_5 = int32(
+                (return_val - min_int32) if return_val > max_int32 else return_val
+            << 5)
+
+            return_val = int32(shifted_5 - return_val + ord(char))
+            return_val = return_val & return_val
+    hex_val = hex(return_val)
+    return hex_val[3:]

siibra/explorer/util.py

@@ -0,0 +1,65 @@
+import math
+import struct
+from functools import wraps
+from typing import Callable
+
+cipher = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-'
+separator = '.'
+neg = '~'
+def encode_number(n, float_flag=False):
+    if float_flag:
+        b=struct.pack('f', n)
+        new_n=struct.unpack('i',b)
+        return encode_int(new_n[0])
+    else:
+        return encode_int(n)
+
+def encode_int(n):
+    if not isinstance(n, int):
+        raise ValueError('Cannot encode int')
+
+    residual=None
+    result=''
+    if n < 0:
+        result += neg
+        residual = n * -1
+    else:
+        residual = n
+    
+    while True:
+        result = cipher[residual % 64] + result
+        residual = math.floor(residual / 64)
+
+        if residual == 0:
+            break
+    return result
+
+def decode_int(n):
+    neg_flag = False
+    if n[-1] == neg:
+        neg_flag = True
+        n = n[:-1]
+
+    result = 0
+    for char in n:
+        val = cipher.index(char)
+        result = result * 64 + val
+
+    if neg_flag:
+        result = result * -1
+    return result
+
+def decode_number(n, float_flag=False):
+    if float_flag:
+        raise NotImplementedError
+    return decode_int(n)
+
+
+def post_process(post_process: Callable):
+    def outer(fn):
+        @wraps(fn)
+        def inner(*args, **kwargs):
+            val = fn(*args, **kwargs)
+            return post_process(val, *args, **kwargs)
+        return inner
+    return outer

siibra/features/anchor.py

@@ -57,15 +57,19 @@ class AnatomicalAnchor:
         self._location_cached = location
         self._assignments: Dict[Union[AtlasConcept, Location], List[AnatomicalAssignment]] = {}
         self._last_matched_concept = None
-        self._regions_cached = None
-        self._regionspec = None
-        if isinstance(region, Region):
-            self._regions_cached = {region: AssignmentQualification.EXACT}
-        elif isinstance(region, str):
-            self._regionspec = region
+        if isinstance(region, dict):
+            self._regions_cached = region
+            self._regionspec = ", ".join({r.name for r in region.keys()})
         else:
-            if region is not None:
-                raise ValueError(f"Invalid region specification: {region}")
+            self._regions_cached = None
+            self._regionspec = None
+            if isinstance(region, Region):
+                self._regions_cached = {region: AssignmentQualification.EXACT}
+            elif isinstance(region, str):
+                self._regionspec = region
+            else:
+                if region is not None:
+                    raise ValueError(f"Invalid region specification: {region}")
         self._aliases_cached = None
 
     @property
@@ -135,7 +139,10 @@ class AnatomicalAnchor:
         region = "" if self._regionspec is None else str(self._regionspec)
         location = "" if self.location is None else str(self.location)
         separator = " " if min(len(region), len(location)) > 0 else ""
-        return region + separator + location
+        if region and location:
+            return region + " with " + location
+        else:
+            return region + separator + location
 
     def __repr__(self):
         return self.__str__()
@@ -316,3 +323,23 @@ class AnatomicalAnchor:
             return ""
         else:
             return ' and '.join({str(_) for _ in self.last_match_result})
+
+    def __add__(self, other: 'AnatomicalAnchor') -> 'AnatomicalAnchor':
+        if not isinstance(other, AnatomicalAnchor):
+            raise ValueError(f"Cannot combine an AnatomicalAnchor with {other.__class__}")
+
+        if self.species != other.species:
+            raise ValueError("Cannot combine an AnatomicalAnchor from different species.")
+        else:
+            species = self.species.union(other.species)
+
+        regions = self.regions
+        regions.update(other.regions)
+
+        location = Location.union(self.location, other.location)
+
+        return AnatomicalAnchor(species, location, regions)
+
+    def __radd__(self, other):
+        # required to enable `sum`
+        return self if other == 0 else self.__add__(other)

siibra/features/connectivity/__init__.py

@@ -14,7 +14,10 @@
 # limitations under the License.
 """Multimodal data features concerning connectivity data."""
 
-from .functional_connectivity import FunctionalConnectivity
+from .functional_connectivity import (
+    FunctionalConnectivity,
+    AnatomoFunctionalConnectivity
+)
 from .streamline_counts import StreamlineCounts
 from .streamline_lengths import StreamlineLengths
 from .tracing_connectivity import TracingConnectivity
@@ -25,5 +28,6 @@ def __dir__():
         "FunctionalConnectivity",
         "StreamlineCounts",
         "StreamlineLengths",
-        "TracingConnectivity"
+        "TracingConnectivity",
+        "AnatomoFunctionalConnectivity"
     ]

siibra/features/connectivity/functional_connectivity.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 
 from . import regional_connectivity
+
 from hashlib import md5
 
 
@@ -24,6 +25,9 @@ class FunctionalConnectivity(
 ):
     """Functional connectivity matrix grouped by a parcellation."""
 
+    _filter_attrs = regional_connectivity.RegionalConnectivity._filter_attrs + ["paradigm"]
+    _compound_attrs = regional_connectivity.RegionalConnectivity._compound_attrs + ["paradigm"]
+
     def __init__(self, paradigm: str, **kwargs):
         regional_connectivity.RegionalConnectivity.__init__(self, **kwargs)
         self.paradigm = paradigm
@@ -34,3 +38,20 @@ class FunctionalConnectivity(
     @property
     def id(self):
         return super().id + "--" + md5(self.paradigm.encode("utf-8")).hexdigest()
+
+    @property
+    def name(self):
+        return f"{super().name}, {self.paradigm} paradigm"
+
+
+class AnatomoFunctionalConnectivity(
+    regional_connectivity.RegionalConnectivity,
+    configuration_folder="features/connectivity/regional/anatomofunctional",
+    category="connectivity"
+):
+    """Functional connectivity matrix grouped by a parcellation."""
+
+    _filter_attrs = ["modality", "cohort", "feature"]
+
+    def __init__(self, **kwargs):
+        regional_connectivity.RegionalConnectivity.__init__(self, **kwargs)