small fix to echogramviewer qt

Author: peter-urban

python/themachinethatgoesping/pingprocessing/watercolumn/echograms/echogrambuilder_refactored.py

@@ -407,6 +407,9 @@ def build_image(self, progress=None):
     def build_image_and_layer_image(self, progress=None):
         """Build echogram image and combined layer image.
         
+        Uses fast vectorized get_image() for the main echogram when no main_layer
+        is set. Falls back to per-column iteration only for layer processing.
+        
         Returns:
             Tuple of (image, layer_image, extent).
         """
@@ -415,29 +418,34 @@ def build_image_and_layer_image(self, progress=None):
         ny = len(cs.y_coordinates)
         nx = len(cs.feature_mapper.get_feature_values("X coordinate"))
 
-        image = np.empty((nx, ny), dtype=np.float32)
-        image.fill(np.nan)
-        layer_image = image.copy()
-
-        image_indices, wci_indices = self.get_x_indices()
-        image_indices = get_progress_iterator(image_indices, progress, desc="Building echogram image")
-
-        for image_index, wci_index in zip(image_indices, wci_indices):
-            wci = self.get_column(wci_index)
-            if len(wci) > 1:
-                if self.main_layer is None:
-                    y1, y2 = self.get_y_indices(wci_index)
-                    if len(y1) > 0:
-                        image[image_index, y1] = wci[y2]
-                else:
+        # Fast path: use vectorized get_image for main echogram if no main_layer
+        if self.main_layer is None:
+            request = cs.make_image_request()
+            image = self._backend.get_image(request)
+        else:
+            # Slow path: need per-column iteration for main_layer
+            image = np.full((nx, ny), np.nan, dtype=np.float32)
+            image_indices, wci_indices = self.get_x_indices()
+            for image_index, wci_index in zip(image_indices, wci_indices):
+                wci = self.get_column(wci_index)
+                if len(wci) > 1:
                     y1, y2 = self.main_layer.get_y_indices(wci_index)
                     if y1 is not None and len(y1) > 0:
                         image[image_index, y1] = wci[y2]
 
-                for k, layer in self.layers.items():
-                    y1_layer, y2_layer = layer.get_y_indices(wci_index)
-                    if y1_layer is not None and len(y1_layer) > 0:
-                        layer_image[image_index, y1_layer] = wci[y2_layer]
+        # Build layer image (requires per-column iteration)
+        layer_image = np.full((nx, ny), np.nan, dtype=np.float32)
+        if len(self.layers) > 0:
+            image_indices, wci_indices = self.get_x_indices()
+            image_indices = get_progress_iterator(image_indices, progress, desc="Building layer image")
+            
+            for image_index, wci_index in zip(image_indices, wci_indices):
+                wci = self.get_column(wci_index)
+                if len(wci) > 1:
+                    for k, layer in self.layers.items():
+                        y1_layer, y2_layer = layer.get_y_indices(wci_index)
+                        if y1_layer is not None and len(y1_layer) > 0:
+                            layer_image[image_index, y1_layer] = wci[y2_layer]
 
         extent = deepcopy(cs.x_extent)
         extent.extend(cs.y_extent)
@@ -447,6 +455,9 @@ def build_image_and_layer_image(self, progress=None):
     def build_image_and_layer_images(self, progress=None):
         """Build echogram image and individual layer images.
         
+        Uses fast vectorized get_image() for the main echogram when no main_layer
+        is set. Falls back to per-column iteration only for layer processing.
+        
         Returns:
             Tuple of (image, layer_images_dict, extent).
         """
@@ -455,32 +466,37 @@ def build_image_and_layer_images(self, progress=None):
         ny = len(cs.y_coordinates)
         nx = len(cs.feature_mapper.get_feature_values("X coordinate"))
 
-        image = np.empty((nx, ny), dtype=np.float32)
-        image.fill(np.nan)
+        # Fast path: use vectorized get_image for main echogram if no main_layer
+        if self.main_layer is None:
+            request = cs.make_image_request()
+            image = self._backend.get_image(request)
+        else:
+            # Slow path: need per-column iteration for main_layer
+            image = np.full((nx, ny), np.nan, dtype=np.float32)
+            image_indices, wci_indices = self.get_x_indices()
+            for image_index, wci_index in zip(image_indices, wci_indices):
+                wci = self.get_column(wci_index)
+                if len(wci) > 1:
+                    y1, y2 = self.main_layer.get_y_indices(wci_index)
+                    if y1 is not None and len(y1) > 0:
+                        image[image_index, y1] = wci[y2]
 
+        # Build layer images (requires per-column iteration)
         layer_images = {}
         for key in self.layers.keys():
-            layer_images[key] = image.copy()
+            layer_images[key] = np.full((nx, ny), np.nan, dtype=np.float32)
 
-        image_indices, wci_indices = self.get_x_indices()
-        image_indices = get_progress_iterator(image_indices, progress, desc="Building echogram image")
+        if len(self.layers) > 0:
+            image_indices, wci_indices = self.get_x_indices()
+            image_indices = get_progress_iterator(image_indices, progress, desc="Building layer images")
 
-        for image_index, wci_index in zip(image_indices, wci_indices):
-            wci = self.get_column(wci_index)
-            if len(wci) > 1:
-                if self.main_layer is None:
-                    y1, y2 = self.get_y_indices(wci_index)
-                    if len(y1) > 0:
-                        image[image_index, y1] = wci[y2]
-                else:
-                    y1, y2 = self.main_layer.get_y_indices(wci_index)
-                    if y1 is not None and len(y1) > 0:
-                        image[image_index, y1] = wci[y2]
-
-                for key, layer in self.layers.items():
-                    y1_layer, y2_layer = layer.get_y_indices(wci_index)
-                    if y1_layer is not None and len(y1_layer) > 0:
-                        layer_images[key][image_index, y1_layer] = wci[y2_layer]
+            for image_index, wci_index in zip(image_indices, wci_indices):
+                wci = self.get_column(wci_index)
+                if len(wci) > 1:
+                    for key, layer in self.layers.items():
+                        y1_layer, y2_layer = layer.get_y_indices(wci_index)
+                        if y1_layer is not None and len(y1_layer) > 0:
+                            layer_images[key][image_index, y1_layer] = wci[y2_layer]
 
         extent = deepcopy(cs.x_extent)
         extent.extend(cs.y_extent)
@@ -679,13 +695,18 @@ def get_raw_data_at_coordinates(self, x_coord, y_start, y_end):
 
         ping_idx = ping_indices[0]
 
-        # Convert y coordinates to sample indices
-        interpolator = cs.y_coordinate_indice_interpolator[ping_idx]
-        if interpolator is None:
+        # Convert y coordinates to sample indices using affine transform
+        if cs._affine_y_to_sample is None:
+            return None
+        
+        a_inv, b_inv = cs._affine_y_to_sample
+        a, b = a_inv[ping_idx], b_inv[ping_idx]
+        
+        if not np.isfinite(a) or not np.isfinite(b):
             return None
 
-        sample_start = int(interpolator(y_start) + 0.5)
-        sample_end = int(interpolator(y_end) + 0.5)
+        sample_start = int(a + b * y_start + 0.5)
+        sample_end = int(a + b * y_end + 0.5)
 
         # Get raw data
         raw_column = self._backend.get_raw_column(ping_idx)

python/themachinethatgoesping/pingprocessing/watercolumn/echograms/layers/echolayer.py

@@ -89,13 +89,16 @@ def __init__(self, echodata: "EchogramBuilder", vec_x_val, vec_min_y, vec_max_y)
         # Get n_pings from backend or pings list
         n_pings = self._get_n_pings()
 
-        # Create layer indices (i1 = last element + 1)
-        i0 = np.empty(n_pings, dtype=int)
-        i1 = np.empty(n_pings, dtype=int)
-        for nr, interpolator in enumerate(cs.y_coordinate_indice_interpolator):
-            if interpolator is not None:
-                i0[nr] = int(interpolator(vec_min_y[nr]) + 0.5)
-                i1[nr] = int(interpolator(vec_max_y[nr]) + 1.5)
+        # Create layer indices using affine transforms (vectorized)
+        # sample_index = a_inv + b_inv * y_coord (inverse of y = a + b * sample)
+        if cs._affine_y_to_sample is not None:
+            a_inv, b_inv = cs._affine_y_to_sample
+            i0 = np.round(a_inv + b_inv * vec_min_y).astype(int)
+            i1 = np.round(a_inv + b_inv * vec_max_y).astype(int) + 1
+        else:
+            # Fallback if affine not set
+            i0 = np.zeros(n_pings, dtype=int)
+            i1 = np.zeros(n_pings, dtype=int)
 
         self.set_indices(i0, i1, vec_min_y, vec_max_y)
 
@@ -223,6 +226,8 @@ def from_ping_param_offsets_relative(
     def get_y_indices(self, wci_nr: int) -> Tuple[Optional[np.ndarray], Optional[np.ndarray]]:
         """Get Y indices constrained to layer bounds.
         
+        Uses precomputed affine coefficients for speed.
+        
         Args:
             wci_nr: Ping/column number.
         
@@ -232,12 +237,18 @@ def get_y_indices(self, wci_nr: int) -> Tuple[Optional[np.ndarray], Optional[np.
         cs = self._cs
         n_samples = self._get_max_samples(wci_nr)
 
-        interpolator = cs.y_coordinate_indice_interpolator[wci_nr]
-        if interpolator is None:
+        # Use affine transform: sample_index = a + b * y_coord
+        if cs._affine_y_to_sample is None:
+            return None, None
+        
+        a_inv, b_inv = cs._affine_y_to_sample
+        a, b = a_inv[wci_nr], b_inv[wci_nr]
+        
+        if not np.isfinite(a) or not np.isfinite(b):
             return None, None
 
         y_indices_image = np.arange(len(cs.y_coordinates))
-        y_indices_wci = np.round(interpolator(cs.y_coordinates)).astype(int)
+        y_indices_wci = np.round(a + b * cs.y_coordinates).astype(int)
 
         start_y = max(0, self.i0[wci_nr])
         end_y = min(n_samples, self.i1[wci_nr])

python/themachinethatgoesping/pingprocessing/widgets/echogramviewer_pyqtgraph.py

@@ -267,7 +267,7 @@ def show_background_echogram(self) -> None:
             self.layer_images, self.layer_extents = [], []
             for idx, echogram in enumerate(self.echogramdata):
                 self.progress.set_description(f"Updating echogram [{idx},{self.nechograms}]")
-                if not echogram.layers and echogram.main_layer is None:
+                if len(echogram.layers) == 0 and echogram.main_layer is None:
                     image, extent = echogram.build_image(progress=self.progress)
                     self.images_background.append(image)
                     self.extents_background.append(extent)
@@ -303,7 +303,7 @@ def show_background_zoom(self, _event: Any = None) -> None:
                 xmin, xmax = view.viewRange()[0]
                 ymin, ymax = view.viewRange()[1]
                 self._apply_axis_limits(echogram, xmin, xmax, ymin, ymax)
-                if not echogram.layers and echogram.main_layer is None:
+                if len(echogram.layers) == 0 and echogram.main_layer is None:
                     image, extent = echogram.build_image(progress=self.progress)
                     self.high_res_images[idx] = image
                     self.high_res_extents[idx] = extent
@@ -419,7 +419,8 @@ def _update_plot_image(self, idx: int, key: str, data: np.ndarray, extent: Tuple
             y0, y1 = y1, y0
         rect = QtCore.QRectF(x0, y0, x1 - x0, y1 - y0)
         image_item.setRect(rect)
-        colormap = self._colormap_layer if key != "background" else self._colormap
+        # "background" and "high" use main colormap, "layer" uses layer colormap
+        colormap = self._colormap_layer if key == "layer" else self._colormap
         if hasattr(image_item, "setColorMap"):
             image_item.setColorMap(colormap)
         else:  # pragma: no cover - compatibility with older pyqtgraph