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

miblab_plot/image_3d.py

@@ -1,9 +1,6 @@
 from math import ceil
 
 from PIL import Image
-import numpy as np
-
-
 import numpy as np
 import matplotlib
 matplotlib.use('Agg')
@@ -12,31 +9,162 @@ from tqdm import tqdm
 
 
 
-def get_distinct_colors(rois, colormap='jet'):
+def get_distinct_colors(rois, colormap='jet', opacity=0.6):
     if len(rois)==1:
-        colors = [[1, 0, 0, 0.6]]
+        colors = [[1, 0, 0, opacity]]
     elif len(rois)==2:
-        colors = [[1, 0, 0, 0.6], [0, 1, 0, 0.6]]
+        colors = [[1, 0, 0, opacity], [0, 1, 0, opacity]]
     elif len(rois)==3:
-        colors = [[1, 0, 0, 0.6], [0, 1, 0, 0.6], [0, 0, 1, 0.6]]
+        colors = [[1, 0, 0, opacity], [0, 1, 0, opacity], [0, 0, 1, opacity]]
     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
+        colors = [cmap(i)[:3] + (opacity,) for i in np.linspace(0, 1, n)]
 
     return colors
 
 
+def mosaic_checkerboard(fixed, coreg, file, normalize=False, square_size=32, aspect_ratio=1.8, vmin=None, vmax=None):
+
+    fixed = np.array(fixed)
+    coreg = np.array(coreg)
+
+    if fixed.shape != coreg.shape:
+        raise ValueError("Input arrays must have the same shape")
+    
+    if normalize:
+        fixed = _normalize(fixed)
+        coreg = _normalize(coreg)
+        # fixed = (fixed - fixed.min()) / (fixed.max() - fixed.min())
+        # coreg = (coreg - coreg.min()) / (coreg.max() - coreg.min())
+
+    # Set defaults color window
+    if vmin is None:
+        vmin=np.percentile(np.concatenate([fixed, coreg]), 5)
+    if vmax is None:
+        vmax=np.percentile(np.concatenate([fixed, coreg]), 95)
+
+    # Determine number of rows and columns
+    # c*r = n -> c=n/r
+    # c*w / r*h = a -> w*n/r = a*r*h -> (w*n) / (a*h) = r**2
+    width = fixed.shape[0]
+    height = fixed.shape[1]
+    n_mosaics = fixed.shape[2]
+    nrows = int(np.round(np.sqrt((width*n_mosaics)/(aspect_ratio*height))))
+    ncols = int(np.ceil(n_mosaics/nrows))
+
+    # Set up figure 
+    fig, ax = plt.subplots(
+        nrows=nrows, 
+        ncols=ncols, 
+        gridspec_kw = {'wspace':0, 'hspace':0}, 
+        figsize=(ncols*width/max([width,height]), nrows*height/max([width,height])),
+        dpi=300,
+    )
+    plt.subplots_adjust(left=0, right=1, top=1, bottom=0)
+
+    # Build figure
+    i = 0
+    for row in tqdm(ax, desc='Building png'):
+        for col in row:
+
+            col.set_xticklabels([])
+            col.set_yticklabels([])
+            col.set_aspect('equal')
+            col.axis("off")
+
+            # Display the background image
+            if i < n_mosaics:
+                img = checkerboard(fixed[:,:,i], coreg[:,:,i], square_size)
+                col.imshow(
+                    img.T, 
+                    cmap='gray', 
+                    interpolation='none', 
+                    vmin=vmin, 
+                    vmax=vmax,
+                )
+
+            i += 1
+
+    # fig.suptitle('Mask overlay', fontsize=14)
+    fig.savefig(file, bbox_inches='tight', pad_inches=0)
+    plt.close()
+
+
+
+def _normalize(x: np.ndarray) -> np.ndarray:
+    """
+    Normalize an array so that median = 0 and IQR = 1.
+
+    Parameters
+    ----------
+    x : np.ndarray
+        Input array (any shape)
+
+    Returns
+    -------
+    np.ndarray
+        Normalized array
+    """
+    x = np.asarray(x, dtype=float)
+
+    q25, q50, q75 = np.percentile(x, [25, 50, 75])
+    iqr = q75 - q25
+
+    if iqr == 0:
+        raise ValueError("IQR is zero; cannot normalize")
+
+    return (x - q50) / iqr
+
+
+
+def checkerboard(fixed: np.ndarray, coreg: np.ndarray, square_size: int) -> np.ndarray:
+    """
+    Creates a checkerboard pattern from two 2D arrays.
+
+    Parameters
+    ----------
+    fixed : np.ndarray
+        The first 2D array (e.g., fixed image)
+    coreg : np.ndarray
+        The second 2D array (e.g., coregistered image)
+        Must have the same shape as `fixed`.
+    square_size : int
+        The size of each checkerboard square in pixels.
+
+    Returns
+    -------
+    np.ndarray
+        Checkerboard array combining `fixed` and `coreg`.
+    """
+    if fixed.shape != coreg.shape:
+        raise ValueError("Input arrays must have the same shape")
+    
+    rows, cols = fixed.shape
+    
+    # Create a boolean checkerboard mask
+    row_blocks = np.arange(rows) // square_size
+    col_blocks = np.arange(cols) // square_size
+    mask = (row_blocks[:, None] + col_blocks[None, :]) % 2 == 0  # True = use fixed
+    
+    # Build the checkerboard
+    checker = np.where(mask, fixed, coreg)
+    
+    return checker
+
+
+
 def mosaic_overlay(
         img, 
         rois, 
         file, 
         colormap='tab20', 
-        aspect_ratio=16/9, 
+        aspect_ratio=1.8, 
         margin=None,
         vmin=None,
         vmax=None,
+        opacity=0.6,
     ):
 
     # Set defaults color window
@@ -46,7 +174,7 @@ def mosaic_overlay(
         vmax=np.mean(img) + 2 * np.std(img)
 
     # Define RGBA colors (R, G, B, Alpha) — alpha controls transparency
-    colors = get_distinct_colors(rois, colormap=colormap)
+    colors = get_distinct_colors(rois, colormap=colormap, opacity=opacity)
 
     # Get all masks as boolean arrays
     masks = [m.astype(bool) for m in rois.values()]

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()