Fix coordinate handling in XYImageItem: resolve multiple bugs related to bin edges vs pixel centers, update documentation, and improve method accuracy

Author: PierreRaybaut

CHANGELOG.md

@@ -63,7 +63,16 @@
 
 🛠️ Bug fixes:
 
-* [Issue #49](https://github.com/PlotPyStack/PlotPy/issues/49) - Using cross-section tools on `XYImageItem` images alters the X/Y coordinate arrays
+* [Issue #49](https://github.com/PlotPyStack/PlotPy/issues/49) - Fixed multiple coordinate handling bugs in `XYImageItem`:
+  * **Root cause**: `XYImageItem` internally stores bin edges (length n+1) but several methods were incorrectly treating them as pixel centers (length n)
+  * Fixed `get_x_values()` and `get_y_values()` to correctly compute and return pixel centers from stored bin edges: `(edge[i] + edge[i+1]) / 2`
+  * Fixed `get_pixel_coordinates()` to correctly convert plot coordinates to pixel indices using `searchsorted()` with proper edge-to-index adjustment
+  * Fixed `get_plot_coordinates()` to return pixel center coordinates instead of bin edge coordinates
+  * Fixed `get_closest_coordinates()` to return pixel center coordinates instead of bin edge coordinates
+  * Added comprehensive docstring documentation explaining that `XYImageItem.x` and `XYImageItem.y` store bin edges, not pixel centers
+  * Removed redundant pixel centering code in `CrossSectionItem.update_curve_data()` that was working around these bugs
+  * This fixes the reported issue where using cross-section tools progressively translated image data to the bottom-right corner
+  * All coordinate-related methods now properly handle the bin edge vs pixel center distinction throughout the `XYImageItem` API
 * Fixed index bounds calculation for image slicing compatibility:
   * Corrected the calculation of maximum indices in `get_plot_coordinates` to ensure proper bounds when using NumPy array slicing
   * Previously, the maximum indices were off by one, which could cause issues when extracting image data using the returned coordinates

plotpy/items/image/standard.py

@@ -34,7 +34,6 @@
 
 if TYPE_CHECKING:
     import guidata.io
-    import qwt.color_map
     import qwt.scale_map
     from qtpy.QtCore import QPointF, QRectF
     from qtpy.QtGui import QColor, QPainter
@@ -510,10 +509,17 @@ class XYImageItem(RawImageItem):
     """XY image item (non-linear axes)
 
     Args:
-        x: 1D NumPy array, must be increasing
-        y: 1D NumPy array, must be increasing
+        x: 1D NumPy array of pixel center coordinates, must be increasing
+        y: 1D NumPy array of pixel center coordinates, must be increasing
         data: 2D NumPy array
         param: image parameters
+
+    Note:
+        Internally, `self.x` and `self.y` store **bin edges** (boundaries between
+        pixels), not pixel centers. If input arrays have length nj and ni (matching
+        data dimensions), they are converted to bin edges of length nj+1 and ni+1
+        using `to_bins()`. Methods that need pixel center coordinates must compute
+        them from the stored bin edges.
     """
 
     __implements__ = (IBasePlotItem, IBaseImageItem, ISerializableType)
@@ -604,12 +610,19 @@ def set_xy(self, x: np.ndarray | list[float], y: np.ndarray | list[float]) -> No
         """Set X and Y data
 
         Args:
-            x: 1D NumPy array, must be increasing
-            y: 1D NumPy array, must be increasing
+            x: 1D NumPy array of pixel center coordinates, must be increasing
+            y: 1D NumPy array of pixel center coordinates, must be increasing
 
         Raises:
             ValueError: If X or Y are not increasing
             IndexError: If X or Y are not of the right length
+
+        Note:
+            Input arrays represent pixel **center** coordinates. Internally, they are
+            stored as bin **edges** in `self.x` and `self.y`:
+            - If input has length nj (or ni), it's converted to edges via `to_bins()`
+            - If input already has length nj+1 (or ni+1), it's used directly as edges
+            - The stored edges have length nj+1 and ni+1 (one more than data dimensions)
         """
         ni, nj = self.data.shape
         x = np.array(x, float)
@@ -677,9 +690,18 @@ def get_pixel_coordinates(self, xplot: float, yplot: float) -> tuple[float, floa
             yplot: Y plot coordinate
 
         Returns:
-            Pixel coordinates
-        """
-        return self.x.searchsorted(xplot), self.y.searchsorted(yplot)
+            Pixel coordinates (integer pixel indices)
+        """
+        # self.x and self.y are bin edges. searchsorted finds the right edge index.
+        # To get the pixel index, we need the left edge index, which is right_edge - 1
+        # But clamp to valid range [0, n-1] where n is number of pixels
+        i = self.x.searchsorted(xplot)
+        j = self.y.searchsorted(yplot)
+        # searchsorted returns the insertion point (right edge index)
+        # Pixel index is insertion_point - 1, but clamped to [0, data.shape-1]
+        i = max(0, min(i - 1, self.data.shape[1] - 1))
+        j = max(0, min(j - 1, self.data.shape[0] - 1))
+        return i, j
 
     def get_plot_coordinates(self, xpixel: float, ypixel: float) -> tuple[float, float]:
         """Get plot coordinates from pixel coordinates
@@ -689,9 +711,17 @@ def get_plot_coordinates(self, xpixel: float, ypixel: float) -> tuple[float, flo
             ypixel: Y pixel coordinate
 
         Returns:
-            Plot coordinates
-        """
-        return self.x[int(pixelround(xpixel))], self.y[int(pixelround(ypixel))]
+            Plot coordinates (pixel center coordinates)
+        """
+        # self.x and self.y store bin edges, compute centers
+        i = int(pixelround(xpixel))
+        j = int(pixelround(ypixel))
+        # Protect against out-of-bounds access
+        i = max(0, min(i, len(self.x) - 2))
+        j = max(0, min(j, len(self.y) - 2))
+        x_center = (self.x[i] + self.x[i + 1]) / 2.0
+        y_center = (self.y[j] + self.y[j + 1]) / 2.0
+        return x_center, y_center
 
     def get_x_values(self, i0: int, i1: int) -> np.ndarray:
         """Get X values from pixel indexes
@@ -701,12 +731,13 @@ def get_x_values(self, i0: int, i1: int) -> np.ndarray:
             i1: Second index
 
         Returns:
-            X values corresponding to the given pixel indexes
+            X values corresponding to the given pixel indexes (pixel centers)
         """
-        # Returning a copy to prevent modification of internal data by caller
+        # self.x stores bin edges (length nj+1), but we need to return pixel centers
+        # Compute centers from edges: center[i] = (edge[i] + edge[i+1]) / 2
         # (Fixes issue #49 - Using cross-section tools on `XYImageItem` images alters
         # the X/Y coordinate arrays)
-        return self.x[i0:i1].copy()
+        return (self.x[i0:i1] + self.x[i0 + 1 : i1 + 1]) / 2.0
 
     def get_y_values(self, j0: int, j1: int) -> np.ndarray:
         """Get Y values from pixel indexes
@@ -716,9 +747,11 @@ def get_y_values(self, j0: int, j1: int) -> np.ndarray:
             j1: Second index
 
         Returns:
-            Y values corresponding to the given pixel indexes
+            Y values corresponding to the given pixel indexes (pixel centers)
         """
-        return self.y[j0:j1].copy()  # (same remark as in `get_x_values`)
+        # self.y stores bin edges (length ni+1), but we need to return pixel centers
+        # Compute centers from edges: center[j] = (edge[j] + edge[j+1]) / 2
+        return (self.y[j0:j1] + self.y[j0 + 1 : j1 + 1]) / 2.0
 
     def get_closest_coordinates(self, x: float, y: float) -> tuple[float, float]:
         """
@@ -729,10 +762,16 @@ def get_closest_coordinates(self, x: float, y: float) -> tuple[float, float]:
             y: Y coordinate
 
         Returns:
-            tuple[float, float]: Closest coordinates
+            tuple[float, float]: Closest pixel center coordinates
         """
         i, j = self.get_closest_indexes(x, y)
-        return self.x[i], self.y[j]
+        # self.x and self.y store bin edges, compute centers
+        # Protect against out-of-bounds access
+        i = max(0, min(i, len(self.x) - 2))
+        j = max(0, min(j, len(self.y) - 2))
+        x_center = (self.x[i] + self.x[i + 1]) / 2.0
+        y_center = (self.y[j] + self.y[j + 1]) / 2.0
+        return x_center, y_center
 
     # ---- IBasePlotItem API ---------------------------------------------------
     def types(self) -> tuple[type[IItemType], ...]:

plotpy/panels/csection/csitem.py

@@ -319,16 +319,14 @@ def setStyle(self, style):
                 self.update_curve_data(obj)
 
     def update_curve_data(self, obj):
-        """
+        """Update curve data from cross section
 
-        :param obj:
+        Args:
+            obj: The object defining the cross section (marker, shape, etc.)
         """
         sectx, secty = self.get_cross_section(obj)
         if secty.size == 0 or np.all(np.isnan(secty)):
             sectx, secty = np.array([]), np.array([])
-        elif self.param.curvestyle != "Steps" and sectx.size > 1:
-            # Center the symbols at the middle of pixels:
-            sectx[:-1] += np.mean(np.diff(sectx) / 2)
         if self.orientation() == QC.Qt.Orientation.Vertical:
             self.process_curve_data(secty, sectx)
         else: