qim3d/mesh/_common_mesh_methods.py

+from typing import Any, Tuple
+
 import numpy as np
-from skimage import measure, filters
 import trimesh
-from typing import Tuple, Any
+from skimage import filters, measure
+
 from qim3d.utils._logger import log
 
 
@@ -43,9 +45,10 @@ def from_volume(
         qim3d.viz.mesh(mesh.vertices, mesh.faces)
         ```
         <iframe src="https://platform.qim.dk/k3d/mesh_visualization.html" width="100%" height="500" frameborder="0"></iframe>
+
     """
     if volume.ndim != 3:
-        raise ValueError("The input volume must be a 3D numpy array.")
+        raise ValueError('The input volume must be a 3D numpy array.')
 
     # Compute the threshold level if not provided
     if level is None:
@@ -59,14 +62,18 @@ def from_volume(
         volume = np.pad(
             volume,
             ((pad_z, pad_z), (pad_y, pad_y), (pad_x, pad_x)),
-            mode="constant",
+            mode='constant',
             constant_values=padding_value,
         )
-        log.info(f"Padded volume with {padding} to shape: {volume.shape}")
+        log.info(f'Padded volume with {padding} to shape: {volume.shape}')
 
     # Call skimage.measure.marching_cubes with user-provided kwargs
     verts, faces, normals, values = measure.marching_cubes(
-        volume, level=level, step_size=step_size, allow_degenerate=allow_degenerate, **kwargs
+        volume,
+        level=level,
+        step_size=step_size,
+        allow_degenerate=allow_degenerate,
+        **kwargs,
     )
 
     # Create the Trimesh object

qim3d/ml/__init__.py

 from ._augmentations import Augmentation
 from ._data import Dataset, prepare_dataloaders, prepare_datasets
-from ._ml_utils import inference, model_summary, train_model
+from ._ml_utils import inference, model_summary, train_model, volume_inference
 from .models import *

qim3d/ml/_augmentations.py

 """Class for choosing the level of data augmentations with albumentations"""
 
+
 class Augmentation:
+
     """
     Class for defining image augmentation transformations using the Albumentations library.
 
@@ -17,19 +19,22 @@ class Augmentation:
 
     Example:
         my_augmentation = Augmentation(resize = 'crop', transform_train = 'heavy')
+
     """
 
-    def __init__(self, 
+    def __init__(
+        self,
         resize: str = 'crop',
         transform_train: str = 'moderate',
         transform_validation: str | None = None,
         transform_test: str | None = None,
         mean: float = 0.5,
-                 std: float = 0.5
+        std: float = 0.5,
     ):
-
         if resize not in ['crop', 'reshape', 'padding']:
-            raise ValueError(f"Invalid resize type: {resize}. Use either 'crop', 'resize' or 'padding'.")
+            raise ValueError(
+                f"Invalid resize type: {resize}. Use either 'crop', 'resize' or 'padding'."
+            )
 
         self.resize = resize
         self.mean = mean
@@ -51,27 +56,23 @@ class Augmentation:
 
         Raises:
             ValueError: If `level` is neither None, light, moderate nor heavy.
+
         """
         import albumentations as A
         from albumentations.pytorch import ToTensorV2
 
         # Check if one of standard augmentation levels
         if level not in [None, 'light', 'moderate', 'heavy']:
-            raise ValueError(f"Invalid transformation level: {level}. Please choose one of the following levels: None, 'light', 'moderate', 'heavy'.")
+            raise ValueError(
+                f"Invalid transformation level: {level}. Please choose one of the following levels: None, 'light', 'moderate', 'heavy'."
+            )
 
         # Baseline
-        baseline_aug = [
-            A.Normalize(mean = (self.mean),std = (self.std)),
-            ToTensorV2()
-        ]
+        baseline_aug = [A.Normalize(mean=(self.mean), std=(self.std)), ToTensorV2()]
         if self.resize == 'crop':
-            resize_aug = [
-                A.CenterCrop(im_h,im_w)
-            ]
+            resize_aug = [A.CenterCrop(im_h, im_w)]
         elif self.resize == 'reshape':
-            resize_aug =[
-                A.Resize(im_h,im_w)
-            ]
+            resize_aug = [A.Resize(im_h, im_w)]
         elif self.resize == 'padding':
             resize_aug = [
                 A.PadIfNeeded(im_h, im_w, border_mode=0)  # OpenCV border mode
@@ -81,16 +82,14 @@ class Augmentation:
         if level == None:
             level_aug = []
         elif level == 'light':
-            level_aug = [
-                A.RandomRotate90()
-            ]
+            level_aug = [A.RandomRotate90()]
         elif level == 'moderate':
             level_aug = [
                 A.RandomRotate90(),
                 A.HorizontalFlip(p=0.3),
                 A.VerticalFlip(p=0.3),
                 A.GlassBlur(sigma=0.7, p=0.1),
-                A.Affine(scale = [0.9,1.1], translate_percent = (0.1,0.1))
+                A.Affine(scale=[0.9, 1.1], translate_percent=(0.1, 0.1)),
             ]
         elif level == 'heavy':
             level_aug = [
@@ -98,7 +97,9 @@ class Augmentation:
                 A.HorizontalFlip(p=0.7),
                 A.VerticalFlip(p=0.7),
                 A.GlassBlur(sigma=1.2, iterations=2, p=0.3),
-                A.Affine(scale = [0.8,1.4], translate_percent = (0.2,0.2), shear = (-15,15))
+                A.Affine(
+                    scale=[0.8, 1.4], translate_percent=(0.2, 0.2), shear=(-15, 15)
+                ),
             ]
 
         augment = A.Compose(level_aug + resize_aug + baseline_aug)

qim3d/ml/models/__init__.py

-from ._unet import UNet, Hyperparameters
+from ._unet import Hyperparameters, UNet

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/tests/gui/test_annotation_tool.py

-import qim3d
 import multiprocessing
 import time
 
+import qim3d
+
 
 def test_starting_class():
     app = qim3d.gui.annotation_tool.Interface()
 
-    assert app.title == "Annotation Tool"
+    assert app.title == 'Annotation Tool'
 
 
 def start_server(ip, port):
@@ -15,7 +16,7 @@ def start_server(ip, port):
 
 
 def test_app_launch():
-    ip = "localhost"
+    ip = 'localhost'
     port = 65432
 
     proc = multiprocessing.Process(target=start_server, args=(ip, port))