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

zea/models/__init__.py

@@ -4,8 +4,9 @@
 
 Currently, the following models are available (all inherited from :class:`zea.models.BaseModel`):
 
-- :class:`zea.models.echonet.EchoNetDynamic`: A model for echocardiography segmentation.
+- :class:`zea.models.echonet.EchoNetDynamic`: A model for left ventricle segmentation.
 - :class:`zea.models.carotid_segmenter.CarotidSegmenter`: A model for carotid artery segmentation.
+- :class:`zea.models.echonetlvh.EchoNetLVH`: A model for left ventricle hypertrophy segmentation.
 - :class:`zea.models.unet.UNet`: A simple U-Net implementation.
 - :class:`zea.models.lpips.LPIPS`: A model implementing the perceptual similarity metric.
 - :class:`zea.models.taesd.TinyAutoencoder`: A tiny autoencoder model for image compression.
@@ -16,7 +17,7 @@ To use these models, you can import them directly from the :mod:`zea.models` mod
 
 .. code-block:: python
 
-    from zea.models import UNet
+    from zea.models.unet import UNet
 
     model = UNet.from_preset("unet-echonet-inpainter")
 
@@ -48,7 +49,7 @@ An example of how to use the :class:`zea.models.diffusion.DiffusionModel` is sho
 
 .. code-block:: python
 
-    from zea.models import DiffusionModel
+    from zea.models.diffusion import DiffusionModel
 
     model = DiffusionModel.from_preset("diffusion-echonet-dynamic")
     samples = model.sample(n_samples=4)
@@ -74,9 +75,11 @@ The following steps are recommended when adding a new model:
 
 from . import (
     carotid_segmenter,
+    deeplabv3,
     dense,
     diffusion,
     echonet,
+    echonetlvh,
     generative,
     gmm,
     layers,

zea/models/deeplabv3.py

@@ -0,0 +1,131 @@
+"""DeepLabV3+ architecture for multi-class segmentation. For more details see https://arxiv.org/abs/1802.02611."""
+
+import keras
+from keras import layers, ops
+
+
+def convolution_block(
+    block_input,
+    num_filters=256,
+    kernel_size=3,
+    dilation_rate=1,
+    use_bias=False,
+):
+    """
+    Create a convolution block with batch normalization and ReLU activation.
+
+    This is a standard building block used throughout the DeepLabV3+ architecture,
+    consisting of Conv2D -> BatchNormalization -> ReLU.
+
+    Args:
+        block_input (Tensor): Input tensor to the convolution block
+        num_filters (int): Number of output filters/channels. Defaults to 256.
+        kernel_size (int): Size of the convolution kernel. Defaults to 3.
+        dilation_rate (int): Dilation rate for dilated convolution. Defaults to 1.
+        use_bias (bool): Whether to use bias in the convolution layer. Defaults to False.
+
+    Returns:
+        Tensor: Output tensor after convolution, batch normalization, and ReLU
+    """
+    x = layers.Conv2D(
+        num_filters,
+        kernel_size=kernel_size,
+        dilation_rate=dilation_rate,
+        padding="same",
+        use_bias=use_bias,
+        kernel_initializer=keras.initializers.HeNormal(),
+    )(block_input)
+    x = layers.BatchNormalization()(x)
+    return ops.nn.relu(x)
+
+
+def DilatedSpatialPyramidPooling(dspp_input):
+    """
+    Implement Atrous Spatial Pyramid Pooling (ASPP) module.
+
+    ASPP captures multi-scale context by applying parallel atrous convolutions
+    with different dilation rates. This helps the model understand objects
+    at multiple scales.
+
+    The module consists of:
+    - Global average pooling branch
+    - 1x1 convolution branch
+    - 3x3 convolutions with dilation rates 6, 12, and 18
+
+    Reference: https://arxiv.org/abs/1706.05587
+
+    Args:
+        dspp_input (Tensor): Input feature tensor from encoder
+
+    Returns:
+        Tensor: Multi-scale feature representation
+    """
+    dims = dspp_input.shape
+    x = layers.AveragePooling2D(pool_size=(dims[-3], dims[-2]))(dspp_input)
+    x = convolution_block(x, kernel_size=1, use_bias=True)
+    out_pool = layers.UpSampling2D(
+        size=(dims[-3] // x.shape[1], dims[-2] // x.shape[2]),
+        interpolation="bilinear",
+    )(x)
+
+    out_1 = convolution_block(dspp_input, kernel_size=1, dilation_rate=1)
+    out_6 = convolution_block(dspp_input, kernel_size=3, dilation_rate=6)
+    out_12 = convolution_block(dspp_input, kernel_size=3, dilation_rate=12)
+    out_18 = convolution_block(dspp_input, kernel_size=3, dilation_rate=18)
+
+    x = layers.Concatenate(axis=-1)([out_pool, out_1, out_6, out_12, out_18])
+    output = convolution_block(x, kernel_size=1)
+    return output
+
+
+def DeeplabV3Plus(image_shape, num_classes, pretrained_weights=None):
+    """
+    Build DeepLabV3+ model for semantic segmentation.
+
+    DeepLabV3+ combines the benefits of spatial pyramid pooling and encoder-decoder
+    architecture. It uses a ResNet50 backbone as encoder, ASPP for multi-scale
+    feature extraction, and a simple decoder for recovering spatial details.
+
+    Architecture:
+    1. Encoder: ResNet50 backbone with atrous convolutions
+    2. ASPP: Multi-scale feature extraction
+    3. Decoder: Simple decoder with skip connections
+    4. Output: Final segmentation prediction
+
+    Reference: https://arxiv.org/abs/1802.02611
+
+    Args:
+        image_shape (tuple): Input image shape as (height, width, channels)
+        num_classes (int): Number of output classes for segmentation
+        pretrained_weights (str, optional): Pretrained weights for ResNet50 backbone.
+                                          Defaults to None.
+
+    Returns:
+        keras.Model: Complete DeepLabV3+ model
+    """
+    model_input = keras.Input(shape=image_shape)
+    # 3-channel grayscale as repeated single channel for ResNet50
+    model_input_3_channel = ops.concatenate([model_input, model_input, model_input], axis=-1)
+    preprocessed = keras.applications.resnet50.preprocess_input(model_input_3_channel)
+    resnet50 = keras.applications.ResNet50(
+        weights=pretrained_weights, include_top=False, input_tensor=preprocessed
+    )
+    x = resnet50.get_layer("conv4_block6_2_relu").output
+    x = DilatedSpatialPyramidPooling(x)
+
+    input_a = layers.UpSampling2D(
+        size=(image_shape[0] // 4 // x.shape[1], image_shape[1] // 4 // x.shape[2]),
+        interpolation="bilinear",
+    )(x)
+    input_b = resnet50.get_layer("conv2_block3_2_relu").output
+    input_b = convolution_block(input_b, num_filters=48, kernel_size=1)
+
+    x = layers.Concatenate(axis=-1)([input_a, input_b])
+    x = convolution_block(x)
+    x = convolution_block(x)
+    x = layers.UpSampling2D(
+        size=(image_shape[0] // x.shape[1], image_shape[1] // x.shape[2]),
+        interpolation="bilinear",
+    )(x)
+    model_output = layers.Conv2D(num_classes, kernel_size=(1, 1), padding="same")(x)
+    return keras.Model(inputs=model_input, outputs=model_output)

zea/models/diffusion.py

@@ -728,15 +728,15 @@ class DiffusionModel(DeepGenerativeModel):
             )
         return next_noisy_images
 
-    def start_track_progress(self, diffusion_steps):
+    def start_track_progress(self, diffusion_steps, initial_step=0):
         """Initialize the progress tracking for the diffusion process.
-
         For diffusion animation we keep track of the diffusion progress.
         For large number of steps, we do not store all the images due to memory constraints.
         """
         self.track_progress = []
-        if diffusion_steps > 50:
-            self.track_progress_interval = diffusion_steps // 50
+        remaining = max(1, diffusion_steps - int(initial_step))
+        if remaining > 50:
+            self.track_progress_interval = remaining // 50
         else:
             self.track_progress_interval = 1
 

zea/models/echonetlvh.py

@@ -0,0 +1,290 @@
+"""EchoNetLVH model for segmentation of PLAX view cardiac ultrasound. For more details see https://echonet.github.io/lvh/index.html."""
+
+import numpy as np
+from keras import ops
+
+from zea.internal.registry import model_registry
+from zea.models.base import BaseModel
+from zea.models.deeplabv3 import DeeplabV3Plus
+from zea.models.preset_utils import register_presets
+from zea.models.presets import echonet_lvh_presets
+from zea.utils import translate
+
+
+@model_registry(name="echonetlvh")
+class EchoNetLVH(BaseModel):
+    """
+    EchoNet Left Ventricular Hypertrophy (LVH) model for echocardiogram analysis.
+
+    This model performs semantic segmentation on echocardiogram images to identify
+    key anatomical landmarks for measuring left ventricular wall thickness:
+    - LVPWd_1: Left Ventricular Posterior Wall point 1
+    - LVPWd_2: Left Ventricular Posterior Wall point 2
+    - IVSd_1: Interventricular Septum point 1
+    - IVSd_2: Interventricular Septum point 2
+
+    The model outputs 4-channel logits corresponding to heatmaps for each landmark.
+
+    For more information, see the original project page at https://echonet.github.io/lvh/index.html
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initialize the EchoNetLVH model.
+
+        Args:
+            **kwargs: Additional keyword arguments passed to BaseModel
+        """
+        super().__init__(**kwargs)
+
+        # Scan conversion constants for echonet processing
+        self.rho_range = (0, 224)  # Radial distance range in pixels
+        self.theta_range = (np.deg2rad(-45), np.deg2rad(45))  # Angular range in radians
+        self.fill_value = -1.0  # Fill value for scan conversion
+        self.resolution = 1.0  # mm per pixel resolution
+
+        # Network input/output dimensions
+        self.n_rho = 224
+        self.n_theta = 224
+        self.output_shape = (224, 224, 4)
+
+        # Pre-computed coordinate grid for efficient processing
+        self.coordinate_grid = ops.stack(
+            ops.cast(ops.convert_to_tensor(np.indices((224, 224))), "float32"), axis=-1
+        )
+
+        # Initialize the underlying segmentation network
+        self.network = DeeplabV3Plus(image_shape=(224, 224, 3), num_classes=4)
+
+    def call(self, inputs):
+        """
+        Forward pass of the model.
+
+        Args:
+            inputs (Tensor): Input images of shape [B, H, W, C]. They should
+                be scan converted, with pixel values in range [0, 255].
+
+        Returns:
+            Tensor: Logits of shape [B, H, W, 4] with 4 channels for each landmark
+        """
+        assert len(ops.shape(inputs)) == 4
+
+        # Store original dimensions for output resizing
+        original_size = ops.shape(inputs)[1:3]
+
+        # Resize to network input size
+        inputs_resized = ops.image.resize(inputs, size=(224, 224))
+
+        # Get network predictions
+        logits = self.network(inputs_resized)
+
+        # Resize logits back to original input dimensions
+        logits_output = ops.image.resize(logits, original_size)
+        return logits_output
+
+    def extract_key_points_as_indices(self, logits):
+        """
+        Extract key point coordinates from logits using center-of-mass calculation.
+
+        Args:
+            logits (Tensor): Model output logits of shape [B, H, W, 4]
+
+        Returns:
+            Tensor: Key point coordinates of shape [B, 4, 2] where each point
+                   is in (x, y) format
+        """
+        # Create coordinate grid for the current logit dimensions
+        input_shape = ops.shape(logits)[1:3]
+        input_space_coordinate_grid = ops.stack(
+            ops.cast(ops.convert_to_tensor(np.indices(input_shape)), "float32"), axis=-1
+        )
+
+        # Transpose logits to [B, 4, H, W] for vectorized processing
+        logits_batchified = ops.transpose(logits, (0, 3, 1, 2))
+
+        # Extract expected coordinates for each channel
+        return ops.flip(
+            ops.vectorized_map(
+                lambda logit: self.expected_coordinate(logit, input_space_coordinate_grid),
+                logits_batchified,
+            ),
+            axis=-1,  # Flip to convert from (y, x) to (x, y)
+        )
+
+    def expected_coordinate(self, mask, coordinate_grid=None):
+        """
+        Compute the expected coordinate (center-of-mass) of a heatmap.
+
+        This implements a differentiable version of taking the max of a heatmap
+        by computing the weighted average of coordinates.
+
+        Reference: https://arxiv.org/pdf/1711.08229
+
+        Args:
+            mask (Tensor): Heatmap of shape [B, H, W]
+            coordinate_grid (Tensor, optional): Grid of coordinates. If None,
+                                              uses self.coordinate_grid
+
+        Returns:
+            Tensor: Expected coordinates of shape [B, 2] in (x, y) format
+        """
+        if coordinate_grid is None:
+            coordinate_grid = self.coordinate_grid
+
+        # Ensure mask values are non-negative and normalized
+        mask_clipped = ops.clip(mask, 0, None)
+        mask_normed = mask_clipped / ops.max(mask_clipped)
+
+        def safe_normalize(m):
+            mask_sum = ops.sum(m)
+            return ops.where(mask_sum > 0, m / mask_sum, m)
+
+        coordinate_probabilities = ops.map(safe_normalize, mask_normed)
+
+        # Add dimension for broadcasting with coordinate grid
+        coordinate_probabilities = ops.expand_dims(coordinate_probabilities, axis=-1)
+
+        # Compute weighted average of coordinates
+        expected_coordinate = ops.sum(
+            ops.expand_dims(coordinate_grid, axis=0) * coordinate_probabilities,
+            axis=(1, 2),
+        )
+
+        # Flip to convert from (y, x) to (x, y) format for euclidean distance calculation
+        return ops.flip(expected_coordinate, axis=-1)
+
+    def overlay_labels_on_image(self, image, label, alpha=0.5):
+        """
+        Overlay predicted heatmaps and connecting lines on the input image.
+
+        Args:
+            image (Tensor): Input image of shape [H, W] or [H, W, C]
+            label (Tensor): Predicted logits of shape [H, W, 4]
+            alpha (float): Blending factor for overlay (0=transparent, 1=opaque)
+
+        Returns:
+            ndarray: Image with overlaid heatmaps and measurements of shape [H, W, 3]
+        """
+        try:
+            import cv2
+
+        except ImportError as exc:
+            raise ImportError(
+                "OpenCV is required for `EchoNetLVH.overlay_labels_on_image`. "
+                "Please install it with 'pip install opencv-python' or "
+                "'pip install opencv-python-headless'."
+            ) from exc
+
+        # Color scheme for each landmark
+        overlay_colors = np.array(
+            [
+                [1, 1, 0],  # Yellow (LVPWd_X1)
+                [1, 0, 1],  # Magenta (LVPWd_X2)
+                [0, 1, 1],  # Cyan (IVSd_X1)
+                [0, 1, 0],  # Green (IVSd_X2)
+            ],
+        )
+
+        # Convert to numpy and ensure RGB format
+        image = ops.convert_to_numpy(image)
+        label = ops.convert_to_numpy(label)
+
+        if image.ndim == 2:
+            image = np.stack([image] * 3, axis=-1)
+        elif image.shape[-1] == 1:
+            image = np.repeat(image, 3, axis=-1)
+        else:
+            image = image.copy()
+
+        # Normalize each channel to [0, 1] for proper visualization
+        label = np.clip(label, 0, None)
+        for ch in range(label.shape[-1]):
+            max_val = np.max(label[..., ch])
+            if max_val > 0:
+                label[..., ch] = label[..., ch] / max_val
+
+        # Initialize overlay and tracking variables
+        overlay = np.zeros_like(image, dtype=np.float32)
+        centers = []
+
+        # Process each landmark channel
+        for ch in range(4):
+            # Square the mask to enhance peak responses
+            mask = label[..., ch] ** 2
+            color = overlay_colors[ch]
+
+            # Find center of mass for this channel
+            center_coords = self.expected_coordinate(ops.expand_dims(mask, axis=0))
+            center_x = ops.convert_to_numpy(center_coords[0, 0])
+            center_y = ops.convert_to_numpy(center_coords[0, 1])
+
+            # Bounds check before conversion to int
+            if 0 <= center_x < image.shape[1] and 0 <= center_y < image.shape[0]:
+                center = (int(center_x), int(center_y))
+            else:
+                center = None
+
+            if center is not None:
+                # Blend heatmap with overlay
+                mask_alpha = mask * alpha
+                for c in range(3):
+                    overlay[..., c] += mask_alpha * color[c]
+            centers.append(center)
+
+        # Draw connecting lines between consecutive landmarks
+        for i in range(3):
+            pt1, pt2 = centers[i], centers[i + 1]
+            if pt1 is not None and pt2 is not None:
+                color = tuple(int(x) for x in overlay_colors[i])
+
+                # Create line mask
+                line_mask = np.zeros(image.shape[:2], dtype=np.uint8)
+                cv2.line(line_mask, pt1, pt2, color=1, thickness=2)
+
+                # Apply line to overlay
+                for c in range(3):
+                    overlay[..., c][line_mask.astype(bool)] = color[c] * alpha
+
+        # Blend overlay with original image
+        overlay = np.clip(overlay, 0, 1)
+        out = image.astype(np.float32)
+        blend_mask = np.any(overlay > 0.02, axis=-1)
+        out[blend_mask] = (1 - alpha) * out[blend_mask] + overlay[blend_mask]
+
+        return np.clip(out, 0, 1)
+
+    def visualize_logits(self, images, logits):
+        """
+        Create visualization of model predictions overlaid on input images.
+
+        Args:
+            images (Tensor): Input images of shape [B, H, W, C]
+            logits (Tensor): Model predictions of shape [B, H, W, 4]
+
+        Returns:
+            Tensor: Images with overlaid predictions of shape [B, H, W, 3]
+        """
+        # Store original dimensions for final output
+        original_size = ops.shape(images)[1:3]
+
+        # Resize to standard processing size
+        images_resized = ops.image.resize(images, size=(224, 224), interpolation="nearest")
+        logits_resized = ops.image.resize(logits, size=(224, 224), interpolation="nearest")
+
+        # Normalize images to [0, 1] range
+        images_clipped = ops.clip(images_resized, 0, 255)
+        images = translate(images_clipped, range_from=(0, 255), range_to=(0, 1))
+
+        # Generate overlays for each image in the batch
+        images_with_overlay = []
+        for img, logit_heatmap in zip(images, logits_resized):
+            overlay = self.overlay_labels_on_image(img, logit_heatmap)
+            images_with_overlay.append(overlay)
+
+        # Stack results and resize back to original dimensions
+        images_with_overlay = np.stack(images_with_overlay, axis=0)
+        return ops.image.resize(images_with_overlay, original_size)
+
+
+# Register model presets
+register_presets(echonet_lvh_presets, EchoNetLVH)

zea/models/presets.py

@@ -47,6 +47,20 @@ echonet_dynamic_presets = {
     },
 }
 
+echonet_lvh_presets = {
+    "echonetlvh": {
+        "metadata": {
+            "description": (
+                "EchoNetLVH segmentation model for PLAX-view cardiac ultrasound segmentation. "
+                "Trained on images of size (224, 224)."
+            ),
+            "params": 0,
+            "path": "echonetlvh",
+        },
+        "hf_handle": "hf://zeahub/echonetlvh",
+    },
+}
+
 lpips_presets = {
     "lpips": {
         "metadata": {

zea/ops.py

@@ -1376,20 +1376,6 @@ class Mean(Operation):
         return kwargs
 
 
-@ops_registry("transpose")
-class Transpose(Operation):
-    """Transpose the input data along the specified axes."""
-
-    def __init__(self, axes, **kwargs):
-        super().__init__(**kwargs)
-        self.axes = axes
-
-    def call(self, **kwargs):
-        data = kwargs[self.key]
-        transposed_data = ops.transpose(data, axes=self.axes)
-        return {self.output_key: transposed_data}
-
-
 @ops_registry("simulate_rf")
 class Simulate(Operation):
     """Simulate RF data."""
@@ -1578,19 +1564,6 @@ class PfieldWeighting(Operation):
         return {self.output_key: weighted_data}
 
 
-@ops_registry("sum")
-class Sum(Operation):
-    """Sum data along a specific axis."""
-
-    def __init__(self, axis, **kwargs):
-        super().__init__(**kwargs)
-        self.axis = axis
-
-    def call(self, **kwargs):
-        data = kwargs[self.key]
-        return {self.output_key: ops.sum(data, axis=self.axis)}
-
-
 @ops_registry("delay_and_sum")
 class DelayAndSum(Operation):
     """Sums time-delayed signals along channels and transmits."""
@@ -2124,29 +2097,37 @@ class Demodulate(Operation):
 class Lambda(Operation):
     """Use any function as an operation."""
 
-    def __init__(self, func, func_kwargs=None, **kwargs):
-        super().__init__(**kwargs)
-        func_kwargs = func_kwargs or {}
-        self.func = partial(func, **func_kwargs)
-
-    def call(self, **kwargs):
-        data = kwargs[self.key]
-        data = self.func(data)
-        return {self.output_key: data}
-
+    def __init__(self, func, **kwargs):
+        # Split kwargs into kwargs for partial and __init__
+        op_kwargs = {k: v for k, v in kwargs.items() if k not in func.__code__.co_varnames}
+        func_kwargs = {k: v for k, v in kwargs.items() if k in func.__code__.co_varnames}
+        Lambda._check_if_unary(func, **func_kwargs)
 
-@ops_registry("clip")
-class Clip(Operation):
-    """Clip the input data to a given range."""
+        super().__init__(**op_kwargs)
+        self.func = partial(func, **func_kwargs)
 
-    def __init__(self, min_value=None, max_value=None, **kwargs):
-        super().__init__(**kwargs)
-        self.min_value = min_value
-        self.max_value = max_value
+    @staticmethod
+    def _check_if_unary(func, **kwargs):
+        """Checks if the kwargs are sufficient to call the function as a unary operation."""
+        sig = inspect.signature(func)
+        # Remove arguments that are already provided in func_kwargs
+        params = list(sig.parameters.values())
+        remaining = [p for p in params if p.name not in kwargs]
+        # Count required positional arguments (excluding self/cls)
+        required_positional = [
+            p
+            for p in remaining
+            if p.default is p.empty and p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)
+        ]
+        if len(required_positional) != 1:
+            raise ValueError(
+                f"Partial of {func.__name__} must be callable with exactly one required "
+                f"positional argument, we still need: {required_positional}."
+            )
 
     def call(self, **kwargs):
         data = kwargs[self.key]
-        data = ops.clip(data, self.min_value, self.max_value)
+        data = self.func(data)
         return {self.output_key: data}
 
 
@@ -2685,6 +2666,7 @@ class AnisotropicDiffusion(Operation):
         return result
 
 
+@ops_registry("channels_to_complex")
 class ChannelsToComplex(Operation):
     def call(self, **kwargs):
         data = kwargs[self.key]
@@ -2692,6 +2674,7 @@ class ChannelsToComplex(Operation):
         return {self.output_key: output}
 
 
+@ops_registry("complex_to_channels")
 class ComplexToChannels(Operation):
     def __init__(self, axis=-1, **kwargs):
         super().__init__(**kwargs)

zea/scan.py

@@ -149,12 +149,13 @@ class Scan(Parameters):
             Defaults to 0.0.
         attenuation_coef (float, optional): Attenuation coefficient in dB/(MHz*cm).
             Defaults to 0.0.
-        selected_transmits (None, str, int, list, or np.ndarray, optional):
+        selected_transmits (None, str, int, list, slice, or np.ndarray, optional):
             Specifies which transmit events to select.
             - None or "all": Use all transmits.
             - "center": Use only the center transmit.
             - int: Select this many evenly spaced transmits.
             - list/array: Use these specific transmit indices.
+            - slice: Use transmits specified by the slice (e.g., slice(0, 10, 2)).
         grid_type (str, optional): Type of grid to use for beamforming.
             Can be "cartesian" or "polar". Defaults to "cartesian".
         dynamic_range (tuple, optional): Dynamic range for image display.
@@ -171,13 +172,14 @@ class Scan(Parameters):
         "pixels_per_wavelength": {"type": int, "default": 4},
         "pfield_kwargs": {"type": dict, "default": {}},
         "apply_lens_correction": {"type": bool, "default": False},
-        "lens_sound_speed": {"type": (float, int)},
+        "lens_sound_speed": {"type": float},
         "lens_thickness": {"type": float},
         "grid_type": {"type": str, "default": "cartesian"},
         "polar_limits": {"type": (tuple, list)},
         "dynamic_range": {"type": (tuple, list), "default": DEFAULT_DYNAMIC_RANGE},
+        "selected_transmits": {"type": (type(None), str, int, list, slice, np.ndarray)},
         # acquisition parameters
-        "sound_speed": {"type": (float, int), "default": 1540.0},
+        "sound_speed": {"type": float, "default": 1540.0},
         "sampling_frequency": {"type": float},
         "center_frequency": {"type": float},
         "n_el": {"type": int},
@@ -359,6 +361,7 @@ class Scan(Parameters):
                 - "center": Use only the center transmit
                 - int: Select this many evenly spaced transmits
                 - list/array: Use these specific transmit indices
+                - slice: Use transmits specified by the slice (e.g., slice(0, 10, 2))
 
         Returns:
             The current instance for method chaining.
@@ -416,6 +419,10 @@ class Scan(Parameters):
             self._invalidate_dependents("selected_transmits")
             return self
 
+        # Handle slice - convert to list of indices
+        if isinstance(selection, slice):
+            selection = list(range(n_tx_total))[selection]
+
         # Handle list of indices
         if isinstance(selection, list):
             # Validate indices