qim3d/processing/__init__.py

+from ._layers import get_lines, segment_layers
 from ._local_thickness import local_thickness
 from ._structure_tensor import structure_tensor
-from ._layers import segment_layers, get_lines

qim3d/processing/_layers.py

 import numpy as np
-from slgbuilder import GraphObject 
-from slgbuilder import MaxflowBuilder
+from slgbuilder import GraphObject, MaxflowBuilder
 
-def segment_layers(data: np.ndarray, 
+
+def segment_layers(
+    data: np.ndarray,
     inverted: bool = False,
     n_layers: int = 1,
     delta: float = 1,
     min_margin: int = 10,
     max_margin: int = None,
-                   wrap: bool = False
+    wrap: bool = False,
 ) -> list:
     """
     Works on 2D and 3D data.
@@ -56,11 +57,15 @@ def segment_layers(data: np.ndarray,
         if inverted:
             data = ~data
     else:
-        raise TypeError(F"Data has to be type np.ndarray. Your data is of type {type(data)}")
+        raise TypeError(
+            f'Data has to be type np.ndarray. Your data is of type {type(data)}'
+        )
 
     helper = MaxflowBuilder()
     if not isinstance(n_layers, int):
-        raise TypeError(F"Number of layers has to be positive integer. You passed {type(n_layers)}")
+        raise TypeError(
+            f'Number of layers has to be positive integer. You passed {type(n_layers)}'
+        )
 
     if n_layers == 1:
         layer = GraphObject(data)
@@ -69,17 +74,21 @@ def segment_layers(data: np.ndarray,
         layers = [GraphObject(data) for _ in range(n_layers)]
         helper.add_objects(layers)
         for i in range(len(layers) - 1):
-            helper.add_layered_containment(layers[i], layers[i+1], min_margin=min_margin, max_margin=max_margin) 
+            helper.add_layered_containment(
+                layers[i], layers[i + 1], min_margin=min_margin, max_margin=max_margin
+            )
 
     else:
-        raise ValueError(F"Number of layers has to be positive integer. You passed {n_layers}")
+        raise ValueError(
+            f'Number of layers has to be positive integer. You passed {n_layers}'
+        )
 
     helper.add_layered_boundary_cost()
 
     if delta > 1:
         delta = int(delta)
     elif delta <= 0:
-        raise ValueError(F'Delta has to be positive number. You passed {delta}')
+        raise ValueError(f'Delta has to be positive number. You passed {delta}')
     helper.add_layered_smoothness(delta=delta, wrap=bool(wrap))
     helper.solve()
     if n_layers == 1:
@@ -89,6 +98,7 @@ def segment_layers(data: np.ndarray,
 
     return segmentations
 
+
 def get_lines(segmentations: list[np.ndarray]) -> list:
     """
     Expects list of arrays where each array is 2D segmentation with only 2 classes. This function gets the border between those two
@@ -99,6 +109,7 @@ def get_lines(segmentations:list[np.ndarray]) -> list:
 
     Returns:
         segmentation_lines (list): List of 1D numpy arrays
+
     """
     segmentation_lines = [np.argmin(s, axis=0) - 0.5 for s in segmentations]
     return segmentation_lines