Address review: normalize non-float dtypes, fix edge cases

- Normalize uint8/uint16 RGB(A) images to [0, 1] before passing to imshow
- Add length check to _is_rgb_image to prevent false positives with
  duplicate channel names
- Remove .squeeze() calls that could drop spatial dimensions
- Add tests for uint8, uint16, and duplicate channel name edge cases

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: timtreis

src/spatialdata_plot/pl/render.py

@@ -1034,9 +1034,9 @@ def _is_rgb_image(channel_coords: list[Any]) -> tuple[bool, bool]:
         (is_rgb, has_alpha) — whether the image is RGB and whether it includes an alpha channel.
     """
     names = {str(c).lower() for c in channel_coords}
-    if names == {"r", "g", "b", "a"}:
+    if names == {"r", "g", "b", "a"} and len(channel_coords) == 4:
         return True, True
-    if names == {"r", "g", "b"}:
+    if names == {"r", "g", "b"} and len(channel_coords) == 3:
         return True, False
     return False, False
 
@@ -1114,12 +1114,26 @@ def _render_images(
     if is_rgb and palette is None and not got_multiple_cmaps and not has_explicit_cmap:
         coord_map = {str(c).lower(): c for c in channels}
         ordered = [coord_map[ch] for ch in ("r", "g", "b")]
-        stacked = np.moveaxis(img.sel(c=ordered).squeeze().values, 0, -1)
+        stacked = np.moveaxis(img.sel(c=ordered).values, 0, -1)
+
+        # Normalize to [0, 1] for matplotlib: uint8 → /255, other int dtypes → /max, float → clip
+        if stacked.dtype == np.uint8:
+            stacked = stacked.astype(np.float64) / 255.0
+        elif stacked.dtype.kind in ("u", "i"):
+            stacked = stacked.astype(np.float64) / np.iinfo(stacked.dtype).max
+        else:
+            stacked = np.clip(stacked, 0, 1)
 
         show_kwargs: dict[str, Any] = {"zorder": render_params.zorder}
 
         if has_alpha and render_params.alpha == 1.0:
-            alpha_layer = np.clip(img.sel(c=coord_map["a"]).squeeze().values, 0, 1)
+            alpha_raw = img.sel(c=coord_map["a"]).values
+            if alpha_raw.dtype == np.uint8:
+                alpha_layer = alpha_raw.astype(np.float64) / 255.0
+            elif alpha_raw.dtype.kind in ("u", "i"):
+                alpha_layer = alpha_raw.astype(np.float64) / np.iinfo(alpha_raw.dtype).max
+            else:
+                alpha_layer = np.clip(alpha_raw.astype(np.float64), 0, 1)
             stacked = np.concatenate([stacked, alpha_layer[..., np.newaxis]], axis=-1)
         else:
             show_kwargs["alpha"] = render_params.alpha

tests/pl/test_render_images.py

@@ -181,6 +181,9 @@ def test_partial_rgb_not_detected(self):
     def test_rgb_with_extra_channel_not_detected(self):
         assert _is_rgb_image(["r", "g", "b", "x"]) == (False, False)
 
+    def test_duplicate_channel_names_not_detected(self):
+        assert _is_rgb_image(["r", "g", "b", "b"]) == (False, False)
+
 
 class TestRGBARendering:
     """Regression tests for #406: RGBA images rendered correctly."""
@@ -242,3 +245,28 @@ def test_explicit_alpha_overrides_per_pixel(self):
         fig, ax = plt.subplots()
         sdata.pl.render_images("img", alpha=0.3).pl.show(ax=ax)
         plt.close("all")
+
+    def test_uint8_rgb_renders(self):
+        """uint8 RGB image should be normalized to [0, 1] and render correctly."""
+        data = np.zeros((3, 50, 50), dtype=np.uint8)
+        data[0] = 200
+        data[1] = 100
+        data[2] = 50
+        img = Image2DModel.parse(data, dims=("c", "y", "x"), c_coords=["r", "g", "b"])
+        sdata = SpatialData(images={"img": img})
+        fig, ax = plt.subplots()
+        sdata.pl.render_images("img").pl.show(ax=ax)
+        plt.close("all")
+
+    def test_uint16_rgba_renders(self):
+        """uint16 RGBA image should be normalized and render correctly."""
+        data = np.zeros((4, 50, 50), dtype=np.uint16)
+        data[0] = 50000
+        data[1] = 30000
+        data[2] = 10000
+        data[3] = 65535  # fully opaque
+        img = Image2DModel.parse(data, dims=("c", "y", "x"), c_coords=["r", "g", "b", "a"])
+        sdata = SpatialData(images={"img": img})
+        fig, ax = plt.subplots()
+        sdata.pl.render_images("img").pl.show(ax=ax)
+        plt.close("all")