fix

Author: timtreis

src/spatialdata_plot/pl/render.py

@@ -204,7 +204,10 @@ def _render_shapes(
 
         # Handle circles encoded as points with radius
         if is_point.any():
-            scale = shapes[is_point]["radius"] * render_params.scale
+            radius_values = shapes[is_point]["radius"]
+            # Convert to numeric, replacing non-numeric values with NaN
+            radius_numeric = pd.to_numeric(radius_values, errors='coerce')
+            scale = radius_numeric * render_params.scale
             shapes.loc[is_point, "geometry"] = _geometry[is_point].buffer(scale.to_numpy())
 
         # apply transformations to the individual points
@@ -227,6 +230,20 @@ def _render_shapes(
 
         # in case we are coloring by a column in table
         if col_for_color is not None and col_for_color not in transformed_element.columns:
+            # Ensure color vector length matches the number of shapes
+            if len(color_vector) != len(transformed_element):
+                if len(color_vector) == 1:
+                    # If single color, broadcast to all shapes
+                    color_vector = [color_vector[0]] * len(transformed_element)
+                else:
+                    # If lengths don't match, pad or truncate to match
+                    if len(color_vector) > len(transformed_element):
+                        color_vector = color_vector[:len(transformed_element)]
+                    else:
+                        # Pad with the last color or na_color
+                        na_color = render_params.cmap_params.na_color.get_hex_with_alpha()
+                        color_vector = list(color_vector) + [na_color] * (len(transformed_element) - len(color_vector))
+            
             transformed_element[col_for_color] = color_vector if color_source_vector is None else color_source_vector
         # Render shapes with datashader
         color_by_categorical = col_for_color is not None and color_source_vector is not None

src/spatialdata_plot/pl/utils.py

@@ -93,6 +93,50 @@
 ColorLike = tuple[float, ...] | list[float] | str
 
 
+def _extract_scalar_value(value: Any, default: float = 0.0) -> float:
+    """
+    Extract a scalar float value from various data types.
+    
+    Handles pandas Series, arrays, lists, and other iterables by taking the first element.
+    Converts non-numeric values to the default value.
+    
+    Parameters
+    ----------
+    value : Any
+        The value to extract a scalar from
+    default : float, default 0.0
+        Default value to return if conversion fails
+        
+    Returns
+    -------
+    float
+        The extracted scalar value
+    """
+    try:
+        # Handle pandas Series or similar objects with iloc
+        if hasattr(value, 'iloc'):
+            if len(value) > 0:
+                value = value.iloc[0]
+            else:
+                return default
+        
+        # Handle other array-like objects
+        elif hasattr(value, '__len__') and not isinstance(value, (str, bytes)):
+            if len(value) > 0:
+                value = value[0]
+            else:
+                return default
+        
+        # Convert to float, handling NaN values
+        if pd.isna(value):
+            return default
+        
+        return float(value)
+        
+    except (TypeError, ValueError, IndexError):
+        return default
+
+
 def _verify_plotting_tree(sdata: SpatialData) -> SpatialData:
     """Verify that the plotting tree exists, and if not, create it."""
     if not hasattr(sdata, "plotting_tree"):
@@ -285,9 +329,10 @@ def _get_centroid_of_pathpatch(pathpatch: mpatches.PathPatch) -> tuple[float, fl
 
 
 def _scale_pathpatch_around_centroid(pathpatch: mpatches.PathPatch, scale_factor: float) -> None:
+    scale_value = _extract_scalar_value(scale_factor, default=1.0)
     centroid = _get_centroid_of_pathpatch(pathpatch)
     vertices = pathpatch.get_path().vertices
-    scaled_vertices = np.array([centroid + (vertex - centroid) * scale_factor for vertex in vertices])
+    scaled_vertices = np.array([centroid + (vertex - centroid) * scale_value for vertex in vertices])
     pathpatch.get_path().vertices = scaled_vertices
 
 
@@ -421,7 +466,8 @@ def _assign_fill_and_outline_to_row(
     def _process_polygon(row: pd.Series, scale: float) -> dict[str, Any]:
         coords = np.array(row["geometry"].exterior.coords)
         centroid = np.mean(coords, axis=0)
-        scaled = (centroid + (coords - centroid) * scale).tolist()
+        scale_value = _extract_scalar_value(scale, default=1.0)
+        scaled = (centroid + (coords - centroid) * scale_value).tolist()
         return {**row.to_dict(), "geometry": mpatches.Polygon(scaled, closed=True)}
 
     def _process_multipolygon(row: pd.Series, scale: float) -> list[dict[str, Any]]:
@@ -432,9 +478,13 @@ def _process_multipolygon(row: pd.Series, scale: float) -> list[dict[str, Any]]:
         return [{**row_dict, "geometry": m} for m in mp]
 
     def _process_point(row: pd.Series, scale: float) -> dict[str, Any]:
+        radius_value = _extract_scalar_value(row["radius"], default=0.0)
+        scale_value = _extract_scalar_value(scale, default=1.0)
+        radius = radius_value * scale_value
+        
         return {
             **row.to_dict(),
-            "geometry": mpatches.Circle((row["geometry"].x, row["geometry"].y), radius=row["radius"] * scale),
+            "geometry": mpatches.Circle((row["geometry"].x, row["geometry"].y), radius=radius),
         }
 
     def _create_patches(