Decoupled channels & time points, functions to invalidate computed columns, enforce bound restrictions on getShapePixels by injecting nan where the shape is out of bound, & bug fixes.

Author: Suhayb-A

mapmanagercore/analysis_params.py

@@ -3,21 +3,23 @@
 
 from mapmanagercore.logger import logger
 
+
 class AnalysisParams():
-    def __init__(self, loadJson : str = None):
-        
+    def __init__(self, loadJson: str = None):
+
         # self.__version__ = 0.1
         # self.__version__ = 0.1  # switched to dict of dicts
         self.__version__ = 0.2  # 20240508 added anchorPointSearchDistance
         self.__version__ = 0.3  # segmentTracingMaxDistance
+        self.__version__ = 0.4  # maxChannels
 
         if loadJson is not None:
             self._dict = json.loads(loadJson)
             if self._dict['__version__'] <= self.__version__:
                 self._getDefauls()
         else:
             self._getDefauls()
-    
+
     def getDict(self):
         return self._dict
 
@@ -29,7 +31,7 @@ def _getDefauls(self):
         """
         self._dict = {
             '__version__': self.__version__,
-            
+
             # new spine
             'brightestPathDistance': {
                 'defaultValue': 10,
@@ -61,21 +63,27 @@ def _getDefauls(self):
                 'currentValue': 4,
                 'description': 'Width of spine ROI.'
             },
-            
+
             # segment
             'segmentRadius': {
                 'defaultValue': 4,
                 'currentValue': 4,
                 'description': 'Radius of segment tracing.'
             },
-            
-            # The distance 
+
+            # The distance
             'segmentTracingMaxDistance': {
                 'defaultValue': 30,
                 'currentValue': 30,
                 'description': 'Max distance to trace a brightest path with relatively low performance cost.'
             },
 
+            'maxChannels': {
+                'defaultValue': 2,
+                'currentValue': 2,
+                'description': 'Max number of channels.'
+            },
+
             # anchor point search distance
             # 'anchorPointSearchDistance': {
             #     'defaultValue': 10,
@@ -90,15 +98,15 @@ def __getitem__(self, key) -> Optional[object]:
         """
         return self.getValue(key)
 
-    def getValue(self, key : str) -> Optional[object]:
+    def getValue(self, key: str) -> Optional[object]:
         """Get the value for a key, return None of KeyError.
         """
         try:
             return self._dict[key]['currentValue']
         except (KeyError):
             logger.error(f'did not find key "{key}", possible keys are {self._dict.keys()}')
 
-    def setValue(self, key : str, value : object):
+    def setValue(self, key: str, value: object):
         try:
             self._dict[key]['currentValue'] = value
         except (KeyError):
@@ -109,9 +117,9 @@ def save(self):
         """
         pass
 
-    def load(self, path : str):
+    def load(self, path: str):
         """Load JSON from zarr file into our _dict.
-        
+
         Parameters
         ----------
         path : str

mapmanagercore/annotations/base.py

@@ -4,6 +4,7 @@
 from typing import Any, Tuple, Union
 import weakref
 import zipfile
+from mapmanagercore.lazy_geo_pd_images.loader.base import Position
 import numpy as np
 import pandas as pd
 
@@ -24,6 +25,7 @@
 from mapmanagercore.analysis_params import AnalysisParams
 from mapmanagercore.logger import logger
 
+
 class AnnotationsBase(LazyImagesGeoPandas):
     _images: ImageLoader
 
@@ -32,7 +34,8 @@ def __init__(self,
                  lineSegments: Union[str, pd.DataFrame] = pd.DataFrame(),
                  points: Union[str, pd.DataFrame] = pd.DataFrame(),
                  analysisParams: AnalysisParams = AnalysisParams(),
-                 path: str = None):
+                 path: str = None,
+                 version: int = None):
 
         super().__init__(loader)
 
@@ -49,35 +52,43 @@ def __init__(self,
 
         self._segments = LazyGeoFrame(
             Segment, data=lineSegments, store=weakref.ref(self))
-        self._points = LazyGeoFrame(Spine, data=points, store=weakref.ref(self))
+        self._points = LazyGeoFrame(
+            Spine, data=points, store=weakref.ref(self))
 
         self.loader = loader
         self.path = path
+        
+        # To invalidate columns that were miss-computed in previous version
+        # we can conditionally check the version number
+        # if version === 0:
+        #  then we can invalidate the invalid columns by name
+        # self._segments.invalidateColumns([... columns ...])
+        
 
     # abb
     def __str__(self):
         """Print info about the map.
-        
+
         See: _SingleTimePointAnnotationsBase()
         """
         numTimepoints = len(self._images.timePoints())
         numPnts = len(self.points._rootDf)
         numSegments = len(self.segments._rootDf)
 
         return f't:{numTimepoints}, points:{numPnts} segments:{numSegments} loader:{self.loader}'
-    
+
     @property
     def segments(self) -> LazyGeoFrame:
         return self._segments
 
     @property
     def points(self) -> LazyGeoFrame:
         return self._points
-    
+
     @property
     def analysisParams(self) -> AnalysisParams:
         return self._analysisParams
-    
+
     def filterPoints(self, filter: Any):
         """
         Filters the points.
@@ -100,7 +111,7 @@ def getTimePoint(self, time: int):
         """
         from .single_time_point import SingleTimePointAnnotations
         return SingleTimePointAnnotations(self, time)
-    
+
     def getPixels(self, time: int, channel: int, zRange: Tuple[int, int] = None, z: int = None, zSpread: int = 0) -> ImageSlice:
         """
         Loads the image data for a slice.
@@ -152,7 +163,7 @@ def checkFile(cls, path: str, lazy=True, verbose=False) -> bool:
             store = zarr.DirectoryStore(path)
         else:
             store = zarr.ZipStore(path, mode="r")
-        
+
         group = zarr.group(store=store)
 
         if verbose:
@@ -191,7 +202,8 @@ def checkFile(cls, path: str, lazy=True, verbose=False) -> bool:
 
         # (2) points
         try:
-            _points = group["points"]  # zarr.core.Array '/points' (255865,) uint8
+            # zarr.core.Array '/points' (255865,) uint8
+            _points = group["points"]
         except (KeyError) as e:
             logger.error('did not find group "points"')
             logger.error(f'   {e}')
@@ -216,7 +228,8 @@ def checkFile(cls, path: str, lazy=True, verbose=False) -> bool:
             _errors += 1
         finally:
             try:
-                _lineSegments = pd.read_pickle(BytesIO(_lineSegments[:].tobytes()))
+                _lineSegments = pd.read_pickle(
+                    BytesIO(_lineSegments[:].tobytes()))
                 if verbose:
                     logger.info(f'lineSegments: {len(_lineSegments)}')
                     # print(_lineSegments.head())
@@ -244,24 +257,33 @@ def checkFile(cls, path: str, lazy=True, verbose=False) -> bool:
             logger.info(f'encountered {_errors} errors while inspecting {path}')
 
         return _errors == 0
-    
+
+    def merge(self, loader: ImageLoader):
+        self.loader.merge(loader)
+
     @classmethod
     def load(cls, path: Union[str, None], lazy=False):
         loader = ZarrLoader(path, lazy=lazy)
-        points = pd.read_pickle(BytesIO(loader.group["points"][:].tobytes()))
-        points = gp.GeoDataFrame(points, geometry="point")
-        lineSegments = pd.read_pickle(
-            BytesIO(loader.group["lineSegments"][:].tobytes()))
-        lineSegments = gp.GeoDataFrame(lineSegments, geometry="segment")
 
-        # abb analysisparams
-        _analysisParams_json = loader.group.attrs['analysisParams']  # json str
-        analysisParams = AnalysisParams(loadJson=_analysisParams_json)
+        if "points" in loader.group:
+            points = pd.read_pickle(
+                BytesIO(loader.group["points"][:].tobytes()))
+            points = gp.GeoDataFrame(points, geometry="point")
+        else:
+            points = gp.GeoDataFrame()
 
+        if "lineSegments" in loader.group:
+            lineSegments = pd.read_pickle(
+                BytesIO(loader.group["lineSegments"][:].tobytes()))
+            lineSegments = gp.GeoDataFrame(lineSegments, geometry="segment")
+        else:
+            lineSegments = gp.GeoDataFrame()
+            
+        analysisParams = loader.analysisParams()
 
         return cls(loader, lineSegments, points, analysisParams, path)
 
-    def save(self, path: str=None, compression=zipfile.ZIP_STORED):
+    def save(self, path: str = None, compression=zipfile.ZIP_STORED):
         if path is None:
             path = self.path
 
@@ -279,7 +301,8 @@ def save(self, path: str=None, compression=zipfile.ZIP_STORED):
 
             with fs as store:
                 group = zarr.group(store=store)
-                self._images.saveTo(group)
+                images = group.create_group("images");
+                self._images.saveTo(images)
                 group.create_dataset(
                     "points", data=self.points.toBytes(), dtype=np.uint8)
                 group.create_dataset(

mapmanagercore/annotations/pyodide.py

@@ -1,5 +1,8 @@
 import json
-from typing import Tuple
+from typing import List, Tuple, Union
+from mapmanagercore.lazy_geo_pd_images.loader.base import Position
+from mapmanagercore.lazy_geo_pd_images.loader.imageio import MultiImageLoader
+from mapmanagercore.lazy_geo_pd_images.loader.zarr import ZarrLoader
 import numpy as np
 from ..benchmark import timeAll
 from ..config import SpineId
@@ -10,6 +13,10 @@
 from . import Annotations
 from pyodide.ffi import to_js
 from .single_time_point import SingleTimePointAnnotations
+from enum import Enum
+
+
+type ChangeOrError = Union[bool, str]
 
 
 class PyodideSingleTimePoint(SingleTimePointAnnotations):
@@ -30,7 +37,7 @@ def getSpinePosition(self, spineID: SpineId):
         """Returns the position of a spine in the current time point."""
         if spineID not in self.points.index:
             return None
-        
+
         points = self.points[spineID, ["point", "z"]]
         return to_js([*list(*points["point"].coords), int(points["z"])])
 
@@ -79,8 +86,22 @@ class PyodideAnnotations(Annotations):
     """ PyodideAnnotations contains pyodide specific helper methods to allow JS to use Annotations.
     """
 
+    def mergeFile(self, path: str, timePoint: int = 0, channel: int = 0, name: str = None, position: Position = Position.OVER):
+        if name is None:
+            name = path
+        if path.endswith(".mmap"):
+            loader = ZarrLoader(path)
+        if path.endswith(".tif"):
+            loader = MultiImageLoader()
+            loader.read(path, time=timePoint, channel=channel, name=name)
+        self.loader.merge(loader)
+
     def timePoint_js(self, time: int):
         return PyodideSingleTimePoint(self, time)
+    
+    def metadata_json(self, time: int):
+        """Returns the metadata as a JSON string."""
+        return self.loader.metadata(time).to_json()
 
     def slices_js(self, time: int, channel: int, zRange: Tuple[int, int]) -> ImageSlice:
         """
@@ -129,3 +150,66 @@ def getSymbols(self, shapeOn: str = None):
     def columnsAttributes_json(self):
         """Returns the columnsAttributes as a JSON string."""
         return json.dumps(self.points.columnsAttributes, skipkeys=True)
+
+    def dataTree(self):
+        return json.dumps(self.loader.dataTree(), skipkeys=True)
+
+    def createTimePoint(self) -> ChangeOrError:
+        try:
+            return self.loader.createTimePoint()
+        except Exception as e:
+            return str(e)
+
+    def appendChannelToTimePoint(self, srcTimePoint: int, srcChannel: int, destTimePoint: int) -> ChangeOrError:
+        try:
+            return self.loader.appendChannelToTimePoint(srcTimePoint, srcChannel, destTimePoint)
+        except Exception as e:
+            return str(e)
+
+    def moveChannel(self, srcTimePoint: int, srcChannel: int, destTimePoint: int, destChannel: int) -> ChangeOrError:
+        try:
+            return self.loader.moveChannel(srcTimePoint, srcChannel, destTimePoint, destChannel)
+        except Exception as e:
+            return str(e)
+
+    def moveTimePoint(self, srcTimePoint: int, destTimePoint: int, position: Position = Position.OVER) -> ChangeOrError:
+        try:
+            return self.loader.moveTimePoint(srcTimePoint, destTimePoint, int(position))
+        except Exception as e:
+            return str(e)
+
+    def deleteTimePoint(self, timePoint: int) -> ChangeOrError:
+        try:
+            return self.loader.deleteTimePoint(timePoint)
+        except Exception as e:
+            return str(e)
+
+    def deleteChannel(self, timePoint: int, channel: int) -> ChangeOrError:
+        try:
+            return self.loader.deleteChannel(timePoint, channel)
+        except Exception as e:
+            return str(e)
+
+    def updateChannel(self, timePoint: int, channel: int, updates: dict) -> ChangeOrError:
+        try:
+            return self.loader.updateChannel(timePoint, channel, updates.to_py())
+        except Exception as e:
+            return str(e)
+
+    def updateTimePoint(self, timePoint: int, updates: dict) -> ChangeOrError:
+        try:
+            return self.loader.updateTimePoint(timePoint, updates.to_py())
+        except Exception as e:
+            return str(e)
+
+    def maxChannels(self) -> int:
+        return self.loader.maxChannels()
+    
+    def timePoints_js(self):
+        return to_js(list(self.loader.timePoints()))
+
+    def setMaxChannels(self, maxChannels: int):
+        try:
+            return self.loader.setMaxChannels(maxChannels)
+        except Exception as e:
+            return str(e)