zea 0.0.4__py3-none-any.whl → 0.0.5__py3-none-any.whl

zea/tensor_ops.py

@@ -1270,6 +1270,14 @@ def L2(x):
     return ops.sqrt(ops.sum(x**2))
 
 
+def L1(x):
+    """L1 norm of a tensor.
+
+    Implementation of L1 norm: https://mathworld.wolfram.com/L1-Norm.html
+    """
+    return ops.sum(ops.abs(x))
+
+
 def linear_sum_assignment(cost):
     """Greedy linear sum assignment.
 
@@ -1325,3 +1333,145 @@ else:
     def safe_vectorize(pyfunc, excluded=None, signature=None):
         """Just a wrapper around ops.vectorize."""
         return ops.vectorize(pyfunc, excluded=excluded, signature=signature)
+
+
+def apply_along_axis(func1d, axis, arr, *args, **kwargs):
+    """Apply a function to 1D array slices along an axis.
+
+    Keras implementation of numpy.apply_along_axis using keras.ops.vectorized_map.
+
+    Args:
+        func1d: A callable function with signature ``func1d(arr, /, *args, **kwargs)``
+            where ``*args`` and ``**kwargs`` are the additional positional and keyword
+            arguments passed to apply_along_axis.
+        axis: Integer axis along which to apply the function.
+        arr: The array over which to apply the function.
+        *args: Additional positional arguments passed through to func1d.
+        **kwargs: Additional keyword arguments passed through to func1d.
+
+    Returns:
+        The result of func1d applied along the specified axis.
+    """
+    # Convert to keras tensor
+    arr = ops.convert_to_tensor(arr)
+
+    # Get array dimensions
+    num_dims = len(arr.shape)
+
+    # Canonicalize axis (handle negative indices)
+    if axis < 0:
+        axis = num_dims + axis
+
+    if axis < 0 or axis >= num_dims:
+        raise ValueError(f"axis {axis} is out of bounds for array of dimension {num_dims}")
+
+    # Create a wrapper function that applies func1d with the additional arguments
+    def func(slice_arr):
+        return func1d(slice_arr, *args, **kwargs)
+
+    # Recursively build up vectorized maps following the JAX pattern
+    # For dimensions after the target axis (right side)
+    for i in range(1, num_dims - axis):
+        prev_func = func
+
+        def make_func(f, dim_offset):
+            def vectorized_func(x):
+                # Move the dimension we want to map over to the front
+                perm = list(range(len(x.shape)))
+                perm[0], perm[dim_offset] = perm[dim_offset], perm[0]
+                x_moved = ops.transpose(x, perm)
+                result = ops.vectorized_map(f, x_moved)
+                # Move the result dimension back if needed
+                if len(result.shape) > 0:
+                    result_perm = list(range(len(result.shape)))
+                    if len(result_perm) > dim_offset:
+                        result_perm[0], result_perm[dim_offset] = (
+                            result_perm[dim_offset],
+                            result_perm[0],
+                        )
+                        result = ops.transpose(result, result_perm)
+                return result
+
+            return vectorized_func
+
+        func = make_func(prev_func, i)
+
+    # For dimensions before the target axis (left side)
+    for i in range(axis):
+        prev_func = func
+
+        def make_func(f):
+            return lambda x: ops.vectorized_map(f, x)
+
+        func = make_func(prev_func)
+
+    return func(arr)
+
+
+def correlate(x, y, mode="full"):
+    """
+    Complex correlation via splitting real and imaginary parts.
+    Equivalent to np.correlate(x, y, mode).
+
+    NOTE: this function exists because tensorflow does not support complex correlation.
+    NOTE: tensorflow also handles padding differently than numpy, so we manually pad the input.
+
+    Args:
+        x: np.ndarray (complex or real)
+        y: np.ndarray (complex or real)
+        mode: "full", "valid", or "same"
+    """
+    x = ops.convert_to_tensor(x)
+    y = ops.convert_to_tensor(y)
+
+    is_complex = "complex" in ops.dtype(x) or "complex" in ops.dtype(y)
+
+    # Split into real and imaginary
+    xr, xi = ops.real(x), ops.imag(x)
+    yr, yi = ops.real(y), ops.imag(y)
+
+    # Pad to do full correlation
+    pad_left = ops.shape(y)[0] - 1
+    pad_right = ops.shape(y)[0] - 1
+    xr = ops.pad(xr, [[pad_left, pad_right]])
+    xi = ops.pad(xi, [[pad_left, pad_right]])
+
+    # Correlation: sum over x[n] * conj(y[n+k])
+    rr = ops.correlate(xr, yr, mode="valid")
+    ii = ops.correlate(xi, yi, mode="valid")
+    ri = ops.correlate(xr, yi, mode="valid")
+    ir = ops.correlate(xi, yr, mode="valid")
+
+    real_part = rr + ii
+    imag_part = ir - ri
+
+    real_part = ops.cast(real_part, "complex64")
+    imag_part = ops.cast(imag_part, "complex64")
+
+    complex_tensor = real_part + 1j * imag_part
+
+    # Extract relevant part based on mode
+    full_length = ops.shape(real_part)[0]
+    x_len = ops.shape(x)[0]
+    y_len = ops.shape(y)[0]
+
+    if mode == "same":
+        # Return output of length max(M, N)
+        target_len = ops.maximum(x_len, y_len)
+        start = ops.floor((full_length - target_len) / 2)
+        start = ops.cast(start, "int32")
+        end = start + target_len
+        complex_tensor = complex_tensor[start:end]
+    elif mode == "valid":
+        # Return output of length max(M, N) - min(M, N) + 1
+        target_len = ops.maximum(x_len, y_len) - ops.minimum(x_len, y_len) + 1
+        start = ops.ceil((full_length - target_len) / 2)
+        start = ops.cast(start, "int32")
+        end = start + target_len
+        complex_tensor = complex_tensor[start:end]
+    # For "full" mode, use the entire result (no slicing needed)
+
+    if is_complex:
+        return complex_tensor
+    else:
+        return ops.real(complex_tensor)

zea/tools/fit_scan_cone.py

@@ -83,8 +83,7 @@ def filter_edge_points_by_boundary(edge_points, is_left=True, min_cone_half_angl
 
 
 def detect_cone_parameters(image, min_cone_half_angle_deg=20, threshold=15):
-    """
-    Detect the ultrasound cone parameters from a grayscale image.
+    """Detect the ultrasound cone parameters from a grayscale image.
 
     This function performs the following steps:
     1. Thresholds the image to create a binary mask
@@ -209,6 +208,7 @@ def detect_cone_parameters(image, min_cone_half_angle_deg=20, threshold=15):
     apex_x = left_a + left_b * apex_y
 
     # Calculate cone height
+    max_y = ops.cast(max_y, apex_y.dtype)
     cone_height = max_y - apex_y
 
     # Calculate opening angle from the line slopes

zea/tools/selection_tool.py

@@ -250,10 +250,13 @@ def add_shape_from_mask(ax, mask, **kwargs):
     Returns:
         plt.ax: matplotlib axis with shape added
     """
-    # Create a Path patch
-    contours = measure.find_contours(mask, 0.5)
+    # Pad mask to ensure edge contours are found
+    padded_mask = np.pad(mask, pad_width=1, mode="constant", constant_values=0)
+    contours = measure.find_contours(padded_mask, 0.5)
     patches = []
     for contour in contours:
+        # Remove padding offset
+        contour -= 1
         path = pltPath(contour[:, ::-1])
         patch = PathPatch(path, **kwargs)
         patches.append(ax.add_patch(patch))
@@ -593,10 +596,11 @@ def interpolate_masks(
     assert all(mask.shape == mask_shape for mask in masks), "All masks must have the same shape."
 
     # distribute number of frames over number of masks
-    num_frames_per_segment = [num_frames // (number_of_masks - 1)] * (number_of_masks - 1)
-    if num_frames % num_frames_per_segment[0] != 0:
-        # make sure that number of frames per mask adds up to total number of frames
-        num_frames_per_segment[-1] += num_frames - sum(num_frames_per_segment)
+    base_frames = num_frames // (number_of_masks - 1)
+    remainder = num_frames % (number_of_masks - 1)
+    num_frames_per_segment = [base_frames] * (number_of_masks - 1)
+    for i in range(remainder):
+        num_frames_per_segment[i] += 1
 
     if rectangle:
         # get the rectangles
@@ -615,7 +619,6 @@ def interpolate_masks(
         for _rectangle in rectangles:
             interpolated_masks.append(reconstruct_mask_from_rectangle(_rectangle, mask_shape))
         return interpolated_masks
-
     # get the contours
     polygons = []
     for mask in masks:
@@ -726,6 +729,17 @@ def update_imshow_with_mask(
     return imshow_obj, mask_obj
 
 
+def ask_for_title():
+    print("What are you selecting?")
+    title = input("Enter a title for the selection: ")
+    if not title:
+        raise ValueError("Title cannot be empty.")
+    # Convert title to snake_case
+    title = title.strip().replace(" ", "_").lower()
+    print(f"Title set to: {title}")
+    return title
+
+
 def main():
     """Main function for interactive selector on multiple images."""
     print(
@@ -751,6 +765,7 @@ def main():
             raise e
         print("No more images selected. Continuing...")
 
+    title = ask_for_title()
     selector = ask_for_selection_tool()
 
     if same_images is True:
@@ -829,6 +844,10 @@ def main():
         else:
             add_shape_from_mask(axs, interpolated_masks[0], alpha=0.5)
 
+        filestem = Path(file.parent / f"{file.stem}_{title}_annotations.gif")
+        np.save(filestem.with_suffix(".npy"), interpolated_masks)
+        print(f"Succesfully saved interpolated masks to {log.yellow(filestem.with_suffix('.npy'))}")
+
         fps = ask_save_animation_with_fps()
 
         ani = FuncAnimation(
@@ -838,9 +857,9 @@ def main():
             fargs=(axs, imshow_obj, images, interpolated_masks, selector),
             interval=1000 / fps,
         )
-        filename = Path(file.parent.stem + "_" + f"{file.stem}_interpolated_masks.gif")
+        filename = filestem.with_suffix(".gif")
         ani.save(filename, writer="pillow")
-        print(f"Succesfully saved animation as {filename}")
+        print(f"Succesfully saved animation as {log.yellow(filename)}")
 
 
 if __name__ == "__main__":

{zea-0.0.4.dist-info → zea-0.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: zea
-Version: 0.0.4
+Version: 0.0.5
 Summary: A Toolbox for Cognitive Ultrasound Imaging. Provides a set of tools for processing of ultrasound data, all built in your favorite machine learning framework.
 Keywords: ultrasound,machine learning,beamforming
 Author: Tristan Stevens
@@ -33,13 +33,14 @@ Requires-Dist: furo ; extra == "dev"
 Requires-Dist: furo ; extra == "docs"
 Requires-Dist: h5py (>=3.11)
 Requires-Dist: huggingface_hub (>=0.26)
+Requires-Dist: imageio[ffmpeg] (>=2.0)
 Requires-Dist: ipykernel (>=6.29.5) ; extra == "dev"
 Requires-Dist: ipykernel (>=6.29.5) ; extra == "tests"
 Requires-Dist: ipywidgets ; extra == "dev"
 Requires-Dist: ipywidgets ; extra == "tests"
 Requires-Dist: jax ; extra == "backends"
 Requires-Dist: jax[cuda12-pip] (>=0.4.26) ; extra == "jax"
-Requires-Dist: keras (>=3.9)
+Requires-Dist: keras (>=3.11)
 Requires-Dist: matplotlib (>=3.8)
 Requires-Dist: mock ; extra == "dev"
 Requires-Dist: mock ; extra == "docs"
@@ -69,6 +70,8 @@ Requires-Dist: scikit-learn (>=1.4)
 Requires-Dist: scipy (>=1.13)
 Requires-Dist: sphinx ; extra == "dev"
 Requires-Dist: sphinx ; extra == "docs"
+Requires-Dist: sphinx-argparse ; extra == "dev"
+Requires-Dist: sphinx-argparse ; extra == "docs"
 Requires-Dist: sphinx-autobuild ; extra == "dev"
 Requires-Dist: sphinx-autobuild ; extra == "docs"
 Requires-Dist: sphinx-autodoc-typehints ; extra == "dev"

{zea-0.0.4.dist-info → zea-0.0.5.dist-info}/RECORD

@@ -1,5 +1,5 @@
-zea/__init__.py,sha256=-et4Iz8oJRRaQahurztVr7Rvz9Do7WkXfq5D5CuhX7w,2274
-zea/__main__.py,sha256=QQaxECJxTUo99q43OobV1Tc9m4POtmjRbeKqpkCZ4Lo,2020
+zea/__init__.py,sha256=Fur5gTy71o142eTY924plqQwlsghVLeHea2-kae9SaA,2345
+zea/__main__.py,sha256=4OCFujuZ5ooIDMF7xxE4Esin9dfFlgX9PdOi9uB64y8,1569
 zea/agent/__init__.py,sha256=uJjMiPvvCXmUxC2mkSkh1Q9Ege0Vf7WazKX1_Ul80GY,924
 zea/agent/gumbel.py,sha256=WbvSrM8meXtZmDLkyXDGUyRzjB4dWZmNO_qzloRxB_s,3770
 zea/agent/masks.py,sha256=qdSGbTs9449hUxcX6gAl_s47mrs1FKI6U_T2KjS-iz8,6581
@@ -32,7 +32,7 @@ zea/beamform/phantoms.py,sha256=zow6j4mPXOJjSl31dLQbuDW8rH_qEV2dsfcy-TqkhkI,1108
 zea/beamform/pixelgrid.py,sha256=XONJqgWC9XUkEL7iaphy0YBr6xLAyXz-yaTdPQju1r0,5432
 zea/config.py,sha256=mhmTxD1ylyc6zl7yq834-BUiBpcqJ-sNVnJd38yinCs,19509
 zea/data/__init__.py,sha256=h2wKll096dKxTRrEKHnFmgURqp9lDHlqJM884HzmhSY,1757
-zea/data/__main__.py,sha256=3KKsj-8ZL1k8vWE7mZkGJyn5xfzVTSK_MaplUgXIUCo,857
+zea/data/__main__.py,sha256=xEXj3m3gJ6MoV1f9WbDl3QVPMbDXedTj1J9WeT83NrI,909
 zea/data/augmentations.py,sha256=R09_dVkhOFGHiiVFaTjP9pYcHCMtwri9Nz8wsM5mRPY,12686
 zea/data/convert/__init__.py,sha256=xuPIB-Dd8voTTRoQr-Mb5KTbPpWzk46alCgKQ_EZqzY,244
 zea/data/convert/camus.py,sha256=PgFN6b0AgHZRS0JjcsiOGOzoagG-sHvlmhDuNR6iNKo,9555
@@ -46,60 +46,65 @@ zea/data/convert/picmus.py,sha256=1TK1vDWzfHmnFErtt0ad36TInIiy4fm3nMmfx83G5nw,62
 zea/data/data_format.py,sha256=n4OTQKl1newgvTamlPprAsRubAVt3bPeNYHJXNc89G0,25684
 zea/data/dataloader.py,sha256=ZAlWbZB6F43EtLvRcUzfeHVtMhYViJTvyaRb9CmpEFc,14865
 zea/data/datasets.py,sha256=XcNlJVmkfNo7TXp80y4Si_by75Ix2ULIU_iEiNEhl6Q,24492
-zea/data/file.py,sha256=dG6if-hofBzfOTr_39_X_OFlTx7t8s7ggrYR7XwyhI8,29387
+zea/data/file.py,sha256=DJHqYlVDNZtQWj0VvytrdGeZEnpDJqc2zZPWz3rF_7k,27152
 zea/data/layers.py,sha256=Tv_dEIX6DZPTVjVMYSPomz1wtkEMrAcX9u9gQkJPRrY,6737
 zea/data/preset_utils.py,sha256=mJ7YC7W9X91__V6Wk2xenORIqZ0reZQerbX3zgapBJM,4408
 zea/data/utils.py,sha256=Y8eO7DznJFiq89SUQmDdiYetQ3aHjf72sC8ih9ooht4,2687
 zea/datapaths.py,sha256=SzsgW4KuZ72aieUbKTUPBmErEPPNcthgI01ixrKX0RQ,20239
-zea/display.py,sha256=nvtef82SiOVZJxm8FgykueIsR7yv8pfGIWOLW4XB_lE,24419
+zea/display.py,sha256=tIrPY2wcQFhdsijgydeNkZviZHkVZDtpz4lFAyPzRv0,24250
+zea/doppler.py,sha256=PG8-GhgTxo2eUjFQ2D6Ag74HD2SkJa6b5LUQjXCS8a8,2994
 zea/interface.py,sha256=2xa3wSNwVlESBa3hWqsJIypjnemioPUGJxEgwl4mDXY,18176
+zea/internal/_generate_keras_ops.py,sha256=0K64fBSDBirTGiwP_qPPT4gdrGwVvKLzPylbHzT-qus,3853
 zea/internal/cache.py,sha256=JHbWJ2vXz_NnXWHXrfSKAhcvi1_JMMeQnBzQIrSlYBo,10559
 zea/internal/checks.py,sha256=Dj8kMY0BY5M170V7NmM9TENyiI7tb6wT9tG6jdrxy-0,10809
 zea/internal/config/create.py,sha256=f8dy6YcAUZbROxwCvORI26ACMRO4Q7EL188KyTL8Bpk,5447
 zea/internal/config/parameters.py,sha256=3YE8aBeiosxTuIT0RAEEMkJPmkykSyZZ7hbmmyGnsuc,6602
 zea/internal/config/validation.py,sha256=vPGFWC-UVtNh8jqfQ4V8HTUIjfnOtsJrqcG2R2ae5hg,6522
-zea/internal/convert.py,sha256=EDg6vY73vQht-AwwrYUJ2XrE2L64qL3JBXxnft7Xw70,4596
-zea/internal/core.py,sha256=QAiN1yFgIm8PGTn8RyE3LyZd5YWpbxuSGwbjfbEYJzU,9387
-zea/internal/device.py,sha256=pcgKHWudolflxe6umQh5DVNDz8QtQBZ8tDiWDNwTays,15175
+zea/internal/core.py,sha256=wJHqp3h_MCCkugTPpvmsxNIOOQ6_VAF7-skNUY-bvmc,9587
+zea/internal/device.py,sha256=YM-yuB2wu8hmILP84LfIjxmcLq9mI6FMI_iS8Lr04i0,15841
 zea/internal/git_info.py,sha256=vEeN7cdppNIJPRkC69pUQqtAfTdwCN-tpfo702xpGzY,1040
-zea/internal/operators.py,sha256=0CMv4s0k8MIlD0uMKcxiHq4YryIfacklBFnCqf7RO0A,1837
-zea/internal/parameters.py,sha256=MbYYQQuESQtzXA1b7S3psESdfTbntzQCgljkV_zTlLw,17857
+zea/internal/notebooks.py,sha256=57qBEJMzLIfWndZslQ6NphJgU4Wlu_jL_XgDWft_xkY,1136
+zea/internal/operators.py,sha256=F4J5R6L_VBfq5JbYKtqXuMQqk1q-L-n3JaOakcX_fDg,2005
+zea/internal/parameters.py,sha256=kyHbEg0otKN-_kPFPIg4iaHSNBJ-TitFmhahR5DRhlk,19871
 zea/internal/registry.py,sha256=lQsJbYUz1S2eKzE-7shRYWUBulX2TjHTRN37evrYIGA,7884
 zea/internal/setup_zea.py,sha256=P8dmHk_0hwfukaf-DfPxeDofOH4Kj1s5YvUs8yeFqAQ,7800
-zea/internal/viewer.py,sha256=VsDehOQgqvVp7gkw0kz2Y2v_My8P8FshJEOCM4E0RIk,15745
-zea/io_lib.py,sha256=z65zGUDaRsxeYnddgy9LtEkbHfKhW3O3wPumqozjZvg,12527
+zea/internal/viewer.py,sha256=nXTJwaWM9x8_R3X8YB9B5bNkZwwfVGKUu8pIr2HMweQ,15840
+zea/io_lib.py,sha256=9yjiYQmoyaJ6IYo4SuNZ5ofX8DB67mbypvmKxd8iZqk,12506
+zea/keras_ops.py,sha256=QUN8sX3tNvyxXPcabiE2V41EJNFDIDBdOrwDscPL1aE,65461
 zea/log.py,sha256=UJIL91lHUgWc-vrlJWOn1PX60fX3TFQ5slIs-b5EWEQ,10540
 zea/metrics.py,sha256=22BonPRPs6sfpDqtSEQGC1icNhsSywBak4iaf_1cook,4894
-zea/models/__init__.py,sha256=gBW1pXrD01beK10dlV6GeY6H17Ym_6wrzMDXrbUs1dk,4183
+zea/models/__init__.py,sha256=xeyo23kLfXCEy92eev4qLVVA2oSVWsN1XXEMsuwrlBU,4325
 zea/models/base.py,sha256=_l1RlXIYS2V5py-en5llJpX1oU0IXK_hzLhfCYybzHg,7121
 zea/models/carotid_segmenter.py,sha256=qxv4xSSbwLQ3AWeP8xoVCFhpPLOqsN-4dNq1ECkG3FM,5401
+zea/models/deeplabv3.py,sha256=Ew-JIaQgekumVZN--pIQ5XQR5xTj1qMbfLm_xQH9qYo,4967
 zea/models/dense.py,sha256=EwrSawfSTi9oWE55Grr7jtwLXC9MNqEOO3su4oYHqfg,4067
-zea/models/diffusion.py,sha256=DJhrV_NGgRFK8p3kIBelM-0mqvmuDbdxRyWugaftv-0,31841
+zea/models/diffusion.py,sha256=Itt6Os7LTtIXBosvqwy9nc2EoClkmIstFgKjALa5DQI,31908
 zea/models/echonet.py,sha256=toLw6QjpdROvGrm6VEuqHuxxKkiAWtX-__5YzrE-LJA,6346
+zea/models/echonetlvh.py,sha256=HlfgzIBg9v6-whTLV-j3g1mopFj4gP7H1AkB9uSI8Ow,10951
 zea/models/generative.py,sha256=iujicyFDuCD7NEk_cZ8thlZ2Rl3Qa8LfkwPsZdWYpR0,2625
 zea/models/gmm.py,sha256=6YYoiizsD7BtISOToEXkki6Cc8iXMkgmPH_rMFQKs3E,8324
 zea/models/layers.py,sha256=hhtBLQgt6ZMKj60FXBNIpThI7gZZeEqkzBMsub_TNFM,1920
 zea/models/lpips.py,sha256=ryJSg2_XIZyOyPP-fcEQKsz3JzlDl9ik4TZPipVbomw,6126
 zea/models/preset_utils.py,sha256=OEs13M92W3NH_lB5_dCvJSNqdW0-QQwKw87QMZg06O4,15396
-zea/models/presets.py,sha256=drTQF2XCAxMFSqZtu_6m-kpPtcG6io4DrXsBcdFss-4,2623
+zea/models/presets.py,sha256=cwua5PBC2zT2J_uExcNzjuc_LT_uEhaOjA29e16M_Yw,3012
 zea/models/taesd.py,sha256=Vab5jywo4uxXPXMQ-8VdpOMhVwQsEc_PNztctDzFZfk,8403
 zea/models/unet.py,sha256=B_600WLn3jj_BuhDdRrj5I1XQIHylaQQN8ISq-vt7zM,6392
 zea/models/utils.py,sha256=My6VY27S4udOn7xatIM22Qgn8jED1FmnA2yZw1mcuVw,2015
-zea/ops.py,sha256=wgm_p1rbQFFQ5856u2SIYGGTv3dFaJR1ogdMkiteChc,109464
+zea/ops.py,sha256=Pe2H8yQ8T8MrASxfaEPmKux5Eiv6-w7a3SkoJhEyDh0,109511
 zea/probes.py,sha256=991X4ilpMablekNxAHwBU6DoBIZHrmzoJgs2C6zfU0U,7632
-zea/scan.py,sha256=dp-PiQZWk4HnRROeu6cwrGcM8FNjezDzkF05ZJcacVI,26935
+zea/scan.py,sha256=vtF60IgP6V2I5wfvT__ZngfFmhqtEGl5LlbCqSEATw0,27339
 zea/simulator.py,sha256=KziYNRNAwIyKNE4nzVp2cbNyLATaaUkF-Ity6O1fx20,11279
-zea/tensor_ops.py,sha256=TA8N9o8fg6sf-d8JFbMDZAeNzyOBOMbLY--guf2HCjE,48284
+zea/tensor_ops.py,sha256=5cphTpARxlpeAfvY-zcdm5KZec1QuzlpwVMqRwZLNdE,53434
 zea/tools/__init__.py,sha256=QunH0W09HdOLYq2rNyNJCajfZgarLjX-ymiHVwjR9Kg,259
-zea/tools/fit_scan_cone.py,sha256=Pw1kiXUAXenCVIO1nfqWVne2i0eWWXHFmoAQ7l_Qzro,24635
+zea/tools/fit_scan_cone.py,sha256=0T6PSmMVb8DmU9yLAc-nqZFd5lhTRMxYCvmDmF3Klx8,24672
 zea/tools/hf.py,sha256=ibuTGaLitK1vOlQdZJuVmDBoUkYRrEfCctj3kiiOQGs,5477
-zea/tools/selection_tool.py,sha256=dNksdVw_sNcelAyszbrseOTQRDxJpwlapabdh7feNoQ,29848
+zea/tools/selection_tool.py,sha256=nEALcrHGLb4NzRRcN_bxYCwzVyHKNN6Y21Q9jsuPFI8,30514
 zea/tools/wndb.py,sha256=8XY056arnDKpVV7k-B5PrMa-RANur3ldPSR4GW3jgS4,666
 zea/utils.py,sha256=8gxZaojsC0D2S63gs6lN0ulcSJ1jry3AzOMFvBdl4H4,23351
 zea/visualize.py,sha256=4-bEHRYG3hUukmBkx7x4VBoa3oAJffO3HnnnzTfduDE,23905
 zea/zea_darkmode.mplstyle,sha256=wHTXkgy00tLEbRmr8GZULb5zIzU0MTMn9xC0Z3WT7Bo,42141
-zea-0.0.4.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-zea-0.0.4.dist-info/METADATA,sha256=VL_XaEx_hcxAPQTU2EcGEaz1RfYxbZ5p_5XRfmqOA6Q,6489
-zea-0.0.4.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-zea-0.0.4.dist-info/entry_points.txt,sha256=hQcQYCHdMu2LRM1PGZuaGU5EwAjTGErC-QakgwZKZeo,41
-zea-0.0.4.dist-info/RECORD,,
+zea-0.0.5.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+zea-0.0.5.dist-info/METADATA,sha256=Usg0MvMgewPYLPS0Illkx1WI6uNy1g_Pn0Vc7wUnA2Q,6626
+zea-0.0.5.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+zea-0.0.5.dist-info/entry_points.txt,sha256=hQcQYCHdMu2LRM1PGZuaGU5EwAjTGErC-QakgwZKZeo,41
+zea-0.0.5.dist-info/RECORD,,

zea/internal/convert.py

@@ -1,150 +0,0 @@
-"""This module contains functionality for converting between hdf5, mat and
-dictionary.
-
-"""
-
-import argparse
-from pathlib import Path
-
-import h5py
-import numpy as np
-import scipy.io as sio
-
-from zea.data.file import recursively_load_dict_contents_from_group
-from zea.internal.viewer import filename_from_window_dialog
-
-
-def load_mat(filename):
-    """
-    This function should be called instead of direct scipy.io.loadmat
-    as it cures the problem of not properly recovering python dictionaries
-    from mat files. It calls the function check keys to cure all entries
-    which are still mat-objects
-    """
-
-    def _check_vars(d):
-        """
-        Checks if entries in dictionary are mat-objects. If yes
-        todict is called to change them to nested dictionaries
-        """
-        for key in d:
-            if isinstance(d[key], sio.matlab.mio5_params.mat_struct):
-                d[key] = _todict(d[key])
-            elif isinstance(d[key], np.ndarray):
-                d[key] = _toarray(d[key])
-        return d
-
-    def _todict(matobj):
-        """
-        A recursive function which constructs from matobjects nested dictionaries
-        """
-        d = {}
-        for strg in matobj._fieldnames:
-            elem = matobj.__dict__[strg]
-            if isinstance(elem, sio.matlab.mio5_params.mat_struct):
-                d[strg] = _todict(elem)
-            elif isinstance(elem, np.ndarray):
-                d[strg] = _toarray(elem)
-            else:
-                d[strg] = elem
-        return d
-
-    def _toarray(ndarray):
-        """
-        A recursive function which constructs ndarray from cellarrays
-        (which are loaded as numpy ndarrays), recursing into the elements
-        if they contain matobjects.
-        """
-        if ndarray.dtype != "float64":
-            elem_list = []
-            for sub_elem in ndarray:
-                if isinstance(sub_elem, sio.matlab.mio5_params.mat_struct):
-                    elem_list.append(_todict(sub_elem))
-                elif isinstance(sub_elem, np.ndarray):
-                    elem_list.append(_toarray(sub_elem))
-                else:
-                    elem_list.append(sub_elem)
-            return np.array(elem_list)
-        else:
-            return ndarray
-
-    data = sio.loadmat(filename, struct_as_record=False, squeeze_me=True)
-    return _check_vars(data)
-
-
-def save_dict_to_file(filename, dic):
-    """Save dict to .mat or .hdf5"""
-
-    filetype = Path(filename).suffix
-    assert filetype in [".mat", ".hdf5"]
-
-    if filetype == ".hdf5":
-        with h5py.File(filename, "w") as h5file:
-            recursively_save_dict_contents_to_group(h5file, "/", dic)
-    elif filetype == ".mat":
-        sio.savemat(filename, dic)
-
-
-def recursively_save_dict_contents_to_group(h5file, path, dic):
-    """Save dict contents to group"""
-    for key, item in dic.items():
-        if isinstance(item, dict):
-            recursively_save_dict_contents_to_group(h5file, path + key + "/", item)
-        else:
-            h5file[path + key] = item
-
-
-def load_dict_from_file(filename, squeeze=True):
-    """dict from file"""
-    filetype = Path(filename).suffix
-    assert filetype in [".mat", ".hdf5"]
-
-    v_7_3 = False
-    if filetype == ".mat":
-        try:
-            return load_mat(filename)
-        except Exception:
-            v_7_3 = True
-
-    if (filetype == ".hdf5") or (v_7_3 is True):
-        with h5py.File(filename, "r", locking=False) as h5file:
-            return recursively_load_dict_contents_from_group(h5file, "/", squeeze)
-
-
-def strip_matfile_keys(dic):
-    """Strip some unecessary .mat keys"""
-    new_dic = {}
-    for key, val in dic.items():
-        if key not in ["__globals__", "__header__", "__version__"]:
-            new_dic[key] = np.squeeze(val)
-    return new_dic
-
-
-def get_args():
-    """Command line argument parser"""
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--file", default=None, help="hdf5 file or mat file")
-    args = parser.parse_args()
-    return args
-
-
-if __name__ == "__main__":
-    args = get_args()
-    data = {}
-    if args.file is None:
-        file = filename_from_window_dialog(
-            "Choose .mat or .hdf5 file",
-            filetypes=(("mat or hdf5", "*.mat *.hdf5 *.h5"),),
-        )
-    else:
-        file = Path(args.file)
-
-    dic = load_dict_from_file(file)
-    if file.suffix == ".mat":
-        dic = strip_matfile_keys(dic)
-        save_dict_to_file(file.with_suffix(".hdf5"), dic)
-
-    elif file.suffix in [".h5", ".hdf5"]:
-        save_dict_to_file(file.with_suffix(".mat"), dic)
-
-    print(f"Succesfully converted {file}")