zea 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

zea/probes.py

@@ -22,7 +22,7 @@ We can initialize a generic probe with the following code:
 
     >>> probe = Probe.from_name("generic")
     >>> print(probe.get_parameters())
-    {'probe_geometry': None, 'center_frequency': None, 'sampling_frequency': None, 'xlims': None, 'zlims': None}
+    {'probe_geometry': None, 'center_frequency': None, 'sampling_frequency': None, 'xlims': None, 'zlims': None, 'n_el': None}
 """  # noqa: E501
 
 import numpy as np
@@ -114,6 +114,7 @@ class Probe(Object):
             "sampling_frequency": self.sampling_frequency,
             "xlims": self.xlims,
             "zlims": self.zlims,
+            "n_el": self.n_el,
         }
 
     @classmethod
@@ -231,12 +232,3 @@ class Esaote_sll1543(Probe):
             bandwidth_MHz=bandwidth_MHz,
             probe_type="linear",
         )
-
-    def get_parameters(self):
-        return {
-            "probe_geometry": self.probe_geometry,
-            "center_frequency": self.center_frequency,
-            "sampling_frequency": self.sampling_frequency,
-            "xlims": self.xlims,
-            "zlims": self.zlims,
-        }

zea/scan.py

@@ -153,13 +153,11 @@ class Scan(Parameters):
         apply_lens_correction (bool, optional): Whether to apply lens correction to
             delays. Defaults to False.
         lens_thickness (float, optional): Thickness of the lens in meters.
-            Defaults to None.
         f_number (float, optional): F-number of the transducer. Defaults to 1.0.
         theta_range (tuple, optional): Range of theta angles for 3D imaging.
         phi_range (tuple, optional): Range of phi angles for 3D imaging.
         rho_range (tuple, optional): Range of rho (radial) distances for 3D imaging.
         fill_value (float, optional): Value to use for out-of-bounds pixels.
-            Defaults to 0.0.
         attenuation_coef (float, optional): Attenuation coefficient in dB/(MHz*cm).
             Defaults to 0.0.
         selected_transmits (None, str, int, list, slice, or np.ndarray, optional):
@@ -215,15 +213,15 @@ class Scan(Parameters):
         "initial_times": {"type": np.ndarray},
         "time_to_next_transmit": {"type": np.ndarray},
         "tgc_gain_curve": {"type": np.ndarray},
-        "waveforms_one_way": {"type": np.ndarray},
-        "waveforms_two_way": {"type": np.ndarray},
+        "waveforms_one_way": {"type": np.ndarray, "default": None},
+        "waveforms_two_way": {"type": np.ndarray, "default": None},
         "tx_waveform_indices": {"type": np.ndarray},
         "t_peak": {"type": np.ndarray},
         # scan conversion parameters
         "theta_range": {"type": (tuple, list)},
         "phi_range": {"type": (tuple, list)},
         "rho_range": {"type": (tuple, list)},
-        "fill_value": {"type": float, "default": 0.0},
+        "fill_value": {"type": float},
         "resolution": {"type": float, "default": None},
     }
 
@@ -242,16 +240,7 @@ class Scan(Parameters):
         if selected_transmits_input is not None:
             self.set_transmits(selected_transmits_input)
 
-    @cache_with_dependencies(
-        "xlims",
-        "zlims",
-        "grid_size_x",
-        "grid_size_z",
-        "sound_speed",
-        "center_frequency",
-        "pixels_per_wavelength",
-        "grid_type",
-    )
+    @cache_with_dependencies("xlims", "zlims", "grid_size_x", "grid_size_z", "grid_type")
     def grid(self):
         """The beamforming grid of shape (grid_size_z, grid_size_x, 3)."""
         if self.grid_type == "polar":
@@ -271,12 +260,7 @@ class Scan(Parameters):
                 "'cartesian' and 'polar'."
             )
 
-    @cache_with_dependencies(
-        "xlims",
-        "wavelength",
-        "pixels_per_wavelength",
-        "grid_type",
-    )
+    @cache_with_dependencies("xlims", "wavelength", "pixels_per_wavelength")
     def grid_size_x(self):
         """Grid width in pixels. For a cartesian grid, this is the lateral (x) pixels in the grid,
         set to prevent aliasing if not provided. For a polar grid, this can be thought of as
@@ -311,7 +295,7 @@ class Scan(Parameters):
         """Calculate the wavelength based on sound speed and center frequency."""
         return self.sound_speed / self.center_frequency
 
-    @cache_with_dependencies("zlims", "grid_type", "polar_limits", "probe_geometry")
+    @cache_with_dependencies("zlims", "polar_limits", "probe_geometry")
     def xlims(self):
         """The x-limits of the beamforming grid [m]. If not explicitly set, it is computed based
         on the polar limits and probe geometry.
@@ -508,7 +492,7 @@ class Scan(Parameters):
         value = self._params.get("azimuth_angles")
         if value is None:
             log.warning("No azimuth angles provided, using zeros")
-            value = np.zeros(self.n_tx_selected)
+            return np.zeros(self.n_tx_selected)
 
         return value[self.selected_transmits]
 
@@ -529,7 +513,7 @@ class Scan(Parameters):
         value = self._params.get("tx_apodizations")
         if value is None:
             log.warning("No transmit apodizations provided, using ones")
-            value = np.ones((self.n_tx_selected, self.n_el))
+            return np.ones((self.n_tx_selected, self.n_el))
 
         return value[self.selected_transmits]
 
@@ -539,7 +523,7 @@ class Scan(Parameters):
         value = self._params.get("focus_distances")
         if value is None:
             log.warning("No focus distances provided, using zeros")
-            value = np.zeros(self.n_tx_selected)
+            return np.zeros(self.n_tx_selected)
 
         return value[self.selected_transmits]
 
@@ -549,16 +533,28 @@ class Scan(Parameters):
         value = self._params.get("initial_times")
         if value is None:
             log.warning("No initial times provided, using zeros")
-            value = np.zeros(self.n_tx_selected)
+            return np.zeros(self.n_tx_selected)
 
         return value[self.selected_transmits]
 
+    @property
+    def n_waveforms(self):
+        """The number of unique transmit waveforms."""
+
+        if self.waveforms_one_way is not None:
+            return self.waveforms_one_way.shape[0]
+
+        if self.waveforms_two_way is not None:
+            return self.waveforms_two_way.shape[0]
+
+        return 1
+
     @property
     def t_peak(self):
         """The time of the peak of the pulse in seconds of shape (n_waveforms,)."""
         t_peak = self._params.get("t_peak")
         if t_peak is None:
-            t_peak = np.array([1 / self.center_frequency])
+            t_peak = np.array([1 / self.center_frequency] * self.n_waveforms)
 
         return t_peak
 
@@ -617,7 +613,7 @@ class Scan(Parameters):
 
     @cache_with_dependencies("pfield")
     def flat_pfield(self):
-        """Flattened pfield for weighting."""
+        """Flattened pfield for weighting of shape (n_pix, n_tx)."""
         return self.pfield.reshape(self.n_tx, -1).swapaxes(0, 1)
 
     @cache_with_dependencies("zlims")
@@ -674,6 +670,17 @@ class Scan(Parameters):
         otherwise 2D."""
         return self.coordinates_3d if getattr(self, "phi_range", None) else self.coordinates_2d
 
+    @property
+    def pulse_repetition_frequency(self):
+        """The pulse repetition frequency (PRF) [Hz]. Assumes a constant PRF."""
+        if self.time_to_next_transmit is None:
+            log.warning("Time to next transmit is not set, cannot compute PRF")
+            return None
+
+        pulse_repetition_interval = np.mean(self.time_to_next_transmit)
+
+        return 1 / pulse_repetition_interval
+
     @cache_with_dependencies("time_to_next_transmit")
     def frames_per_second(self):
         """The number of frames per second [Hz]. Assumes a constant frame rate.