miblab-plot 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

miblab_plot/__init__.py

@@ -1,5 +1,6 @@
-from miblab_plot.image_3d import (
+from .image_3d import (
     volume_to_mosaic, 
     mosaic_overlay, 
     mosaic_checkerboard,
-)
+)
+from . import mp4, pvplot, gui

miblab_plot/gui.py

@@ -0,0 +1,652 @@
+import numpy as np
+import pyvista as pv
+from skimage import measure
+#from pyvistaqt import BackgroundPlotter
+
+
+def rotation_vector_to_matrix(rot_vec):
+    """Convert a rotation vector (axis-angle) to a 3x3 rotation matrix using Rodrigues' formula."""
+    theta = np.linalg.norm(rot_vec)
+    if theta < 1e-8:
+        return np.eye(3)
+    k = rot_vec / theta
+    K = np.array([[    0, -k[2],  k[1]],
+                  [ k[2],     0, -k[0]],
+                  [-k[1],  k[0],     0]])
+    R = np.eye(3) + np.sin(theta) * K + (1 - np.cos(theta)) * (K @ K)
+    return R
+
+
+def ellipsoid_mask(shape, voxel_sizes=(1.0,1.0,1.0), center=(0,0,0), radii=(1,1,1), rot_vec=None):
+    """
+    Generate a 3D mask array with a rotated ellipsoid.
+
+    Parameters
+    ----------
+    shape : tuple of int
+        Shape of the 3D array (z, y, x).
+    voxel_sizes : tuple of float
+        Physical voxel sizes (dz, dy, dx).
+    center : tuple of float
+        Center of the ellipsoid in physical units, with (0,0,0) at the **middle of the volume**.
+    radii : tuple of float
+        Radii of the ellipsoid in physical units.
+    rot_vec : array-like of shape (3,), optional
+        Rotation vector. Magnitude = angle in radians, direction = rotation axis.
+
+    Returns
+    -------
+    mask : np.ndarray of bool
+        Boolean 3D mask with the ellipsoid.
+    """
+    dz, dy, dx = voxel_sizes
+    zdim, ydim, xdim = shape
+
+    # Rotation matrix
+    if rot_vec is None:
+        rotation = np.eye(3)
+    else:
+        rot_vec = np.array(rot_vec, dtype=float)
+        rotation = rotation_vector_to_matrix(rot_vec)
+
+    rz, ry, rx = radii
+    D = np.diag([1/rz**2, 1/ry**2, 1/rx**2])
+    A = rotation @ D @ rotation.T
+
+    # Generate coordinate grids centered at 0
+    z = (np.arange(zdim) - zdim/2 + 0.5) * dz
+    y = (np.arange(ydim) - ydim/2 + 0.5) * dy
+    x = (np.arange(xdim) - xdim/2 + 0.5) * dx
+    zz, yy, xx = np.meshgrid(z, y, x, indexing='ij')
+
+    coords = np.stack([zz - center[0], yy - center[1], xx - center[2]], axis=-1)
+    vals = np.einsum('...i,ij,...j->...', coords, A, coords)
+
+    return vals <= 1.0
+
+
+
+def add_axes(p, xlabel="X", ylabel="Y", zlabel="Z", color=("red", "green", "blue")):
+
+    # Draw your volume/mesh
+    # p.add_volume(grid)
+
+    # Custom axis length
+    L = 50
+
+    # Unit right-handed basis
+    origin = np.array([0,0,0])
+    X = np.array([1,0,0])
+    Y = np.array([0,1,0])
+    Z = np.cross(X, Y)   # guaranteed right-handed
+
+    # Arrows
+    p.add_mesh(pv.Arrow(start=origin, direction=X, scale=L), color=color[0])
+    p.add_mesh(pv.Arrow(start=origin, direction=Y, scale=L), color=color[1])
+    p.add_mesh(pv.Arrow(start=origin, direction=Z, scale=L), color=color[2])
+
+    # Add 3D text at the arrow tips
+    p.add_point_labels([origin + X*L], [xlabel], font_size=20, text_color=color[0], point_size=0)
+    p.add_point_labels([origin + Y*L], [ylabel], font_size=20, text_color=color[1], point_size=0)
+    p.add_point_labels([origin + Z*L], [zlabel], font_size=20, text_color=color[2], point_size=0)
+
+
+
+
+def visualize_surface_reconstruction(original_mesh, reconstructed_mesh, opacity=(0.3,0.3)):
+    # Convert trimesh to pyvista PolyData
+    def trimesh_to_pv(mesh):
+        faces = np.hstack([np.full((len(mesh.faces),1), 3), mesh.faces]).astype(np.int64)
+        return pv.PolyData(mesh.vertices, faces)
+    
+    original_pv = trimesh_to_pv(original_mesh)
+    reconstructed_pv = trimesh_to_pv(reconstructed_mesh)
+
+    plotter = pv.Plotter(window_size=(800,600))
+    plotter.background_color = 'white'
+    plotter.add_mesh(original_pv, color='red', opacity=opacity[0], label='Original')
+    plotter.add_mesh(reconstructed_pv, color='blue', opacity=opacity[1], label='Reconstructed')
+    plotter.add_legend()
+    plotter.add_text("Original (Red) vs Reconstructed (Blue)", font_size=14)
+    plotter.camera_position = 'iso'
+    plotter.show()
+
+
+def display_both_surfaces(mask, mask_recon):
+    # ---------------------------
+    # 7. Visualize with PyVista
+    # ---------------------------
+    # Original mesh
+    grid_orig = pv.wrap(mask.astype(np.uint8))
+    contour_orig = grid_orig.contour(isosurfaces=[0.5])
+
+    # Reconstructed mesh
+    grid_recon = pv.wrap(mask_recon.astype(np.uint8))
+    contour_recon = grid_recon.contour(isosurfaces=[0.5])
+
+    plotter = pv.Plotter(shape=(1,2))
+    plotter.subplot(0,0)
+    plotter.add_text("Original", font_size=12)
+    plotter.add_mesh(contour_orig, color="lightblue")
+
+    plotter.subplot(0,1)
+    plotter.add_text("Reconstructed", font_size=12)
+    plotter.add_mesh(contour_recon, color="salmon")
+
+    plotter.show()
+
+
+
+
+import numpy as np
+import pyvista as pv
+
+def display_volume(
+    kidney,
+    kidney_voxel_size=(1.0, 1.0, 1.0),
+    surface_color='lightblue',
+    opacity=1.0,
+    iso_value=0.5,
+    smooth_iters=20,
+):
+    """
+    Display a single kidney mask in a clean single-panel view.
+
+    Parameters
+    ----------
+    kidney : np.ndarray
+        3D binary mask (bool or 0/1).
+    kidney_voxel_size : tuple
+        Voxel spacing (z, y, x) in world units.
+    surface_color : color-like
+        Color used for the kidney surface.
+    opacity : float
+        Surface opacity.
+    iso_value : float
+        Contour threshold for extracting the surface.
+    smooth_iters : int
+        Number of VTK smoothing iterations to apply (0 to disable).
+    """
+
+    # Ensure voxel spacing is an array
+    kidney_voxel_size = np.asarray(kidney_voxel_size, dtype=float)
+
+    # Build plotter
+    plotter = pv.Plotter(window_size=(900, 700))
+    plotter.background_color = "white"
+
+    # Wrap volume and set spacing so bounds are in world coordinates
+    vol = pv.wrap(kidney.astype(float))
+    vol.spacing = kidney_voxel_size
+
+    # Get isosurface
+    surf = vol.contour(isosurfaces=[iso_value])
+    if smooth_iters and smooth_iters > 0:
+        try:
+            surf = surf.smooth(n_iter=smooth_iters, relaxation_factor=0.1)
+        except Exception:
+            # Some VTK builds may not support smooth; ignore if fails
+            pass
+
+    # Main kidney surface
+    plotter.add_mesh(
+        surf,
+        color=surface_color,
+        opacity=opacity,
+        smooth_shading=True,
+        specular=0.2,
+        specular_power=20,
+        style='surface',
+        name="Kidney Surface"
+    )
+
+    # Bounding box (use the volume's bounds)
+    box = pv.Box(bounds=vol.bounds)
+    plotter.add_mesh(box, color="black", style="wireframe", line_width=2, name="Bounds")
+
+    # Camera & display
+    plotter.camera_position = "iso"
+    plotter.show()  
+
+
+
+
+
+
+
+
+# def _old_compute_principal_axes(mask, voxel_size):
+#     """
+#     Compute centroid and orthonormal principal axes (right-handed) for a 3D binary mask.
+#     Returns centroid (world coords) and axes (3x3 matrix, columns are orthonormal axes).
+#     """
+#     coords = np.argwhere(mask > 0).astype(float)  # (N,3) indices (z,y,x) or (i,j,k)
+#     if coords.size == 0:
+#         raise ValueError("Empty mask provided to compute_principal_axes.")
+#     # Convert to physical/world coordinates by multiplying by voxel spacing
+#     voxel_size = np.asarray(voxel_size, float)
+#     coords_world = coords * voxel_size  # broadcasting (N,3) * (3,) -> (N,3)
+
+#     centroid = coords_world.mean(axis=0)
+#     centered = coords_world - centroid  # (N,3)
+
+#     # SVD on centered coords: Vt rows are principal directions; columns of V are axes
+#     U, S, Vt = np.linalg.svd(centered, full_matrices=False)
+#     axes = Vt.T  # shape (3,3) columns are principal directions (unit length)
+
+#     # Ensure orthonormal (numerical safety) via QR or re-normalize columns
+#     # Re-normalize columns
+#     for i in range(3):
+#         axes[:, i] = axes[:, i] / (np.linalg.norm(axes[:, i]) + 1e-12)
+
+#     # Make right-handed: if determinant negative, flip third axis
+#     if np.linalg.det(axes) < 0:
+#         axes[:, 2] = -axes[:, 2]
+
+#     return centroid, axes
+
+def compute_principal_axes(mask, voxel_size=(1.0, 1.0, 1.0)):
+    """
+    Calculates the physical centroid and normalized, right-handed principal axes 
+    of a 3D binary mask.
+
+    Parameters:
+    -----------
+    mask : np.ndarray
+        A 3D binary array (boolean or 0/1) where True indicates the object.
+    voxel_size : tuple or list of 3 floats
+        The voxel size in physical units (e.g., [dz, dy, dx] or [dx, dy, dz]).
+        Must match the order of dimensions in the mask array.
+
+    Returns:
+    --------
+    centroid : np.ndarray
+        A (3,) array containing the center of mass in physical coordinates.
+    axes : np.ndarray
+        A (3, 3) matrix where each column represents a principal axis vector.
+        - Column 0: Major axis (largest variance)
+        - Column 1: Intermediate axis
+        - Column 2: Minor axis (smallest variance)
+        The system is guaranteed to be right-handed and normalized.
+    """
+    # 1. Get indices of the non-zero voxels (N, 3)
+    indices = np.argwhere(mask)
+    
+    if indices.shape[0] < 3:
+        raise ValueError("Mask must contain at least 3 points to define 3D axes.")
+
+    # 2. Convert to physical coordinates
+    # We multiply the indices by the voxel_size to handle anisotropic voxels correctly
+    points = indices * np.array(voxel_size)
+
+    # 3. Calculate Centroid
+    centroid = np.mean(points, axis=0)
+
+    # 4. Center the points (subtract centroid)
+    points_centered = points - centroid
+
+    # 5. Compute Covariance Matrix
+    # rowvar=False means each column is a variable (x, y, z), each row is an observation
+    cov_matrix = np.cov(points_centered, rowvar=False)
+
+    # 6. Eigendecomposition
+    # eigh is optimized for symmetric matrices (like covariance matrices)
+    eigenvalues, eigenvectors = np.linalg.eigh(cov_matrix)
+
+    # 7. Sort axes by Eigenvalues (descending order)
+    # eigh returns eigenvalues in ascending order, so we reverse them
+    # We want: Index 0 = Major Axis (Largest eigenvalue)
+    sort_indices = np.argsort(eigenvalues)[::-1]
+    
+    sorted_eigenvalues = eigenvalues[sort_indices]
+    sorted_vectors = eigenvectors[:, sort_indices]
+
+    # 8. Enforce Right-Handed Coordinate System
+    # Calculate the determinant. If -1, the system is left-handed (reflection).
+    # We flip the minor axis (last column) to fix this.
+    if np.linalg.det(sorted_vectors) < 0:
+        sorted_vectors[:, -1] *= -1
+
+    return centroid, sorted_vectors
+
+def add_principal_axes(plotter, centroid_world, axes, bounds, colors=("red","green","blue")):
+    """
+    Add principal axes as rays (lines through centroid extending to volume bounds).
+    
+    Args:
+        plotter (pv.Plotter): pyvista plotter
+        centroid_world (np.ndarray): centroid in world coordinates
+        axes (np.ndarray): 3x3 matrix, columns are unit direction vectors
+        bounds (tuple): (xmin, xmax, ymin, ymax, zmin, zmax)
+        colors (tuple): colors for the three axes
+    """
+    centroid_world = np.asarray(centroid_world, float)
+    bounds = np.asarray(bounds).reshape(3,2)  # [[xmin,xmax],[ymin,ymax],[zmin,zmax]]
+
+    for i in range(3):
+        dir_vec = axes[:, i]
+        dir_vec /= np.linalg.norm(dir_vec) + 1e-12
+
+        # For each direction ±dir_vec, compute intersection with bounding box planes
+        line_pts = []
+        for sign in (-1, 1):
+            d = dir_vec * sign
+            t_vals = []
+            for dim in range(3):
+                if abs(d[dim]) > 1e-12:
+                    for plane in bounds[dim]:
+                        t = (plane - centroid_world[dim]) / d[dim]
+                        if t > 0:  # forward intersection
+                            t_vals.append(t)
+            if len(t_vals) > 0:
+                t_min = min(t_vals)
+                pt = centroid_world + d * t_min
+                line_pts.append(pt)
+
+        if len(line_pts) == 2:
+            line = pv.Line(line_pts[0], line_pts[1])
+            plotter.add_mesh(line, color=colors[i], line_width=4, opacity=0.8)
+
+
+# def add_principal_axes(plotter, centroid_world, axes, scale=100.0, colors=("red","green","blue")):
+#     """
+#     Add principal axes as rays (lines through centroid in ± directions).
+#     """
+#     centroid_world = np.asarray(centroid_world, float)
+#     for i in range(3):
+#         direction = axes[:, i] / (np.linalg.norm(axes[:, i]) + 1e-12)
+#         p1 = centroid_world - direction * scale
+#         p2 = centroid_world + direction * scale
+#         line = pv.Line(p1, p2)
+#         plotter.add_mesh(line, color=colors[i], line_width=4, opacity=0.8)
+
+
+def display_two_normalized_kidneys(kidney1, kidney2,
+                        kidney1_voxel_size=(1.0,1.0,1.0),
+                        kidney2_voxel_size=(1.0,1.0,1.0),
+                        title='Two normalized_kidneys'):
+    """
+    Visualize two shapes and overlay computed principal axes.
+    """
+    kidney1_voxel_size = np.asarray(kidney1_voxel_size, float)
+    kidney2_voxel_size = np.asarray(kidney2_voxel_size, float)
+
+    # compute centroids & axes
+    centroid_1, axes_1 = compute_principal_axes(kidney1, kidney1_voxel_size)
+    centroid_2, axes_2 = compute_principal_axes(kidney2, kidney2_voxel_size)
+
+    plotter = pv.Plotter(window_size=(1000,600), shape=(1,2))
+    plotter.background_color = 'white'
+
+    # Original
+    vol_1 = pv.wrap(kidney1.astype(float))
+    vol_1.spacing = kidney1_voxel_size  # ensures world coordinates are correct
+    vol_1_surf = vol_1.contour(isosurfaces=[0.5])
+
+    plotter.subplot(0,0)
+    plotter.add_text(f"{title} (1)", font_size=12)
+    plotter.add_mesh(vol_1_surf, color='lightblue', opacity=1.0, style='surface', ambient=0.1, diffuse=0.9)
+    # box
+    plotter.add_mesh(pv.Box(bounds=vol_1.bounds), color='black', style='wireframe', line_width=2)
+    add_axes(plotter, xlabel='O', ylabel='L', zlabel='T', color=("red", "blue", "green"))
+    add_principal_axes(plotter, centroid_1, axes_1, bounds=vol_1.bounds, colors=("black","black","black"))
+
+    # Normalized
+    vol_2 = pv.wrap(kidney2.astype(float))
+    vol_2.spacing = kidney2_voxel_size
+    vol_2_surf = vol_2.contour(isosurfaces=[0.5])
+
+    plotter.subplot(0,1)
+    plotter.add_text(f"{title} (2)", font_size=12)
+    plotter.add_mesh(vol_2_surf, color='lightblue', opacity=1.0, style='surface', ambient=0.1, diffuse=0.9)
+    plotter.add_mesh(pv.Box(bounds=vol_2.bounds), color='black', style='wireframe', line_width=2)
+    add_axes(plotter, xlabel='O', ylabel='L', zlabel='T', color=("red", "blue", "green"))
+    add_principal_axes(plotter, centroid_2, axes_2, bounds=vol_2.bounds, colors=("black","black","black"))
+
+    plotter.camera_position = 'iso'
+    plotter.show()
+
+def display_two_kidneys(kidney1, kidney2,
+                        kidney1_voxel_size=(1.0,1.0,1.0),
+                        kidney2_voxel_size=(1.0,1.0,1.0),
+                        title1='Kidney 1', title2='Kidney 2'):
+    """
+    Visualize two shapes and overlay computed principal axes.
+    """
+    kidney1_voxel_size = np.asarray(kidney1_voxel_size, float)
+    kidney2_voxel_size = np.asarray(kidney2_voxel_size, float)
+
+    # compute centroids & axes
+    centroid_1, axes_1 = compute_principal_axes(kidney1, kidney1_voxel_size)
+    centroid_2, axes_2 = compute_principal_axes(kidney2, kidney2_voxel_size)
+
+    plotter = pv.Plotter(window_size=(1000,600), shape=(1,2))
+    plotter.background_color = 'white'
+
+    # Original
+    vol_1 = pv.wrap(kidney1.astype(float))
+    vol_1.spacing = kidney1_voxel_size  # ensures world coordinates are correct
+    vol_1_surf = vol_1.contour(isosurfaces=[0.5])
+
+    plotter.subplot(0,0)
+    plotter.add_text(f"{title1}", font_size=12)
+    plotter.add_mesh(vol_1_surf, color='lightblue', opacity=1.0, style='surface', ambient=0.1, diffuse=0.9)
+    # box
+    plotter.add_mesh(pv.Box(bounds=vol_1.bounds), color='black', style='wireframe', line_width=2)
+    add_axes(plotter, xlabel='L', ylabel='F', zlabel='P', color=("red", "green", "blue"))
+    add_principal_axes(plotter, centroid_1, axes_1, bounds=vol_1.bounds, colors=("black","black","black"))
+
+    # Normalized
+    vol_2 = pv.wrap(kidney2.astype(float))
+    vol_2.spacing = kidney2_voxel_size
+    vol_2_surf = vol_2.contour(isosurfaces=[0.5])
+
+    plotter.subplot(0,1)
+    plotter.add_text(f"{title2}", font_size=12)
+    plotter.add_mesh(vol_2_surf, color='lightblue', opacity=1.0, style='surface', ambient=0.1, diffuse=0.9)
+    plotter.add_mesh(pv.Box(bounds=vol_2.bounds), color='black', style='wireframe', line_width=2)
+    add_axes(plotter, xlabel='L', ylabel='F', zlabel='P', color=("red", "green", "blue"))
+    add_principal_axes(plotter, centroid_2, axes_2, bounds=vol_2.bounds, colors=("black","black","black"))
+
+    plotter.camera_position = 'iso'
+    plotter.show()
+
+
+def display_kidney_normalization(kidney, kidney_norm,
+                                 kidney_voxel_size=(1.0,1.0,1.0),
+                                 kidney_norm_voxel_size=None,
+                                 title='Kidney normalization',
+                                 axis_scale=100.0):
+    """
+    Visualize original and normalized kidneys and overlay computed principal axes.
+    """
+    kidney_voxel_size = np.asarray(kidney_voxel_size, float)
+    if kidney_norm_voxel_size is None:
+        kidney_norm_voxel_size = kidney_voxel_size
+    kidney_norm_voxel_size = np.asarray(kidney_norm_voxel_size, float)
+
+    # compute centroids & axes
+    centroid_orig, axes_orig = compute_principal_axes(kidney, kidney_voxel_size)
+    centroid_norm, axes_norm = compute_principal_axes(kidney_norm, kidney_norm_voxel_size)
+
+    plotter = pv.Plotter(window_size=(1000,600), shape=(1,2))
+    plotter.background_color = 'white'
+
+    # Original
+    orig_vol = pv.wrap(kidney.astype(float))
+    orig_vol.spacing = kidney_voxel_size  # ensures world coordinates are correct
+    orig_surf = orig_vol.contour(isosurfaces=[0.5])
+
+    plotter.subplot(0,0)
+    plotter.add_text(f"{title} (original)", font_size=12)
+    plotter.add_mesh(orig_surf, color='lightblue', opacity=1.0, style='surface', ambient=0.1, diffuse=0.9)
+    # box
+    plotter.add_mesh(pv.Box(bounds=orig_vol.bounds), color='black', style='wireframe', line_width=2)
+    add_axes(plotter, xlabel='L', ylabel='F', zlabel='P', color=("red", "green", "blue"))
+    add_principal_axes(plotter, centroid_orig, axes_orig, bounds=orig_vol.bounds, colors=("black","black","black"))
+
+    # Normalized
+    recon_vol = pv.wrap(kidney_norm.astype(float))
+    recon_vol.spacing = kidney_norm_voxel_size
+    recon_surf = recon_vol.contour(isosurfaces=[0.5])
+
+    plotter.subplot(0,1)
+    plotter.add_text(f"{title} (normalized)", font_size=12)
+    plotter.add_mesh(recon_surf, color='lightblue', opacity=1.0, style='surface', ambient=0.1, diffuse=0.9)
+    plotter.add_mesh(pv.Box(bounds=recon_vol.bounds), color='black', style='wireframe', line_width=2)
+    add_axes(plotter, xlabel='O', ylabel='L', zlabel='T', color=("red", "blue", "green"))
+    add_principal_axes(plotter, centroid_norm, axes_norm, bounds=recon_vol.bounds, colors=("black","black","black"))
+
+    plotter.camera_position = 'iso'
+    plotter.show()
+
+
+def compare_processed_kidneys(kidney, kidney_proc, voxel_size=(1.0,1.0,1.0)):
+    """
+    Visualize original and reconstructed 3D volumes in PyVista with correct proportions.
+    """
+    voxel_size = np.array(voxel_size, dtype=float)
+    plotter = pv.Plotter(window_size=(800,600), shape=(1,2))
+    plotter.background_color = 'white'
+
+    # Wrap original volume
+    orig_vol = pv.wrap(kidney.astype(float))
+    orig_vol.spacing = voxel_size
+    orig_surface = orig_vol.contour(isosurfaces=[0.5])
+    plotter.subplot(0,0)
+    plotter.add_text(f"Original", font_size=12)
+    plotter.add_mesh(
+        orig_surface, color='lightblue', opacity=1.0, style='surface',     
+        ambient=0.1,           # ambient term
+        diffuse=0.9,           # diffuse shading
+    )
+    # Add wireframe box around original volume
+    bounds = orig_vol.bounds  # (xmin, xmax, ymin, ymax, zmin, zmax)
+    box = pv.Box(bounds=bounds)
+    plotter.add_mesh(box, color='black', style='wireframe', line_width=2)
+    #add_axes(plotter, xlabel='LO', ylabel='PO', zlabel='HO', color=("red", "blue", "green"))
+    add_axes(plotter, xlabel='O', ylabel='L', zlabel='T', color=("red", "blue", "green"))
+    # # Force camera to look from the opposite direction
+    # plotter.view_vector((-1, 0, 0))  # rotate 180° around vertical axis
+
+    # Wrap reconstructed volume
+    recon_vol = pv.wrap(kidney_proc.astype(float))
+    recon_vol.spacing = voxel_size
+    recon_surface = recon_vol.contour(isosurfaces=[0.5])
+    plotter.subplot(0,1)
+    plotter.add_text(f"Processed", font_size=12)
+    plotter.add_mesh(recon_surface, color='lightblue', opacity=1.0, style='surface',
+        ambient=0.1,           # ambient term
+        diffuse=0.9,           # diffuse shading
+    )
+    # Add wireframe box around original volume
+    bounds = recon_vol.bounds  # (xmin, xmax, ymin, ymax, zmin, zmax)
+    box = pv.Box(bounds=bounds)
+    plotter.add_mesh(box, color='black', style='wireframe', line_width=2)
+    # add_axes(plotter, xlabel='LO', ylabel='PO', zlabel='HO', color=("red", "blue", "green"))
+    add_axes(plotter, xlabel='O', ylabel='L', zlabel='T', color=("red", "blue", "green"))
+
+    # Set the camera position and show the plot
+    plotter.camera_position = 'iso'
+    plotter.show()
+
+
+def display_volumes_two_panel(original_volume, reconstructed_volume, original_voxel_size=(1.0,1.0,1.0), reconstructed_voxel_size=None):
+    """
+    Visualize original and reconstructed 3D volumes in PyVista with correct proportions.
+    """
+    original_voxel_size = np.array(original_voxel_size, dtype=float)
+    if reconstructed_voxel_size is None:
+        reconstructed_voxel_size = original_voxel_size
+    plotter = pv.Plotter(window_size=(800,600), shape=(1,2))
+    plotter.background_color = 'white'
+
+    # Wrap original volume
+    orig_vol = pv.wrap(original_volume.astype(float))
+    orig_vol.spacing = original_voxel_size
+    orig_surface = orig_vol.contour(isosurfaces=[0.5])
+    plotter.subplot(0,0)
+    plotter.add_text("Original", font_size=12)
+    plotter.add_mesh(orig_surface, color='lightblue', opacity=1.0, style='surface')
+    # Add wireframe box around original volume
+    bounds = orig_vol.bounds  # (xmin, xmax, ymin, ymax, zmin, zmax)
+    box = pv.Box(bounds=bounds)
+    plotter.add_mesh(box, color='black', style='wireframe', line_width=2)
+    add_axes(plotter)
+
+    # Wrap reconstructed volume
+    recon_vol = pv.wrap(reconstructed_volume.astype(float))
+    recon_vol.spacing = reconstructed_voxel_size
+    recon_surface = recon_vol.contour(isosurfaces=[0.5])
+    plotter.subplot(0,1)
+    plotter.add_text("Reconstructed", font_size=12)
+    plotter.add_mesh(recon_surface, color='red', opacity=1.0, style='surface')
+    # Add wireframe box around original volume
+    bounds = recon_vol.bounds  # (xmin, xmax, ymin, ymax, zmin, zmax)
+    box = pv.Box(bounds=bounds)
+    plotter.add_mesh(box, color='black', style='wireframe', line_width=2)
+    add_axes(plotter)
+
+    # Set the camera position and show the plot
+    plotter.camera_position = 'iso'
+    plotter.show()
+
+
+def display_volumes(original_volume, reconstructed_volume, original_voxel_size=(1.0,1.0,1.0), reconstructed_voxel_size=None):
+    """
+    Visualize original and reconstructed 3D volumes in PyVista with correct proportions.
+    """
+    original_voxel_size = np.array(original_voxel_size, dtype=float)
+    if reconstructed_voxel_size is None:
+        reconstructed_voxel_size = original_voxel_size
+    plotter = pv.Plotter(window_size=(800,600))
+    plotter.background_color = 'white'
+
+    # Wrap original volume
+    orig_vol = pv.wrap(original_volume.astype(float))
+    orig_vol.spacing = original_voxel_size
+    orig_surface = orig_vol.contour(isosurfaces=[0.5])
+    plotter.add_mesh(orig_surface, color='blue', opacity=0.3, style='surface', label='Original Volume')
+
+    # Wrap reconstructed volume
+    recon_vol = pv.wrap(reconstructed_volume.astype(float))
+    recon_vol.spacing = reconstructed_voxel_size
+    recon_surface = recon_vol.contour(isosurfaces=[0.5])
+    plotter.add_mesh(recon_surface, color='red', opacity=0.3, style='surface', label='Reconstructed Volume')
+
+    # Add wireframe box around original volume
+    bounds = orig_vol.bounds  # (xmin, xmax, ymin, ymax, zmin, zmax)
+    box = pv.Box(bounds=bounds)
+    plotter.add_mesh(box, color='black', style='wireframe', line_width=2)
+
+    plotter.add_legend()
+    plotter.add_text('3D Volume Reconstruction', font_size=20)
+    plotter.camera_position = 'iso'
+    plotter.show()
+
+
+
+
+
+
+
+
+def display_surface(volume_recon):
+
+    # -----------------------
+    # Extract surface mesh (marching cubes)
+    # -----------------------
+    verts, faces, normals, _ = measure.marching_cubes(volume_recon, level=0.5)
+    faces = np.hstack([np.full((faces.shape[0], 1), 3), faces]).astype(np.int32)
+
+    mesh = pv.PolyData(verts, faces)
+    mesh_smooth = mesh.smooth(n_iter=50, relaxation_factor=0.1)
+
+    # -----------------------
+    # PyVista visualization
+    # -----------------------
+    plotter = pv.Plotter()
+    plotter.add_mesh(mesh_smooth, color="lightblue", opacity=1.0, show_edges=False)
+    plotter.add_axes()
+    plotter.show_grid()
+    plotter.show()

miblab_plot/movie.py

@@ -0,0 +1,79 @@
+import os
+import shutil
+
+import imageio.v2 as imageio  # Use v2 interface for compatibility
+from moviepy import VideoFileClip
+import matplotlib
+import numpy as np
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+
+
+
+def get_distinct_colors(rois, colormap='jet'):
+    if len(rois)==1:
+        colors = [[255, 0, 0, 0.6]]
+    elif len(rois)==2:
+        colors = [[255, 0, 0, 0.6], [0, 255, 0, 0.6]]
+    elif len(rois)==3:
+        colors = [[255, 0, 0, 0.6], [0, 255, 0, 0.6], [0, 0, 255, 0.6]]
+    else:
+        n = len(rois)
+        #cmap = cm.get_cmap(colormap, n)
+        cmap = matplotlib.colormaps[colormap]
+        colors = [cmap(i)[:3] + (0.6,) for i in np.linspace(0, 1, n)]  # Set alpha to 0.6 for transparency
+
+    return colors
+
+
+def movie_overlay(img, rois, file):
+
+    # Define RGBA colors (R, G, B, Alpha) — alpha controls transparency
+    colors = get_distinct_colors(rois, colormap='tab20')
+
+    # Directory to store temporary frames
+    tmp = os.path.join(os.getcwd(), 'tmp')
+    os.makedirs(tmp, exist_ok=True)
+    filenames = []
+
+    # Generate and save a sequence of plots
+    for i in tqdm(range(img.shape[2]), desc='Building animation..'):
+
+        # Set up figure
+        fig, ax = plt.subplots(
+            figsize=(5, 5),
+            dpi=300,
+        )
+
+        # Display the background image
+        ax.imshow(img[:,:,i].T, cmap='gray', interpolation='none', vmin=0, vmax=np.mean(img) + 2 * np.std(img))
+
+        # Overlay each mask
+        for mask, color in zip([m.astype(bool) for m in rois.values()], colors):
+            rgba = np.zeros((img.shape[0], img.shape[1], 4), dtype=float)
+            for c in range(4):  # RGBA
+                rgba[..., c] = mask[:,:,i] * color[c]
+            ax.imshow(rgba.transpose((1,0,2)), interpolation='none')
+
+        # Save eachg image to a tmp file
+        fname = os.path.join(tmp, f'frame_{i}.png')
+        fig.savefig(fname)
+        filenames.append(fname)
+        plt.close(fig)
+
+    # Create GIF
+    print('Creating movie')
+    gif = os.path.join(tmp, 'movie.gif')
+    with imageio.get_writer(gif, mode="I", duration=0.2) as writer:
+        for fname in filenames:
+            image = imageio.imread(fname)
+            writer.append_data(image)
+
+    # Load gif
+    clip = VideoFileClip(gif)
+
+    # Save as MP4
+    clip.write_videofile(file, codec='libx264')
+
+    # Clean up temporary files
+    shutil.rmtree(tmp)

miblab_plot/mp4.py

@@ -0,0 +1,83 @@
+import os
+
+from moviepy.video.io.ImageSequenceClip import ImageSequenceClip  # NEW (v2.x)
+
+def images_to_video(image_folder, output_file, fps=30):
+    # 1. Get and sort images
+    images = [os.path.join(image_folder, img) 
+              for img in os.listdir(image_folder) 
+              if img.endswith(".png")]
+    images.sort()
+
+    if not images:
+        print("No images found!")
+        return
+
+    # 2. Create the clip
+    clip = ImageSequenceClip(images, fps=fps)
+    
+    # 3. Write to MP4 (Windows compatible)
+    # The 'logger=None' argument suppresses the progress bar if you want cleaner output
+    clip.write_videofile(output_file, codec='libx264', bitrate="50000k")
+
+# Usage
+# save_high_quality_mp4('your/image/folder', 'video.mp4')
+
+# Usage
+# create_lossless_video('your_folder', 'high_quality.mp4')
+
+# Usage
+# save_high_quality_mp4('my_folder', 'final_video.mp4')
+
+# def _images_to_video(image_folder, output_video_file, fps=30):
+#     """
+#     Converts a folder of PNG images into a video file.
+    
+#     Args:
+#         image_folder (str): Path to the folder containing images.
+#         output_video_file (str): Output filename (e.g., 'output.mp4').
+#         fps (int): Frames per second.
+#     """
+    
+#     # 1. Get the list of files
+#     images = [img for img in os.listdir(image_folder) if img.endswith(".png")]
+    
+#     # 2. Sort the images to ensure they are in the correct order
+#     # Note: This uses standard string sorting. If your files are named 1.png, 10.png, 2.png,
+#     # you might need "natural sorting" logic.
+#     images.sort()
+
+#     if not images:
+#         print("No PNG images found in the directory.")
+#         return
+
+#     # 3. Read the first image to determine width and height
+#     frame = cv2.imread(os.path.join(image_folder, images[0]))
+#     height, width, layers = frame.shape
+#     size = (width, height)
+
+#     # 4. Define the codec and create VideoWriter object
+#     # 'mp4v' is a standard codec for MP4 containers
+#     # fourcc = cv2.VideoWriter_fourcc(*'mp4v') 
+#     fourcc = cv2.VideoWriter_fourcc(*'MJPG') # Motion JPEG codec
+#     out = cv2.VideoWriter(output_video_file, fourcc, fps, size)
+    
+
+#     print(f"Processing {len(images)} images...")
+
+#     # 5. Write images to video
+#     for image in images:
+#         img_path = os.path.join(image_folder, image)
+#         frame = cv2.imread(img_path)
+        
+#         # specific check: resizing might be needed if images vary in size
+#         # frame = cv2.resize(frame, size) 
+        
+#         out.write(frame)
+
+#     # 6. Release everything
+#     out.release()
+#     print(f"Video saved as {output_video_file}")
+
+# # --- Usage Example ---
+# # images_to_video('path/to/your/images', 'my_animation.mp4', fps=24)

miblab_plot/pvplot.py

@@ -0,0 +1,364 @@
+import os
+from pathlib import Path
+from typing import Union
+
+import numpy as np
+from tqdm import tqdm
+import pyvista as pv
+import dbdicom as db
+import zarr
+
+import miblab_ssa as ssa
+
+
+def mosaic_masks_dcm(masks, imagefile, labels=None, view_vector=(1, 0, 0)):
+
+    # Plot settings
+    aspect_ratio = 16/9
+    width = 150
+    height = 150
+
+    # Count nr of mosaics
+    n_mosaics = len(masks)
+    nrows = int(np.ceil(np.sqrt((width*n_mosaics)/(aspect_ratio*height))))
+    ncols = int(np.ceil(n_mosaics/nrows))
+
+    plotter = pv.Plotter(window_size=(ncols*width, nrows*height), shape=(nrows, ncols), border=False, off_screen=True)
+    plotter.background_color = 'white'
+
+    row = 0
+    col = 0
+    for i, mask_series in tqdm(enumerate(masks), desc=f'Building mosaic'):
+
+        # Set up plotter
+        plotter.subplot(row,col)
+        if labels is not None:
+            plotter.add_text(labels[i], font_size=6)
+        if col == ncols-1:
+            col = 0
+            row += 1
+        else:
+            col += 1
+
+        # Load data
+        vol = db.volume(mask_series, verbose=0)
+        mask_norm = ssa.sdf_ft.smooth_mask(vol.values, order=32)
+
+        # Plot tile
+        orig_vol = pv.wrap(mask_norm.astype(float))
+        orig_vol.spacing = vol.spacing
+        orig_surface = orig_vol.contour(isosurfaces=[0.5])
+        plotter.add_mesh(orig_surface, color='lightblue', opacity=1.0, style='surface')
+        plotter.camera_position = 'iso'
+        plotter.view_vector(view_vector)  # rotate 180° around vertical axis
+    
+    plotter.screenshot(imagefile)
+    plotter.close()
+
+
+def rotating_masks_grid(
+        dir_output:str, 
+        masks:Union[zarr.Array, np.ndarray], 
+        labels:np.ndarray=None,
+        nviews=25,
+):
+    # masks: (cols, rows) + 3d shape
+    # labels: (cols, rows)
+    # Plot settings
+    width = 150
+    height = 150
+
+    # Define view points
+    angles = np.linspace(0, 2*np.pi, nviews)
+    dirs = [(np.cos(a), np.sin(a), 0.0) for a in angles] # rotate around z
+    dirs += [(np.cos(a), 0.0, np.sin(a)) for a in angles] # rotate around y
+
+    # Count nr of mosaics
+    ncols = masks.shape[0]
+    nrows = masks.shape[1]
+
+    plotters = {}
+    for i, vec in enumerate(dirs):
+        plotters[i] = pv.Plotter(
+            window_size=(ncols*width, nrows*height), 
+            shape=(nrows, ncols), 
+            border=False, 
+            off_screen=True,
+        )
+        plotters[i].background_color = 'white'
+
+    for row in tqdm(range(nrows), desc=f'Building mosaic'):
+        for col in range(ncols):
+
+            # Load data once
+            mask_norm = masks[col, row, ...]
+
+            orig_vol = pv.wrap(mask_norm.astype(float))
+            orig_vol.spacing = [1.0, 1.0, 1.0]
+            orig_surface = orig_vol.contour(isosurfaces=[0.5])
+
+            prev_up = None
+            for i, vec in enumerate(dirs):
+                # Camera position
+                distance = orig_surface.length * 2.0  # controls zoom
+                center = list(orig_surface.center)
+                pos = center + distance * np.array(vec) # vec = direction
+                up = _camera_up_from_direction(vec, prev_up)
+                prev_up = up
+
+                # Set up plotter
+                plotters[i].subplot(row, col)
+                if labels is not None:
+                    plotters[i].add_text(labels[col, row], font_size=6)
+                plotters[i].add_mesh(orig_surface, color='lightblue', opacity=1.0, style='surface')
+                plotters[i].camera_position = [pos, center, up]
+
+    for i, vec in tqdm(enumerate(dirs), desc='Saving mosaics..'):
+        file = os.path.join(dir_output, f"mosaic_{i:03d}.png")
+        os.makedirs(Path(file).parent, exist_ok=True)
+        plotters[i].screenshot(file)
+        plotters[i].close()
+
+
+
+
+def rotating_mosaics_npz(dir_output, masks, labels=None, chunksize=None, nviews=25, columns=None, rows=None):
+
+    if labels is None:
+        labels = [str(i) for i in range(len(masks))]
+    if chunksize is None:
+        chunksize = len(masks)
+
+    # Split into numbered chunks
+    def chunk_list(lst, size):
+        chunks = [lst[i:i+size] for i in range(0, len(lst), size)]
+        return list(enumerate(chunks))
+     
+    mask_chunks = chunk_list(masks, chunksize)
+    label_chunks = chunk_list(labels, chunksize)
+
+    # Define view points
+    angles = np.linspace(0, 2*np.pi, nviews)
+    dirs = [(np.cos(a), np.sin(a), 0.0) for a in angles] # rotate around z
+    dirs += [(np.cos(a), 0.0, np.sin(a)) for a in angles] # rotate around y
+
+    # Save mosaics for each chunk and view
+    for mask_chunk, label_chunk in zip(mask_chunks, label_chunks):
+        chunk_idx = mask_chunk[0]
+        names = [f"group_{str(chunk_idx).zfill(2)}_{i:02d}.png" for i in range(len(dirs))]
+        directions = {vec: os.path.join(dir_output, name) for name, vec in zip(names, dirs)}
+        multiple_mosaic_masks_npz(mask_chunk[1], directions, label_chunk[1], columns=columns, rows=rows)
+        
+
+def multiple_mosaic_masks_npz(masks, directions:dict, labels, columns=None, rows=None):
+    # Plot settings
+    aspect_ratio = 16/9
+    width = 150
+    height = 150
+
+    # Count nr of mosaics
+    n_mosaics = len(masks)
+    if columns is None:
+        ncols = int(np.ceil(np.sqrt((height*n_mosaics)/(aspect_ratio*width))))
+    else:
+        ncols = columns
+    if rows is None:
+        nrows = int(np.ceil(n_mosaics/ncols))
+    else:
+        nrows = rows
+    # nrows = int(np.ceil(np.sqrt((width*n_mosaics)/(aspect_ratio*height))))
+    # ncols = int(np.ceil(n_mosaics/nrows))
+
+    plotters = {}
+    for vec in directions.keys():
+        plotters[vec] = pv.Plotter(
+            window_size=(ncols*width, nrows*height), 
+            shape=(nrows, ncols), 
+            border=False, 
+            off_screen=True,
+        )
+        plotters[vec].background_color = 'white'
+
+    row = 0
+    col = 0
+    for mask_label, mask_series in tqdm(zip(labels, masks), desc=f'Building mosaic'):
+
+        # Load data once
+        vol = db.npz.volume(mask_series)
+        mask_norm = ssa.sdf_ft.smooth_mask(vol.values.astype(bool), order=32)
+
+        orig_vol = pv.wrap(mask_norm.astype(float))
+        orig_vol.spacing = [1.0, 1.0, 1.0]
+        orig_surface = orig_vol.contour(isosurfaces=[0.5])
+
+        prev_up = None
+        for vec in directions.keys():
+            # Camera position
+            distance = orig_surface.length * 2.0  # controls zoom
+            center = list(orig_surface.center)
+            pos = center + distance * np.array(vec) # vec = direction
+            up = _camera_up_from_direction(vec, prev_up)
+            prev_up = up
+
+            # Set up plotter
+            plotter = plotters[vec]
+            plotter.subplot(row,col)
+            if labels is not None:
+                plotter.add_text(mask_label, font_size=6)
+            plotter.add_mesh(orig_surface, color='lightblue', opacity=1.0, style='surface')
+            plotter.camera_position = [pos, center, up]
+            
+            # plotter.camera_position = 'iso'
+            # plotter.view_vector(vec)  # rotate 180° around vertical axis
+
+        if col == ncols-1:
+            col = 0
+            row += 1
+        else:
+            col += 1
+    
+    for vec, file in directions.items():
+        # plotters[vec].render()
+        plotters[vec].screenshot(file)
+        plotters[vec].close()
+
+
+
+def _camera_up_from_direction(d, prev_up=None):
+    d = np.asarray(d, float)
+    d /= np.linalg.norm(d)
+
+    # 1. First Frame: Use your original logic to establish an initial Up vector
+    if prev_up is None:
+        ref = np.array([0, 0, 1])
+        # If looking straight down Z, switch ref to Y to avoid singularity
+        if abs(np.dot(d, ref)) > 0.99:
+            ref = np.array([0, 1, 0])
+        
+        right = np.cross(ref, d)
+        right /= np.linalg.norm(right)
+        up = np.cross(d, right)
+    
+    # 2. Subsequent Frames: Parallel Transport
+    else:
+        # Project the previous Up vector onto the plane perpendicular to the new direction.
+        # This removes the component of prev_up that is parallel to d.
+        # Formula: v_perp = v - (v . d) * d
+        up = prev_up - np.dot(prev_up, d) * d
+        
+        # Normalize the result
+        norm = np.linalg.norm(up)
+        
+        # Handle rare edge case where d aligns perfectly with prev_up (norm is 0)
+        if norm < 1e-6:
+            # Fallback to initial logic
+            ref = np.array([0, 0, 1])
+            if abs(np.dot(d, ref)) > 0.99:
+                ref = np.array([0, 1, 0])
+            right = np.cross(ref, d)
+            up = np.cross(d, right)
+            up /= np.linalg.norm(up)
+        else:
+            up /= norm
+
+    return up
+
+
+def mosaic_masks_npz(masks, imagefile, labels=None, view_vector=(1, 0, 0)):
+
+    # Plot settings
+    aspect_ratio = 16/9
+    width = 150
+    height = 150
+
+    # Count nr of mosaics
+    n_mosaics = len(masks)
+    nrows = int(np.ceil(np.sqrt((width*n_mosaics)/(aspect_ratio*height))))
+    ncols = int(np.ceil(n_mosaics/nrows))
+
+    plotter = pv.Plotter(
+        window_size=(ncols*width, nrows*height), 
+        shape=(nrows, ncols), 
+        border=False, 
+        off_screen=True,
+    )
+    plotter.background_color = 'white'
+
+    row = 0
+    col = 0
+    for i, mask_series in tqdm(enumerate(masks), desc=f'Building mosaic'):
+
+        # Set up plotter
+        plotter.subplot(row,col)
+        if labels is not None:
+            plotter.add_text(labels[i], font_size=6)
+        if col == ncols-1:
+            col = 0
+            row += 1
+        else:
+            col += 1
+
+        # Load data
+        vol = db.npz.volume(mask_series)
+        mask_norm = ssa.sdf_ft.smooth_mask(vol.values.astype(bool), order=32)
+
+        # Plot tile
+        orig_vol = pv.wrap(mask_norm.astype(float))
+        orig_vol.spacing = [1.0, 1.0, 1.0]
+        orig_surface = orig_vol.contour(isosurfaces=[0.5])
+        plotter.add_mesh(orig_surface, color='lightblue', opacity=1.0, style='surface')
+        plotter.camera_position = 'iso'
+        plotter.view_vector(view_vector)  # rotate 180° around vertical axis
+    
+    plotter.screenshot(imagefile)
+    plotter.close()
+
+
+def mosaic_features_npz(features, imagefile, labels=None, view_vector=(1, 0, 0)):
+
+    # Plot settings
+    aspect_ratio = 16/9
+    width = 150
+    height = 150
+
+    # Count nr of mosaics
+    n_mosaics = len(features)
+    nrows = int(np.ceil(np.sqrt((width*n_mosaics)/(aspect_ratio*height))))
+    ncols = int(np.ceil(n_mosaics/nrows))
+
+    plotter = pv.Plotter(
+        window_size=(ncols*width, nrows*height), 
+        shape=(nrows, ncols), 
+        border=False, 
+        off_screen=True,
+    )
+    plotter.background_color = 'white'
+
+    row = 0
+    col = 0
+    for i, feat in tqdm(enumerate(features), desc=f'Building mosaic'):
+
+        # Set up plotter
+        plotter.subplot(row,col)
+        if labels is not None:
+            plotter.add_text(labels[i], font_size=6)
+        if col == ncols-1:
+            col = 0
+            row += 1
+        else:
+            col += 1
+
+        # Load data
+        ft = np.load(feat)
+        mask_norm = ssa.sdf_ft.mask_from_features(ft['features'], ft['shape'], ft['order'])
+
+        # Plot tile
+        orig_vol = pv.wrap(mask_norm.astype(float))
+        orig_vol.spacing = [1.0, 1.0, 1.0]
+        orig_surface = orig_vol.contour(isosurfaces=[0.5])
+        plotter.add_mesh(orig_surface, color='lightblue', opacity=1.0, style='surface')
+        plotter.camera_position = 'iso'
+        plotter.view_vector(view_vector)  # rotate 180° around vertical axis
+    
+    plotter.screenshot(imagefile)
+    plotter.close()

{miblab_plot-0.0.2.dist-info → miblab_plot-0.0.3.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: miblab-plot
-Version: 0.0.2
+Version: 0.0.3
 Summary: Plotting utilities for medical images
 Author-email: Steven Sourbron <s.sourbron@sheffield.ac.uk>
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://miblab.org/
-Project-URL: Source Code, https://github.com/openmiblab/miblab-plot
+Project-URL: Source Code, https://github.com/openmiblab/pckg-miblab-plot
 Keywords: python,medical imaging,MRI
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -20,6 +20,11 @@ Requires-Dist: pillow
 Requires-Dist: numpy
 Requires-Dist: matplotlib
 Requires-Dist: tqdm
+Requires-Dist: pyvista
+Requires-Dist: scikit-image
+Requires-Dist: moviepy
+Requires-Dist: dbdicom
+Requires-Dist: zarr
 Dynamic: license-file
 
 # miblab-plot

miblab_plot-0.0.3.dist-info/RECORD

@@ -0,0 +1,11 @@
+miblab_plot/__init__.py,sha256=1v5zoONP5hCwbc1ncF4dvt2EUssrmcgYoKm4jEpQkuM,130
+miblab_plot/gui.py,sha256=d-0Ks7vdKHAzm9PczXUrevPqBEIJ_mxak81xvXZVb6Y,25758
+miblab_plot/image_3d.py,sha256=nwP_cF--H_rUSrL-Ozp6qzbO-4Y8159TkWOsg27s5b0,10779
+miblab_plot/movie.py,sha256=eXNkas10U7USIlOoKGcl59GdZy6HEZCXXi1XKvIiQiY,2468
+miblab_plot/mp4.py,sha256=QvJa8RPeTXzoOf0zGoLRY2v6iLqgzz-3XKbi5yYbI7w,2825
+miblab_plot/pvplot.py,sha256=mEW1fOArcl3UDShjfXk8kdRaP9kZ7AONvR1QAAC98Ww,11945
+miblab_plot-0.0.3.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+miblab_plot-0.0.3.dist-info/METADATA,sha256=rZi3f9O3FhD1dh87uTgXmRw9pJ4ACF_9KNmddxCGSh8,1064
+miblab_plot-0.0.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+miblab_plot-0.0.3.dist-info/top_level.txt,sha256=w6glSbOeiZvvL3Tywi8XTJxYAatD7VMkOifD5iKnTSU,12
+miblab_plot-0.0.3.dist-info/RECORD,,

{miblab_plot-0.0.2.dist-info → miblab_plot-0.0.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

miblab_plot-0.0.2.dist-info/RECORD

@@ -1,7 +0,0 @@
-miblab_plot/__init__.py,sha256=7k0ANRoyjRqb-6xxqpbR657tOMBf5UtLmtBif_PC93s,109
-miblab_plot/image_3d.py,sha256=nwP_cF--H_rUSrL-Ozp6qzbO-4Y8159TkWOsg27s5b0,10779
-miblab_plot-0.0.2.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-miblab_plot-0.0.2.dist-info/METADATA,sha256=vAnLpEphCq9CTiEX5JkUONETakTH2ElVgr88HAXBHyg,937
-miblab_plot-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-miblab_plot-0.0.2.dist-info/top_level.txt,sha256=w6glSbOeiZvvL3Tywi8XTJxYAatD7VMkOifD5iKnTSU,12
-miblab_plot-0.0.2.dist-info/RECORD,,