Merged codmore-dev

Author: Suhayb-A

mapmanagercore/_version.py

@@ -12,5 +12,5 @@
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.0.post73'
+__version__ = version = '0.0.post104'
 __version_tuple__ = version_tuple = (0, 0)

mapmanagercore/annotations/base.py

@@ -19,6 +19,8 @@
 
 from mapmanagercore.analysis_params import AnalysisParams
 
+from mapmanagercore.analysis_params import AnalysisParams
+from mapmanagercore.logger import logger
 
 class AnnotationsBase(LazyImagesGeoPandas):
     _images: ImageLoader
@@ -46,18 +48,32 @@ def __init__(self,
             Segment, data=lineSegments, store=self)
         self._points = LazyGeoFrame(Spine, data=points, store=self)
 
+        self.loader = loader
+
+    # 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.laoder}'
+    
     @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.
@@ -130,6 +146,7 @@ def save(self, path: str, compression=zipfile.ZIP_STORED):
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
 
+            logger.info(f'saving to {path}')
             fs = zarr.ZipStore(path, mode="w", compression=compression)
             with fs as store:
                 group = zarr.group(store=store)

mapmanagercore/annotations/mutation.py

@@ -3,6 +3,8 @@
 from ..config import SegmentId, SpineId
 from .base import AnnotationsBase
 
+from mapmanagercore.logger import logger
+
 Key = Union[SpineId, Tuple[SpineId, int]]
 Keys = Union[Key, list[Key]]
 
@@ -20,22 +22,29 @@ def deleteSegment(self, segmentId: Keys, skipLog=False):
         """
         try:
             if not self.points[["segmentID"]].reset_index().set_index(["segmentID", "t"]).loc[segmentId].empty:
-                raise ValueError(
-                    f"Cannot delete segment(s) {segmentId} as it has an attached spine(s)")
+                # abb
+                logger.info(f'Cannot delete segment(s) {segmentId} as it has an attached spine(s)')
+                return False
+                # raise ValueError(
+                #     f"Cannot delete segment(s) {segmentId} as it has an attached spine(s)")
         except KeyError:
             pass
 
         self._drop("Segment", segmentId, skipLog=skipLog)
-
+        return True
+    
     def updateSpine(self, spineId: Keys, value: Spine, replaceLog=False, skipLog=False):
         """
         Set the spine with the given ID to the specified value.            
         """
         return self._update("Spine", spineId, value, replaceLog, skipLog)
 
     def updateSegment(self, segmentId: Keys, value: Segment, replaceLog=False, skipLog=False):
-        """
-        Set the segment with the given ID to the specified value.
+        """Set the segment with the given ID to the specified value.
+
+        Args:
+            segmentId (str): The ID of the spine.
+            value (Union[dict, gp.Series, pd.Series]): The value to set for the spine.
         """
         return self._update("Segment", segmentId, value, replaceLog, skipLog)
 
@@ -56,9 +65,14 @@ def newUnassignedSegmentId(self) -> SegmentId:
         return self.segments.index.get_level_values(0).max() + 1
 
     def connect(self, spineKey: Tuple[SpineId, int], toSpineKey: Tuple[SpineId, int]):
-        if self.points[toSpineKey, "segmentID"] != self.points[spineKey, "segmentID"]:
+        
+        # ValueError: Can only compare identically-labeled Series objects
+        # if self.points[toSpineKey, "segmentID"] != self.points[spineKey, "segmentID"]:
+        _segmentID = self.points[spineKey, "segmentID"].values[0]
+        _toSegmentID = self.points[toSpineKey, "segmentID"].values[0]
+        if _toSegmentID != _segmentID:
             raise ValueError("Cannot connect spines from different segments.")
-
+        
         # check if the key already exists in the time point
         existingKey = (toSpineKey[0], spineKey[1])
         if existingKey in self.points.index:

mapmanagercore/annotations/single_time_point/base.py

@@ -23,6 +23,7 @@
 # abb analysisparams
 from mapmanagercore.analysis_params import AnalysisParams
 
+from mapmanagercore.logger import logger
 
 class SingleTimePointFrame(LazyGeoFrame):
     def __init__(self, frame: LazyGeoFrame, t: int):
@@ -148,6 +149,20 @@ def __init__(self, annotations: Annotations, t: int):
 
         self._t = t
 
+    def __str__(self):
+        logger.info('')
+        
+        # get the number of time points
+        numTimepoints = 'abb ???'
+        try:
+            numTimepoints = len(self._images._imagesSrcs.keys())
+        except (AttributeError) as e:
+            logger.error(e)
+
+        numPnts = len(self._annotations._points._rootDf)
+        numSegments = len(self._annotations._segments._rootDf)
+        return f't:{numTimepoints}, points:{numPnts} segments:{numSegments}'
+    
     @property
     def points(self) -> LazyGeoFrame:
         return self._points

mapmanagercore/annotations/single_time_point/interactions.py

@@ -11,50 +11,56 @@
 from shapely.geometry import LineString
 import geopandas as gp
 from mapmanagercore.logger import logger
+from mapmanagercore.logger import logger
 
 pendingBackgroundRoiTranslation = None
 
 
 class AnnotationsInteractions(AnnotationsSegments):
+    
+    # abb
+    def getSpineDistance(self, segmentID: SegmentId,
+                         point: Point):
+        """Add doc string
+        """
+        segment: LineString = self.segments[segmentID, "segment"]
+        # find the closest point on the segment to the `point`
+        minProjection = segment.project(point)
+        return minProjection
+    
+    # abb added findBrightest=False, do not find brightest by default
     def nearestAnchor(self, segmentID: SegmentId,
                       point: Point,
-                      useBrightestPath=False,
-                      brightestPathDistance: int = None,
-                      channel: int = None,
-                      zSpread: int = None):
-        """
-        Finds the nearest anchor point on a given line segment to a given point.
+                      findBrightest : bool = False):
+        """Finds the nearest anchor point on a given line segment to a given point.
 
         Args:
             segmentID (SegmentId): The ID of the line segment.
             point (Point): The point to find the nearest anchor to.
-            brightestPathDistance (int): The distance to search for the brightest path. Defaults to None.
-            channel (int): The channel. Defaults to 0.
-            zSpread (int): The z spread. Defaults to 0.
+            findBrightest (bool): Default False.
+                If True then find the brightest anchor using image data.
 
         Returns:
             Point: The nearest anchor point.
-        """
-
+        """            
         segment: LineString = self.segments[segmentID, "segment"]
         # find the closest point on the segment to the `point`
         minProjection = segment.project(point)
-
-        if not useBrightestPath:
-            # Default to the closest path
+        
+        if np.isnan(minProjection):
+            logger.warning(f'minProjection:{minProjection}')
+            logger.warning(f'segment:{segment}')
+            logger.warning(f'point:{point}')
+            
+        if not findBrightest:
+            # Default to the closest point (not brightest)
             anchor = segment.interpolate(minProjection)
             anchor = roundPoint(anchor, 1)
             return anchor
 
-        # abb analysisparams
-        # if not specified, get defaults from AnalysisParams()
-        if brightestPathDistance is None:
-            brightestPathDistance = self.analysisParams.getValue(
-                'brightestPathDistance')
-        if channel is None:
-            channel = self.analysisParams.getValue('channel')
-        if zSpread is None:
-            zSpread = self.analysisParams.getValue('zSpread')
+        brightestPathDistance = self.analysisParams.getValue('brightestPathDistance')
+        channel = self.analysisParams.getValue('channel')
+        zSpread = self.analysisParams.getValue('zSpread')
 
         segmentLength = int(segment.length)
         minProjection = int(minProjection)
@@ -121,7 +127,10 @@ def addSpine(self, segmentId: SpineId, x: int, y: int, z: int) -> Union[SpineId,
         z (int): The z coordinate of the spine.
         """
         point = Point(x, y, z)
-        anchor = self.nearestAnchor(segmentId, point)
+
+        logger.error(f'1 FutureWarning: The `drop` keyword ...')
+        anchor = self.nearestAnchor(segmentId, point, findBrightest=True)
+
         spineId = self.newUnassignedSpineId()
 
         self.updateSpine(spineId, Spine.withDefaults(
@@ -134,6 +143,7 @@ def addSpine(self, segmentId: SpineId, x: int, y: int, z: int) -> Union[SpineId,
             yBackgroundOffset=0.0,
         ))
 
+        logger.error(f'4 FutureWarning: The `drop` keyword ...')
         self.snapBackgroundOffset(spineId)
 
         return spineId
@@ -169,7 +179,9 @@ def moveSpine(self, spineId: SpineId, x: int, y: int, z: int, state: DragState =
 
         return True
 
-    def moveAnchor(self, spineId: SpineId, x: int, y: int, z: int, state: DragState = DragState.MANUAL) -> bool:
+    def moveAnchor(self, spineId: SpineId,
+                   x: int, y: int, z: int,
+                   state: DragState = DragState.MANUAL) -> bool:
         """
         Moves the anchor point of a spine to the given x and y coordinates.
 
@@ -183,6 +195,9 @@ def moveAnchor(self, spineId: SpineId, x: int, y: int, z: int, state: DragState
             bool: True if the anchor point was successfully translated, False otherwise.
         """
         segmentId = self.points[spineId, "segmentID"]
+        
+        # abb
+        # when moving, do not find brightest
         anchor = self.nearestAnchor(segmentId, Point(x, y, z))
 
         logger.info(f'segmentId:{segmentId} anchor:{anchor}')
@@ -310,9 +325,9 @@ def newSegment(self) -> Union[SegmentId, None]:
 
         Returns:
             int: The ID of the new segment.
-        """
+        """        
         segmentId = self.newUnassignedSegmentId()
-
+        
         self.updateSegment(segmentId, Segment.withDefaults(
             segment=LineString([]),
             roughTracing=LineString([])
@@ -346,8 +361,7 @@ def injectSegmentPoint(self, segmentId: SegmentId, x: int, y: int, z: int):
         return idx
 
     def appendSegmentPoint(self, segmentId: SegmentId, x: int, y: int, z: int, speculate: bool = False) -> LineString:
-        """
-        Adds a point to a segment.
+        """Adds a point to a segment.
 
         Args:
             segmentId (str): The ID of the segment.

mapmanagercore/layers/line.py

@@ -8,7 +8,8 @@
 import shapely
 import geopandas as gp
 from ..benchmark import timer
-
+import math
+from math import pi as PI
 
 class MultiLineLayer(Layer):
     @Layer.setProperty
@@ -105,6 +106,77 @@ def head(self):
 def getTail(d):
     return Point(d.coords[1][0], d.coords[1][1])
 
+# abj
+def getSide(a: Point, b: Point, c: Point):
+  """ Calculate which side a point (c) is relative to a segment (AB)
+  Args:
+    a: Beginning point of line segment
+    b: End point of line segment
+    c: Point relative to line segment
+  """
+  crossProduct = (b.x - a.x)*(c.y - a.y) - (b.y - a.y)*(c.x - a.x)
+  if crossProduct > 0:
+    return "Right"
+  elif crossProduct < 0:
+    return "Left"
+  else:
+    return "On the Line"
+
+# abj
+@ timer
+def getSpineSide(line: LineString, spine: Point):
+    """ Return a string representing the side at which the spine point is relative to its segment
+
+    Args:
+        Line: segment in the for of a LineString
+        Spine: point
+    """
+    first = Point(line.coords[0])
+    last = Point(line.coords[-1])
+    val = getSide(first, last, spine)
+    return val
+
+# abj
+@ timer
+def getSpineAngle(segmentLine: LineString, spineLine: LineString):
+    """ Return the angle between the two Lines
+    Line 1: The line formed between the spine head and the anchor point
+    Line 2: The line formed by two points on the segment tracing. 
+    Grab two points, one “up” and the other “down” the segment from the spine anchor point. 
+    I think the anchor point on the segment tracing is our new “position”.
+
+    Args:
+        segmentLine: segment in the for of a LineString
+        spineLine: Linestring of spine head to anchor point
+    """
+    spineLineCoord0 = Point(spineLine.coords[0])
+    spineLineCoord1 = Point(spineLine.coords[1])
+    sl0x = spineLineCoord0.x
+    sl0y = spineLineCoord0.y
+    sl1x = spineLineCoord1.x
+    sl1y = spineLineCoord1.y
+
+    segmentLineCoord0 = Point(segmentLine.coords[0])
+    segmentLineCoord1 = Point(segmentLine.coords[-1])
+    sgl0x = segmentLineCoord0.x
+    sgl0y = segmentLineCoord0.y
+    sgl1x = segmentLineCoord1.x
+    sgl1y = segmentLineCoord1.y
+    
+    m1 = (sl1y-sl0y)/(sl1x-sl0x)
+    m2 = (sgl1y-sgl0y)/(sgl1x-sgl0x)
+
+    angle_rad = math.atan(m1) - math.atan(m2)
+    angle_deg = angle_rad*180/PI
+
+    # Range: 0 - 360
+    # Check for Negative angle and add 360 degrees to determine counter clockwise value
+    if angle_deg < 0:
+        angle_deg = angle_deg + 360 
+
+    # print("m1", m1, "m2", m2, "degree:", angle_deg)
+
+    return angle_deg
 
 @timer
 def calcSubLine(line: LineLayer, origin: Point, distance: int):

mapmanagercore/layers/polygon.py

@@ -5,6 +5,7 @@
 import geopandas as gp
 from shapely.geometry import Polygon, Point
 
+from mapmanagercore.logger import logger
 
 class PolygonLayer(Layer):
     def box(minx, miny, maxx, maxy):

mapmanagercore/lazy_geo_pandas/lazy.py

@@ -13,6 +13,7 @@
 import geopandas as gp
 from collections.abc import Sequence
 
+from mapmanagercore.logger import logger
 
 class LazyGeoPandas:
     """