add option to oversample wci images

Author: peter-urban

python/themachinethatgoesping/pingprocessing/watercolumn/image/__init__.py

@@ -3,7 +3,7 @@
 # modules
 
 # functions
-from .make_wci import make_wci, make_wci_dual_head, make_wci_stack, make_beam_sample_image
+from .make_wci import make_wci, make_wci_dual_head, make_wci_stack, make_beam_sample_image, downsample_wci
 from .imagebuilder import *
 
 #from themachinethatgoesping.pingprocessing_cppy.watercolumn.image import make_wci as make_wci_cppy

python/themachinethatgoesping/pingprocessing/watercolumn/image/imagebuilder.py

@@ -2,7 +2,7 @@
 from themachinethatgoesping.pingprocessing.core.progress import get_progress_iterator
 
 #subpackage imports
-from .make_wci import make_wci, make_wci_dual_head, make_wci_stack, make_beam_sample_image
+from .make_wci import make_wci, make_wci_dual_head, make_wci_stack, make_beam_sample_image, downsample_wci
 
 class ImageBuilder:
 
@@ -12,6 +12,8 @@ def __init__(
         horizontal_pixels,
         wci_render = 'linear',
         progress = False,
+        oversampling = 1,
+        oversampling_mode = 'linear_mean',
         **kwargs):
 
         self.pings = pings
@@ -24,24 +26,29 @@ def __init__(
         else:            
             self.beam_sample_view = False
         self.progress = progress
+        self.oversampling = max(1, int(oversampling))
+        self.oversampling_mode = oversampling_mode
 
-        # if isinstance(self.pings, dict):
-        #     self.dual_head = True
-        # else:
-        #     self.dual_head = False
-
-    def update_args(self, wci_render = 'linear', **kwargs):
+    def update_args(self, wci_render = 'linear', oversampling = None, oversampling_mode = None, **kwargs):
         if wci_render == 'beamsample':
             self.beam_sample_view = True
         else:            
             self.beam_sample_view = False
+        if oversampling is not None:
+            self.oversampling = max(1, int(oversampling))
+        if oversampling_mode is not None:
+            self.oversampling_mode = oversampling_mode
         self.default_args.update(kwargs)
 
     def build(self, index, stack = 1, stack_step = 1, **kwargs):
 
         _kwargs = self.default_args.copy()
         _kwargs.update(kwargs)
-                
+        
+        # Apply oversampling: multiply horizontal_pixels
+        effective_oversampling = self.oversampling
+        if effective_oversampling > 1 and not self.beam_sample_view:
+            _kwargs["horizontal_pixels"] = _kwargs["horizontal_pixels"] * effective_oversampling
 
         if stack > 1:
             max_index = index+stack
@@ -50,17 +57,21 @@ def build(self, index, stack = 1, stack_step = 1, **kwargs):
 
             stack_pings = self.pings[index:max_index:stack_step]
 
-            return make_wci_stack(
+            wci, extent = make_wci_stack(
                 stack_pings,
                 progress=self.progress,
                 **_kwargs)
-
-        if self.beam_sample_view:
-            return make_beam_sample_image(
+        elif self.beam_sample_view:
+            wci, extent = make_beam_sample_image(
                 self.pings[index],
                 **_kwargs)
-                
-
-        return make_wci_dual_head(
-            self.pings[index],
-            **_kwargs)
+        else:
+            wci, extent = make_wci_dual_head(
+                self.pings[index],
+                **_kwargs)
+        
+        # Downsample if oversampling was applied
+        if effective_oversampling > 1 and not self.beam_sample_view:
+            wci, extent = downsample_wci(wci, extent, effective_oversampling, mode=self.oversampling_mode)
+        
+        return wci, extent

python/themachinethatgoesping/pingprocessing/watercolumn/image/make_wci.py

@@ -12,6 +12,62 @@
 # themachinethatgoesping.pingtools/watercolumn imports
 import themachinethatgoesping.pingprocessing.watercolumn.helper as wchelper
 
+
+def downsample_wci(wci, extent, factor, mode="linear_mean"):
+    """Downsample a WCI image by block averaging.
+    
+    Reduces the resolution of a water column image by averaging blocks of
+    pixels. Useful as a post-processing step after building an oversampled
+    image (with higher horizontal_pixels) for anti-aliasing.
+    
+    Args:
+        wci: 2D numpy array of shape (ny, nz) with dB values.
+        extent: Tuple/list of (ymin, ymax, zmax, zmin) — physical bounds.
+        factor: Integer downsampling factor (same for both axes).
+            The image dimensions are divided by this factor.
+        mode: Averaging mode.
+            - 'linear_mean': Convert dB to linear power (10^(0.1*v)),
+              average, convert back (10*log10). Correct for dB data.
+            - 'db_mean': Average directly in dB domain. Faster.
+        
+    Returns:
+        Tuple of (downsampled_wci, extent). Extent is unchanged since
+        the physical bounds remain the same.
+    """
+    factor = int(factor)
+    if factor <= 1:
+        return wci, tuple(extent)
+    
+    if mode not in ("linear_mean", "db_mean"):
+        raise ValueError(f"Invalid mode '{mode}'. Use 'linear_mean' or 'db_mean'.")
+    
+    ny, nz = wci.shape
+    
+    # If image is smaller than one block, return as-is
+    if ny < factor or nz < factor:
+        return wci, tuple(extent)
+    
+    # Trim to exact multiple of factor
+    usable_ny = (ny // factor) * factor
+    usable_nz = (nz // factor) * factor
+    trimmed = wci[:usable_ny, :usable_nz]
+    
+    target_ny = usable_ny // factor
+    target_nz = usable_nz // factor
+    
+    # Reshape into blocks: (target_ny, factor, target_nz, factor)
+    blocked = trimmed.reshape(target_ny, factor, target_nz, factor)
+    
+    if mode == "linear_mean":
+        with np.errstate(invalid='ignore'):
+            linear = np.power(10.0, np.float64(blocked) * 0.1)
+            mean_linear = np.nanmean(linear, axis=(1, 3))
+            result = (10.0 * np.log10(mean_linear)).astype(np.float32)
+    else:
+        result = np.nanmean(blocked, axis=(1, 3)).astype(np.float32)
+    
+    return result, tuple(extent)
+
 def is_iterable(obj):
     try:
         iter(obj)

python/themachinethatgoesping/pingprocessing/widgets/wciviewer_pyqtgraph2.py

@@ -514,11 +514,23 @@ def _build_ui(self) -> None:
             value=self.args_imagebuilder["horizontal_pixels"],
             layout=ipywidgets.Layout(width='200px'),
         )
+        self.w_oversampling = ipywidgets.Dropdown(
+            description="oversample",
+            options=[1, 2, 3, 4],
+            value=1,
+            layout=ipywidgets.Layout(width='140px'),
+        )
+        self.w_oversampling_mode = ipywidgets.Dropdown(
+            description="avg",
+            options=["linear_mean", "db_mean"],
+            value="linear_mean",
+            layout=ipywidgets.Layout(width='170px'),
+        )
 
         # Observe global controls for rebuild
         for widget in [self.w_stack, self.w_stack_step, self.w_mp_cores,
                        self.w_stack_linear, self.w_wci_value, self.w_wci_render,
-                       self.w_horizontal_pixels]:
+                       self.w_horizontal_pixels, self.w_oversampling, self.w_oversampling_mode]:
             widget.observe(self._on_global_param_change, names="value")
 
         # Fix/unfix view buttons
@@ -600,10 +612,21 @@ def _build_ui(self) -> None:
         )
         self.w_video_format = ipywidgets.Dropdown(
             description="format",
-            options=["mp4", "gif", "webm", "avi"],
+            options=["mp4", "gif", "avif", "webm", "avi"],
             value="mp4",
             layout=ipywidgets.Layout(width='130px'),
         )
+        self.w_video_quality = ipywidgets.IntSlider(
+            value=50,
+            min=1,
+            max=100,
+            step=1,
+            description="quality",
+            tooltip="Compression quality for AVIF (1=smallest, 100=best)",
+            layout=ipywidgets.Layout(width='200px'),
+        )
+        self.w_video_quality.layout.display = 'none'  # hidden unless avif selected
+        self.w_video_format.observe(self._on_video_format_change, names='value')
         self.w_video_filename = ipywidgets.Text(
             value="wci_video",
             description="filename",
@@ -760,7 +783,7 @@ def _assemble_layout(self) -> None:
         tab_render = ipywidgets.VBox([
             ipywidgets.HBox([self.w_vmin, self.w_vmax]),
             ipywidgets.HBox([self.w_wci_value, self.w_wci_render]),
-            ipywidgets.HBox([self.w_horizontal_pixels]),
+            ipywidgets.HBox([self.w_horizontal_pixels, self.w_oversampling, self.w_oversampling_mode]),
             ipywidgets.HBox([self.w_time_sync, self.w_crosshair, self.w_time_warning]),
         ])
 
@@ -780,7 +803,7 @@ def _assemble_layout(self) -> None:
 
         # Tab 5: Video export
         tab_video = ipywidgets.VBox([
-            ipywidgets.HBox([self.w_video_frames, self.w_video_fps, self.w_video_format]),
+            ipywidgets.HBox([self.w_video_frames, self.w_video_fps, self.w_video_format, self.w_video_quality]),
             ipywidgets.HBox([self.w_video_filename, self.w_video_ping_time, self.w_video_live, self.w_export_video]),
             self.w_video_status,
         ])
@@ -821,6 +844,13 @@ def _assemble_layout(self) -> None:
             self.output,
         ])
 
+    def _on_video_format_change(self, change: Dict[str, Any]) -> None:
+        """Show/hide the quality slider based on selected format."""
+        if change['new'] == 'avif':
+            self.w_video_quality.layout.display = None
+        else:
+            self.w_video_quality.layout.display = 'none'
+
     def _on_layout_change(self, change: Dict[str, Any]) -> None:
         """Handle grid layout change."""
         new_rows, new_cols = change['new']
@@ -1099,6 +1129,8 @@ def _sync_builder_args(self) -> None:
         self.args_imagebuilder["wci_render"] = self.w_wci_render.value
         self.args_imagebuilder["horizontal_pixels"] = self.w_horizontal_pixels.value
         self.args_imagebuilder["mp_cores"] = self.w_mp_cores.value
+        self.args_imagebuilder["oversampling"] = self.w_oversampling.value
+        self.args_imagebuilder["oversampling_mode"] = self.w_oversampling_mode.value
 
         # Update all slot imagebuilders
         for slot in self.slots:
@@ -1413,6 +1445,36 @@ def _export_video(self, _event: Any = None) -> None:
                         imageio.mimsave(filename, frames, duration=durations)
                     else:
                         imageio.mimsave(filename, frames, duration=1.0/video_fps)
+            elif fmt == "avif":
+                # Use pillow-avif-plugin for animated AVIF export
+                try:
+                    import pillow_avif  # noqa: F401 – registers .avif with Pillow
+                except ImportError:
+                    self.w_video_status.value = "Error: pip install pillow-avif-plugin"
+                    return
+                try:
+                    from PIL import Image
+                    pil_frames = [Image.fromarray(f) for f in frames]
+                    quality = self.w_video_quality.value
+
+                    if use_ping_time and durations:
+                        duration_ms = [int(d * 1000) for d in durations]
+                        while len(duration_ms) < len(pil_frames):
+                            duration_ms.append(int(1000 / video_fps))
+                    else:
+                        duration_ms = int(1000 / video_fps)
+
+                    pil_frames[0].save(
+                        filename,
+                        save_all=True,
+                        append_images=pil_frames[1:],
+                        duration=duration_ms,
+                        loop=0,
+                        quality=quality,
+                    )
+                except Exception as e:
+                    self.w_video_status.value = f"AVIF error: {e}"
+                    return
             else:
                 # For video formats (mp4, avi, webm), use imageio with ffmpeg plugin
                 try: