babelplot 2025.11__tar.gz → 2025.13__tar.gz

{babelplot-2025.11 → babelplot-2025.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: babelplot
-Version: 2025.11
+Version: 2025.13
 Summary: A Meta Plotting Library That Speaks Several Backends
 Home-page: https://src.koda.cnrs.fr/eric.debreuve/babelplot/
 Author: Eric Debreuve

{babelplot-2025.11 → babelplot-2025.13}/package/babelplot/backend/catalog/bokeh_.py

@@ -9,6 +9,7 @@ import gzip
 import typing as h
 from multiprocessing import Process as process_t
 
+import numpy as nmpy
 from babelplot.task.plotting import NewPlotFunctionsTemplate, SetDefaultPlotFunction
 from babelplot.task.showing import ShowHTMLPlotWithPyQt
 from babelplot.type.dimension import dim_e
@@ -16,7 +17,7 @@ from babelplot.type.figure import figure_t as base_figure_t
 from babelplot.type.frame import frame_t as base_frame_t
 from babelplot.type.plot import plot_t as base_plot_t
 from babelplot.type.plot_function import plot_function_h
-from babelplot.type.plot_type import plot_e
+from babelplot.type.plot_type import plot_e, plot_type_h
 from bokeh.embed import file_html as HTMLofBackendContent  # noqa
 from bokeh.layouts import column as NewBackendColLayout  # noqa
 from bokeh.layouts import grid as NewBackendGridLayout  # noqa
@@ -27,6 +28,8 @@ from bokeh.resources import INLINE  # noqa
 
 NAME = "bokeh"
 
+array_t = nmpy.ndarray
+
 
 class backend_figure_t: ...
 
@@ -43,6 +46,7 @@ class frame_t(base_frame_t):
         plot_function: plot_function_h,
         *args,
         title: str | None = None,  # If _, then it is swallowed by kwargs!
+        type_: tuple[plot_type_h | plot_function_h, int],
         **kwargs,
     ) -> plot_t:
         """"""
@@ -59,9 +63,9 @@ class figure_t(base_figure_t):
 
     layout: h.Any = d.field(init=False, default=None)
 
-    def _NewBackendFigure(self, *args, **kwargs) -> backend_figure_t:
+    def _NewBackendFigure(self, *args, **kwargs) -> None:
         """"""
-        return backend_figure_t()  # self.raw is never used.
+        return None
 
     def _NewFrame(
         self,
@@ -85,7 +89,7 @@ class figure_t(base_figure_t):
         # arranged_frames must be composed of list since Bokeh does not support tuples
         # here!
         n_rows, n_cols = self.shape
-        arranged_frames = [n_cols * [None] for _ in range(n_rows)]
+        arranged_frames: list[list[h.Any]] = [n_cols * [None] for _ in range(n_rows)]
         for frame, (row, col) in zip(self.frames, self.locations):
             raw = frame.raw
             if raw.renderers.__len__() == 0:
@@ -153,18 +157,15 @@ def _DefaultFunction(type_: plot_e, frame_dim: int, /) -> plot_function_h:
     """"""
 
     def Actual(frame: backend_frame_t, *args, **kwargs) -> backend_plot_t:
-        """"""
-        args = ", ".join(map(lambda _: type(_).__name__, args))
-        kwargs = ", ".join(
-            f"{_key}={type(_vle).__name__}" for _key, _vle in kwargs.items()
-        )
-
+        #
         return backend_frame_t.text(
             frame,
             x=(0,),
             y=(0,),
             text=(
-                f"Unhandled Plot Request\n{type_.name}.{frame_dim}\nargs: {args}\nkwargs: {kwargs}",
+                plot_t.UnhandledRequestMessage(
+                    type_, *args, frame_dim=frame_dim, **kwargs
+                ),
             ),
             text_font_size="30px",
             text_align="center",
@@ -174,16 +175,71 @@ def _DefaultFunction(type_: plot_e, frame_dim: int, /) -> plot_function_h:
     return Actual
 
 
+def _BarH(frame: backend_frame_t, *args, **kwargs) -> backend_plot_t:
+    """"""
+    if args.__len__() == 1:
+        counts = args[0]
+        positions = tuple(range(counts.__len__()))
+    else:
+        positions, counts = args
+
+    return frame.hbar(y=positions, right=counts, **kwargs)
+
+
+def _BarV(frame: backend_frame_t, *args, **kwargs) -> backend_plot_t:
+    """"""
+    if args.__len__() == 1:
+        counts = args[0]
+        positions = tuple(range(counts.__len__()))
+    else:
+        positions, counts = args
+
+    return frame.vbar(x=positions, top=counts, **kwargs)
+
+
+def _Image(frame: backend_frame_t, image: array_t, *args, **kwargs) -> backend_plot_t:
+    """"""
+    if nmpy.issubdtype(image.dtype, nmpy.floating):
+        image = nmpy.round(255.0 * (image / image.max())).astype(nmpy.uint8)
+
+    for_bokeh = nmpy.empty(image.shape[:2], dtype=nmpy.uint32)
+    view = for_bokeh.view(dtype=nmpy.uint8).reshape(image.shape[:2] + (4,))
+
+    if (image.ndim == 2) or (image.shape[2] != 4):
+        if (image.ndim == 2) or (image.shape[2] == 1):
+            planes = (image, image, image)
+        else:
+            planes = (image[..., 0], image[..., 1], image[..., 2])
+        for d_idx in range(3):
+            view[..., d_idx] = planes[d_idx]
+        view[..., 3] = nmpy.full_like(image, 255)
+    else:
+        view[...] = image[...]
+
+    frame.x_range.range_padding = frame.y_range.range_padding = 0
+
+    return frame.image_rgba(
+        image=(for_bokeh,), x=0, y=0, dw=image.shape[1], dh=image.shape[0]
+    )
+
+
 PLOTS = NewPlotFunctionsTemplate()
+PLOTS[plot_e.BARH][0] = _BarH
+PLOTS[plot_e.BARV][0] = _BarV
+PLOTS[plot_e.IMAGE][0] = _Image
 PLOTS[plot_e.SCATTER][0] = backend_frame_t.scatter
 SetDefaultPlotFunction(PLOTS, _DefaultFunction)
 
 
 TRANSLATIONS = {
-    "color_face": "fill_color",
-    "opacity": "alpha",
-    ("AddFrame", "azimuth"): None,
-    ("AddFrame", "elevation"): None,
+    None: {
+        "color_face": "fill_color",
+        "opacity": "alpha",
+    },
+    "_NewFrame": {
+        "azimuth": None,
+        "elevation": None,
+    },
 }
 
 

{babelplot-2025.11 → babelplot-2025.13}/package/babelplot/backend/catalog/matplotlib_.py

@@ -10,7 +10,7 @@ import typing as h
 import matplotlib.pyplot as pypl  # noqa
 import numpy as nmpy
 import skimage.measure as msre
-from babelplot.task.color import NewConvertedColor
+from color_spec_changer.translation import NewTranslatedColor
 from babelplot.task.plotting import NewPlotFunctionsTemplate
 from babelplot.type.dimension import dim_e
 from babelplot.type.ffp_base import backend_element_h
@@ -108,6 +108,7 @@ class frame_t(base_frame_t):
         plot_function: plot_function_h,
         *args,
         title: str | None = None,  # /!\ If _, then it is swallowed by kwargs!
+        type_: tuple[plot_type_h | plot_function_h, int],
         **kwargs,
     ) -> plot_t:
         """"""
@@ -271,7 +272,7 @@ def _Arrows3(frame: backend_frame_3d_t, *args, **kwargs) -> backend_plot_t:
     return frame.quiver(x, y, z, u, v, w, **kwargs)
 
 
-def _Bar3(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plot_t:
+def _Bar3(frame: backend_frame_3d_t, *args, **kwargs) -> backend_plot_t:
     """"""
     if args.__len__() == 1:
         counts = nmpy.asarray(args[0])
@@ -319,7 +320,7 @@ def _BarV(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plots_t:
     return frame.bar(positions, counts, **kwargs)
 
 
-def _ElevationSurface(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plot_t:
+def _ElevationSurface(frame: backend_frame_3d_t, *args, **kwargs) -> backend_plot_t:
     """"""
     if args.__len__() == 1:
         elevation = args[0]
@@ -347,7 +348,7 @@ def _IsoContour(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plot_t:
     return output
 
 
-def _IsoSurface(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plot_t:
+def _IsoSurface(frame: backend_frame_3d_t, *args, **kwargs) -> backend_plot_t:
     """"""
     if "step_size" in kwargs:
         mc_kwargs = {"step_size": kwargs["step_size"]}
@@ -362,9 +363,13 @@ def _IsoSurface(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plot_t:
 
 
 def _Mesh(
-    frame: backend_frame_2d_t, triangles: array_t, vertices: array_t, *_, **kwargs
+    frame: backend_frame_3d_t, triangles: array_t, vertices: array_t, *_, **kwargs
 ) -> backend_plot_t:
-    """"""
+    """
+    Note: As of 3.9.2, plot_trisurf does not support custom triangle colors yet (see
+    https://github.com/matplotlib/matplotlib/blob/v3.9.2/lib/mpl_toolkits/mplot3d/axes3d.py,
+    line 2291).
+    """
     return frame.plot_trisurf(
         vertices[:, 0], vertices[:, 1], triangles, vertices[:, 2], **kwargs
     )
@@ -413,37 +418,52 @@ PLOTS[plot_e.TEXT][1] = _Text3
 
 
 TRANSLATIONS = {
-    "color": "c",
-    "color_edge": "edgecolors",
-    "color_face": "facecolors",
-    "color_max": "vmax",
-    "color_min": "vmin",
-    "color_scaling": "norm",
-    "colormap": "cmap",
-    "depth_shade": "depthshade",
-    "opacity": "alpha",
-    "plot_non_finite": "plotnonfinite",
-    "size": "s",
-    "width_edge": "linewidths",
-    ("AddFrame", "azimuth"): "azim",
-    ("AddFrame", "elevation"): "elev",
-    (_Arrows2, "color"): "color",
-    (_Arrows3, "color"): "color",
-    (_Bar3, "color"): "color",
-    (_BarH, "color"): "color",
-    (_BarH, "offset"): "left",
-    (_BarV, "color"): "color",
-    (_BarV, "offset"): "bottom",
-    (_ElevationSurface, "color_face"): "color",
-    (_IsoContour, "color"): "colors",
-    (_IsoSurface, "color_face"): "color",
-    (_Mesh, "color_face"): ("color", lambda _: NewConvertedColor(_, "hex", 0)),
-    (_Polygon, "color_edge"): "edgecolor",
-    (_Polygon, "color_face"): "facecolor",
-    (backend_frame_2d_t.pie, "color"): "colors",
-    (backend_frame_2d_t.quiver, "color"): "color",
-    (backend_frame_3d_t.quiver, "color"): "colors",
-    (backend_frame_3d_t.scatter, 2): "zs",
+    None: {
+        "color": "c",
+        "color_edge": "edgecolors",
+        "color_face": "facecolors",
+        "color_max": "vmax",
+        "color_min": "vmin",
+        "color_scaling": "norm",
+        "colormap": "cmap",
+        "depth_shade": "depthshade",
+        "opacity": "alpha",
+        "plot_non_finite": "plotnonfinite",
+        "size": "s",
+        "width_edge": "linewidths",
+    },
+    "_NewFrame": {
+        "azimuth": "azim",
+        "elevation": "elev",
+    },
+    _Arrows2: {"c": "color"},
+    _Arrows3: {"c": "color"},
+    _Bar3: {"c": "color"},
+    _BarH: {
+        "c": "color",
+        "offset": "left",
+    },
+    _BarV: {
+        "c": "color",
+        "offset": "bottom",
+    },
+    _ElevationSurface: {"facecolors": "color"},
+    _IsoContour: {"c": "colors"},
+    _IsoSurface: {"facecolors": "color"},
+    _Mesh: {
+        "facecolors": (
+            "color",
+            lambda _: NewTranslatedColor(_, "hex", index_or_reduction=0)[0],
+        )
+    },
+    _Polygon: {
+        "edgecolors": "edgecolor",
+        "facecolors": "facecolor",
+    },
+    backend_frame_2d_t.pie: {"c": "colors"},
+    backend_frame_2d_t.quiver: {"c": "color"},
+    backend_frame_3d_t.quiver: {"c": "colors"},
+    backend_frame_3d_t.scatter: {2: "zs"},
 }
 
 """

{babelplot-2025.11 → babelplot-2025.13}/package/babelplot/backend/catalog/plotly_.py

@@ -13,6 +13,8 @@ from pathlib import Path as path_t
 import numpy as nmpy
 import plotly.figure_factory as fcry  # noqa
 import plotly.graph_objects as plly  # noqa
+from color_spec_changer.analysis import NColorsAndFormat
+from color_spec_changer.translation import NewTranslatedColor
 from babelplot.task.plotting import NewPlotFunctionsTemplate
 from babelplot.task.showing import ShowHTMLPlotWithPyQt
 from babelplot.type.dimension import dim_e
@@ -20,8 +22,8 @@ from babelplot.type.figure import figure_t as base_figure_t
 from babelplot.type.frame import frame_t as base_frame_t
 from babelplot.type.plot import plot_t as base_plot_t
 from babelplot.type.plot_function import plot_function_h
-from babelplot.type.plot_type import plot_e
-from plotly.basedatatypes import BasePlotlyType as backend_plot_t  # noqa
+from babelplot.type.plot_type import plot_e, plot_type_h
+from plotly.basedatatypes import BaseTraceType as backend_plot_t  # noqa
 from plotly.graph_objects import Figure as backend_figure_t  # noqa
 from plotly.subplots import make_subplots as NewMultiAxesFigure  # noqa
 
@@ -53,6 +55,7 @@ class frame_t(base_frame_t):
         plot_function: plot_function_h,
         *args,
         title: str | None = None,  # If _, then it is swallowed by kwargs!
+        type_: tuple[plot_type_h | plot_function_h, int],
         **kwargs,
     ) -> plot_t:
         """"""
@@ -94,7 +97,9 @@ class figure_t(base_figure_t):
         n_rows, n_cols = self.shape
         if (n_rows > 1) or (n_cols > 1):
             frame_titles = (n_rows * n_cols) * [""]
-            arranged_plots = [n_cols * [None] for _ in range(n_rows)]
+            arranged_plots: list[list[list[backend_plot_t] | None]] = [
+                n_cols * [None] for _ in range(n_rows)
+            ]
             for frame, (row, col) in zip(self.frames, self.locations):
                 if frame.title is not None:
                     frame_titles[row * n_cols + col] = frame.title
@@ -106,6 +111,7 @@ class figure_t(base_figure_t):
             frame_types = [n_cols * [{}] for _ in range(n_rows)]
             for row, plot_row in enumerate(arranged_plots):
                 for col, plot_cell in enumerate(plot_row):
+                    # Note: Subclasses of backend_plot_t have a type property.
                     frame_types[row][col] = {"type": plot_cell[0].type}
 
             raw = NewMultiAxesFigure(
@@ -334,7 +340,7 @@ def _Image(image: array_t, *_, **kwargs) -> backend_plot_t:
 
 def _IsoContour(*args, **kwargs) -> backend_plot_t:
     """"""
-    parameters = {
+    parameters: dict[str, h.Any] = {
         "contours_coloring": "lines",
         "line_width": 2,
     }
@@ -388,7 +394,10 @@ def _IsoSurface(values: array_t, value: float, *args, **kwargs) -> backend_plot_
 
 
 def _Mesh(triangles: array_t, vertices: array_t, *_, **kwargs) -> backend_plot_t:
-    """"""
+    """
+    Note: Mesh3d does not support setting edge colors. It can be done indirectly by
+    adding a Scatter3d plot.
+    """
     return plly.Mesh3d(
         x=vertices[:, 0],
         y=vertices[:, 1],
@@ -491,6 +500,17 @@ def _ApplyGlobalTranslation(
             if (value := kwargs.get(passed)) is not None:
                 marker[wanted] = value
                 del kwargs[passed]
+        if "color" in marker:
+            format_ = NColorsAndFormat(marker["color"])
+            n_colors = format_.n_colors
+            if n_colors > 1:
+                translated, _ = NewTranslatedColor(marker["color"], "function_rgb255")
+                colorscale = [
+                    [_idx / (n_colors - 1), _clr]
+                    for _idx, _clr in enumerate(translated)
+                ]
+                marker["colorscale"] = colorscale
+                marker["color"] = tuple(_[0] for _ in colorscale)
         if who_s_asking is _Scatter3:
             # /!\\ Passing one size per sample makes all of them disappear.
             if ("size" in marker) and not isinstance(marker["size"], int | float):
@@ -501,11 +521,11 @@ def _ApplyGlobalTranslation(
 
         kwargs["marker"] = marker
         #
-    elif who_s_asking in (_Arrows2, _Polyline2, _Polyline3):
+    elif who_s_asking in (_Arrows2, _Polygon, _Polyline2, _Polyline3):
         line = {}
         for passed, wanted in zip(
-            ("color", "opacity", "line_width", "line_style"),
-            ("color", "opacity", "width", "symbol"),
+            ("color", "color_edge", "opacity", "line_width", "line_style"),
+            ("color", "color", "opacity", "width", "symbol"),
         ):
             if (value := kwargs.get(passed)) is not None:
                 line[wanted] = value
@@ -524,25 +544,24 @@ def _ApplyGlobalTranslation(
 
 
 TRANSLATIONS = {
-    "color_face": "surfacecolor",
-    (_Arrows3, "color"): None,
-    (_BarH, "color"): None,
-    (_BarV, "color"): None,
-    (_ElevationSurface, "color_edge"): None,
-    (_ElevationSurface, "color_face"): None,
-    (_ElevationSurface, "width_edge"): None,
-    (_Image, "colormap"): None,
-    (_IsoContour, "color"): "fillcolor",
-    (_IsoSurface, "color_edge"): None,
-    (_IsoSurface, "color_face"): None,
-    (_IsoSurface, "step_size"): None,
-    (_IsoSurface, "width_edge"): None,
-    (_Mesh, "color_edge"): None,
-    (_Mesh, "color_face"): "facecolor",
-    (_Mesh, "width_edge"): None,
-    (_Polygon, "color_edge"): None,
-    (_Polygon, "color_face"): "fillcolor",
-    None: _ApplyGlobalTranslation,
+    None: {
+        "color_face": "surfacecolor",
+        None: _ApplyGlobalTranslation,
+    },
+    _Arrows3: {"color": None},
+    _BarH: {"color": None},
+    _BarV: {"color": None},
+    _ElevationSurface: {"color_edge": None, "surfacecolor": None, "width_edge": None},
+    _Image: {"colormap": None},
+    _IsoContour: {"color": "fillcolor"},
+    _IsoSurface: {
+        "color_edge": None,
+        "surfacecolor": None,
+        "step_size": None,
+        "width_edge": None,
+    },
+    _Mesh: {"color_edge": None, "surfacecolor": "facecolor", "width_edge": None},
+    _Polygon: {"surfacecolor": "fillcolor"},
 }
 
 

{babelplot-2025.11 → babelplot-2025.13}/package/babelplot/backend/catalog/vedo_.py

@@ -5,23 +5,30 @@ SEE COPYRIGHT NOTICE BELOW
 """
 
 import dataclasses as d
+import typing as h
 from multiprocessing import Process as process_t
 
-from babelplot.task.color import NewConvertedColor
-from babelplot.task.plotting import NewPlotFunctionsTemplate
+from color_spec_changer.translation import NewTranslatedColor
+from babelplot.task.plotting import NewPlotFunctionsTemplate, SetDefaultPlotFunction
 from babelplot.type.dimension import dim_e
 from babelplot.type.figure import figure_t as base_figure_t
 from babelplot.type.frame import frame_t as base_frame_t
 from babelplot.type.plot import plot_t as base_plot_t
 from babelplot.type.plot_function import plot_function_h
-from babelplot.type.plot_type import plot_e
+from babelplot.type.plot_type import plot_e, plot_type_h
 from numpy import ndarray as array_t
-from vedo import Mesh as backend_plot_t  # noqa
-from vedo import Plotter as backend_figure_t  # noqa
+from vedo import Mesh as backend_mesh_t  # noqa
+from vedo import Text2D as text_2d_t  # noqa
 from vedo import Volume as volume_t  # noqa
+from vedo import show as BackendShow  # noqa
+from vedo.pyplot import plot as NewBackendPlot  # noqa
 
 NAME = "vedo"
 
+_MIN_HEIGHT_RATIO = 0.4
+
+backend_plot_h = h.TypeVar("backend_plot_h")
+
 
 @d.dataclass(slots=True, repr=False, eq=False)
 class plot_t(base_plot_t): ...
@@ -30,33 +37,47 @@ class plot_t(base_plot_t): ...
 @d.dataclass(slots=True, repr=False, eq=False)
 class frame_t(base_frame_t):
 
+    @property
+    def backend_plots(self) -> list[backend_plot_h]:
+        """"""
+        output = []
+
+        for plot in self.plots:
+            if plot.title is None:
+                output.append(plot.raw)
+            else:
+                output.append((plot.raw, plot.title))
+
+        return output
+
     def _NewPlot(
         self,
         plot_function: plot_function_h,
         *args,
         title: str | None = None,  # If _, then it is swallowed by kwargs!
+        type_: tuple[plot_type_h | plot_function_h, int],
         **kwargs,
     ) -> plot_t:
         """"""
-        output = plot_t(
+        return plot_t(
             title=title,
             property=kwargs.copy(),
             backend_name=self.backend_name,
             raw=plot_function(*args, **kwargs),
         )
 
-        if output.raw is not None:
-            self.raw.__iadd__(output.raw)
-
-        return output
-
 
 @d.dataclass(slots=True, repr=False, eq=False)
 class figure_t(base_figure_t):
 
-    def _NewBackendFigure(self, *args, **kwargs) -> backend_figure_t:
+    @property
+    def backend_plots_s(self) -> list[list[backend_plot_h]]:
+        """"""
+        return [_.backend_plots for _ in self.frames]
+
+    def _NewBackendFigure(self, *args, **kwargs) -> None:
         """"""
-        return backend_figure_t(*args, **kwargs)
+        return None
 
     def _NewFrame(
         self,
@@ -68,22 +89,20 @@ class figure_t(base_figure_t):
         **kwargs,
     ) -> frame_t:
         """"""
-        output = frame_t(
+        return frame_t(
             title=title,
             dim=dim,
             backend_name=self.backend_name,
         )
 
-        output.raw = self.raw
-
-        return output
-
     def _BackendShow(self, modal: bool, /) -> None:
         """"""
-        # Passing self.raw.show().close shows the figures one by one.
-        BackendShow = lambda: self.raw.show().close()
+        _ShowAndClose = lambda: BackendShow(
+            self.backend_plots_s, shape=self.shape, sharecam=False
+        ).close()
 
-        process = process_t(target=BackendShow)
+        # Passing [...].close shows the figures one by one. Using _ShowAndClose instead.
+        process = process_t(target=_ShowAndClose)
         process.start()
 
         if modal:
@@ -92,14 +111,62 @@ class figure_t(base_figure_t):
             self.showing_process = process
 
 
-def _IsoSurface(volume: array_t, iso_value: float, *_, **kwargs) -> backend_plot_t:
+def _DefaultFunction(type_: plot_e, frame_dim: int, /) -> plot_function_h:
+    """"""
+
+    def Actual(*args, **kwargs) -> backend_plot_h:
+        #
+        return text_2d_t(
+            plot_t.UnhandledRequestMessage(type_, *args, frame_dim=frame_dim, **kwargs),
+            pos="middle-left",
+            s=1.0,
+            bold=True,
+            c="red",
+        )
+
+    return Actual
+
+
+def _ElevationSurface(elevation: array_t, *args, **kwargs) -> backend_plot_h:
+    """"""
+    (n_rows, n_cols), min_z, max_z = elevation.shape, elevation.min(), elevation.max()
+    max_length = max(n_rows, n_cols)
+    height = max_z - min_z
+
+    if (height > 0) and (height / max_length < _MIN_HEIGHT_RATIO):
+        scaling = _MIN_HEIGHT_RATIO * max_length / height
+        if scaling.is_integer():
+            scaling = int(scaling)
+            equality = "="
+        else:
+            rounded = round(scaling)
+            rounded_length = str(rounded).__len__()
+            precision = max(3 - rounded_length, 0)
+            if precision > 0:
+                scaling = round(scaling, ndigits=precision)
+            else:
+                scaling = rounded
+            equality = "≈"
+        kwarg_axes = {"axes": {"ztitle": f"Scaling{equality}{scaling}"}}
+    else:
+        scaling = 1.0
+        kwarg_axes = {}
+
+    Elevation = lambda _row, _col: scaling * float(elevation[round(_row), round(_col)])
+
+    return NewBackendPlot(
+        Elevation, xlim=(0, n_rows), ylim=(0, n_cols), c="summer", **kwarg_axes
+    )
+
+
+def _IsoSurface(volume: array_t, iso_value: float, *_, **kwargs) -> backend_mesh_t:
     """"""
     return volume_t(volume).isosurface(value=[iso_value], **kwargs)
 
 
-def _Mesh(triangles: array_t, vertices: array_t, *_, **kwargs) -> backend_plot_t:
+def _Mesh(triangles: array_t, vertices: array_t, *_, **kwargs) -> backend_mesh_t:
     """"""
-    output = backend_plot_t((vertices, triangles))
+    output = backend_mesh_t((vertices, triangles))
 
     if "width_edge" in kwargs:
         output.linewidth(kwargs["width_edge"])
@@ -112,16 +179,25 @@ def _Mesh(triangles: array_t, vertices: array_t, *_, **kwargs) -> backend_plot_t
 
 
 PLOTS = NewPlotFunctionsTemplate()
+PLOTS[plot_e.ELEVATION][1] = _ElevationSurface
 PLOTS[plot_e.ISOSET][1] = _IsoSurface
 PLOTS[plot_e.MESH][1] = _Mesh
+SetDefaultPlotFunction(PLOTS, _DefaultFunction)
 
 
 TRANSLATIONS = {
-    (_IsoSurface, "color_edge"): None,
-    (_IsoSurface, "color_face"): None,
-    (_IsoSurface, "step_size"): None,
-    (_IsoSurface, "width_edge"): None,
-    (_Mesh, "color_face"): ("color_face", lambda _: NewConvertedColor(_, "hex", 0)),
+    _IsoSurface: {
+        "color_edge": None,
+        "color_face": None,
+        "step_size": None,
+        "width_edge": None,
+    },
+    _Mesh: {
+        "color_face": (
+            "color_face",
+            lambda _: NewTranslatedColor(_, "hex", index_or_reduction=0)[0],
+        )
+    },
 }
 
 

{babelplot-2025.11 → babelplot-2025.13}/package/babelplot/task/plotting.py

@@ -4,6 +4,7 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2022
 SEE COPYRIGHT NOTICE BELOW
 """
 
+from babelplot.type.plot import plot_t
 from babelplot.type.plot_function import plot_function_h, plot_functions_h
 from babelplot.type.plot_type import plot_e
 from logger_36 import L
@@ -29,11 +30,9 @@ def _FakePlotFunction(type_: plot_e, frame_dim: int, /) -> plot_function_h:
 
     def Actual(*args, **kwargs) -> None:
         #
-        args = ", ".join(map(lambda _: type(_).__name__, args))
-        kwargs = ", ".join(
-            f"{_key}={type(_vle).__name__}" for _key, _vle in kwargs.items()
+        L.warning(
+            plot_t.UnhandledRequestMessage(type_, *args, frame_dim=frame_dim, **kwargs)
         )
-        L.warning(f"Unhandled plot request: {type_.name}.{frame_dim}: {args}, {kwargs}")
 
     return Actual
 

{babelplot-2025.11 → babelplot-2025.13}/package/babelplot/type/backend.py

@@ -63,38 +63,45 @@ class backend_t:
         if (translations is None) or (translations.__len__() == 0):
             return args, kwargs
 
+        if (generics := translations.get(None)) is None:
+            generics = {}
+        if (for_who_s_asking := translations.get(who_s_asking)) is None:
+            for_who_s_asking = {}
+
         out_args = []
         out_kwargs = {}
 
+        from_args_to_args = []
         for idx, value in enumerate(args):
-            if (translation := translations.get((who_s_asking, idx), -1)) == -1:
+            if (translation := for_who_s_asking.get(idx, -1)) == -1:
                 # No translation needed; Keeping the passed arg.
                 out_args.append(value)
             elif translation is None:
                 # The argument should be discarded.
                 pass
-            else:  # isinstance(translation, str | tuple[str, h.Callable])
-                # The passed arg should actually be a kwarg with name "translation".
+            else:  # isinstance(translation, int|str | tuple[int|str, h.Callable])
+                # The passed arg should be placed at the position "translation", or
+                # should actually be a kwarg with name "translation".
                 if isinstance(translation, list | tuple):
                     translation, NewConvertedValue = translation
                     value = NewConvertedValue(value)
-                out_kwargs[translation] = value
+                if isinstance(translation, int):
+                    from_args_to_args.append([translation, value])
+                else:
+                    out_kwargs[translation] = value
+
+        out_args = [[_pos, _vle] for _pos, _vle in enumerate(out_args, start=1)]
+        _InsertArguments(out_args, from_args_to_args)
 
         from_kwargs_to_args = []
         for key, value in kwargs.items():
-            # Search for specific translation (who_s_asking, key) before key alone.
-            if (translation := translations.get((who_s_asking, key), -1)) == -1:
-                if (translation := translations.get(key, -1)) == -1:
-                    # No translation needed; Keeping the passed arg.
-                    out_kwargs[key] = value
-                elif translation is None:
-                    # The argument should be discarded.
-                    pass
-                else:  # isinstance(translation, str | tuple[str, h.Callable])
-                    if isinstance(translation, list | tuple):
-                        translation, NewConvertedValue = translation
-                        value = NewConvertedValue(value)
-                    out_kwargs[translation] = value
+            # Apply generic translation first, if any.
+            key = generics.get(key, key)
+
+            # Search for specific translation.
+            if (translation := for_who_s_asking.get(key, -1)) == -1:
+                # No translation needed; Keeping the passed kwarg.
+                out_kwargs[key] = value
             elif translation is None:
                 # The argument should be discarded.
                 pass
@@ -105,12 +112,12 @@ class backend_t:
                 if isinstance(translation, str):
                     out_kwargs[translation] = value
                 else:  # isinstance(translation, int)
-                    from_kwargs_to_args.append((translation, value))
+                    from_kwargs_to_args.append([translation, value])
 
-        for idx, value in sorted(from_kwargs_to_args, key=ItemAt(0)):
-            out_args.insert(idx, value)
+        _InsertArguments(out_args, from_kwargs_to_args)
+        out_args = tuple(map(ItemAt(1), out_args))
 
-        if (ApplyGlobalTranslation := translations.get(None)) is not None:
+        if (ApplyGlobalTranslation := generics.get(None)) is not None:
             ApplyGlobalTranslation(out_kwargs, who_s_asking)
 
         return out_args, out_kwargs
@@ -120,6 +127,22 @@ class backend_t:
         return self.py_path
 
 
+def _InsertArguments(
+    current: list[list[int | h.Any]], new: list[list[int | h.Any]], /
+) -> None:
+    """
+    Note: list[int | h.Any] should actually be mutable_tuple[int, h.Any].
+    """
+    # Note: It is important to sort from_args_to_args so that a higher-positioned
+    # argument does not get shifted even higher by the insertion of a lower-positioned
+    # argument dealt with later.
+    for position, value in sorted(new, key=ItemAt(0)):
+        for argument in current:
+            if argument[0] >= position:
+                argument[0] += 1
+        current.append([position, value])
+
+
 @d.dataclass(slots=True, repr=False, eq=False)
 class backends_t(dict[str, backend_t]):
 

{babelplot-2025.11 → babelplot-2025.13}/package/babelplot/type/figure.py

@@ -57,7 +57,7 @@ class figure_t(base_t):
 
         return output
 
-    def _NewBackendFigure(self, *args, **kwargs) -> backend_figure_h:
+    def _NewBackendFigure(self, *args, **kwargs) -> backend_figure_h | None:
         """"""
         raise NotImplementedError
 
@@ -86,7 +86,7 @@ class figure_t(base_t):
             col = self.shape[1]
 
         args, kwargs = BACKENDS.TranslatedArguments(
-            self.backend_name, args, kwargs, self.AddFrame.__name__
+            self.backend_name, args, kwargs, self._NewFrame.__name__
         )
         output = self._NewFrame(title, dim, row, col, *args, **kwargs)
 

{babelplot-2025.11 → babelplot-2025.13}/package/babelplot/type/frame.py

@@ -33,6 +33,7 @@ class frame_t(base_t):
         **kwargs,
     ) -> plot_t:
         """"""
+        full_type = (type_, self.frame_dim)
         plot_function = BACKENDS.PlotFunction(self.backend_name, type_, self.frame_dim)
         args, kwargs = BACKENDS.TranslatedArguments(
             self.backend_name, args, kwargs, plot_function
@@ -41,8 +42,10 @@ class frame_t(base_t):
             plot_function,
             *args,
             title=title,
+            type_=full_type,
             **kwargs,
         )
+        plot.type_ = full_type
         # Note: plot.__class__ is not plot_t; It is the subclass defined by a backend.
         DefaultProperties = getattr(plot.__class__, "_BackendDefaultProperties", None)
         if DefaultProperties is not None:
@@ -59,6 +62,7 @@ class frame_t(base_t):
         plot_function: plot_function_h,
         *args,
         title: str | None = None,  # /!\ If _, then it is swallowed by kwargs!
+        type_: tuple[plot_type_h | plot_function_h, int],
         **kwargs,
     ) -> plot_t:
         """"""

{babelplot-2025.11 → babelplot-2025.13}/package/babelplot/type/plot.py

@@ -7,11 +7,35 @@ SEE COPYRIGHT NOTICE BELOW
 import dataclasses as d
 
 from babelplot.type.ffp_base import base_t
+from babelplot.type.plot_function import plot_function_h
+from babelplot.type.plot_type import plot_type_h
 
 
 @d.dataclass(slots=True, repr=False, eq=False)
 class plot_t(base_t):
     title: str | None = None
+    type_: tuple[plot_type_h | plot_function_h, int] | None = None
+
+    @staticmethod
+    def UnhandledRequestMessage(
+        type_: plot_type_h | plot_function_h, *args, frame_dim: int = 0, **kwargs
+    ) -> str:
+        """"""
+        if frame_dim > 0:
+            if isinstance(type_, str):
+                name = type_
+            else:
+                name = type_.name
+            request = f"{name}.{frame_dim}"
+        else:
+            request = str(type_)
+
+        args = ", ".join(map(lambda _: type(_).__name__, args))
+        kwargs = ", ".join(
+            f"{_key}={type(_vle).__name__}" for _key, _vle in kwargs.items()
+        )
+
+        return f"Unhandled Plot Request\n{request}\nargs: {args}\nkwargs: {kwargs}"
 
 
 """

{babelplot-2025.11 → babelplot-2025.13}/package/babelplot/version.py

@@ -4,7 +4,7 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2022
 SEE COPYRIGHT NOTICE BELOW
 """
 
-__version__ = "2025.11"
+__version__ = "2025.13"
 
 """
 COPYRIGHT NOTICE

{babelplot-2025.11 → babelplot-2025.13}/package/babelplot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: babelplot
-Version: 2025.11
+Version: 2025.13
 Summary: A Meta Plotting Library That Speaks Several Backends
 Home-page: https://src.koda.cnrs.fr/eric.debreuve/babelplot/
 Author: Eric Debreuve

{babelplot-2025.11 → babelplot-2025.13}/package/babelplot.egg-info/SOURCES.txt

@@ -26,7 +26,6 @@ package/babelplot/constant/project.py
 package/babelplot/extension/enum_.py
 package/babelplot/extension/function.py
 package/babelplot/runtime/backends.py
-package/babelplot/task/color.py
 package/babelplot/task/help.py
 package/babelplot/task/instantiation.py
 package/babelplot/task/plotting.py

babelplot-2025.11/package/babelplot/task/color.py

@@ -1,112 +0,0 @@
-"""
-Copyright CNRS/Inria/UniCA
-Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2022
-SEE COPYRIGHT NOTICE BELOW
-"""
-
-import typing as h
-
-import numpy as nmpy
-
-try:
-    import matplotlib.colors as colr
-except ModuleNotFoundError:
-    colr = None
-else:
-    AsHex = lambda _: colr.to_hex(_).upper()
-    AsRGB1 = colr.to_rgb
-    AsRGB255 = lambda _: nmpy.round(255.0 * nmpy.array(colr.to_rgb(_))).astype(
-        nmpy.uint8
-    )
-
-
-assert colr, "No module found for color conversion."
-
-
-array_t = nmpy.ndarray
-
-
-def NewConvertedColor(
-    color: h.Any | h.Sequence[h.Any],
-    format_color: h.Literal["hex", "rgb1", "rgb255"],
-    sequence_or_reduction: (
-        int | h.Literal["min", "mean", "median", "max"] | type | h.Callable
-    ),
-    /,
-) -> h.Any:
-    """"""
-    if format_color == "rgb1":
-        AsOutputFormat = AsRGB1
-    elif format_color == "rgb255":
-        AsOutputFormat = AsRGB255
-    elif format_color == "hex":
-        AsOutputFormat = AsHex
-    else:
-        raise ValueError(f"Unknown output format {format_color}.")
-
-    if (
-        (not isinstance(color, str))
-        and (isinstance(color, h.Sequence) and isinstance(color[0], h.Sequence))
-        or (isinstance(color, array_t) and (color.ndim == 2))
-    ):
-        # Notes: The first h.Sequence is implicitly tuple | list, or other "true" (i.e.
-        # not str) sequence types, and color can be of any length.
-        # The second h.Sequence is implicitly tuple | list, other "true" sequence types,
-        # or str. If str, then color is in Hex format. Its length is either 4 (e.g.,
-        # #ABC <=> #AABBCC), 5 (e.g., #ABCD <=> #AABBCCDD), 7 (e.g., #ABCDEF) or 9
-        # (e.g., #ABCDEF01). If not str, then color is a sequence of 3 or 4 integers or
-        # floats.
-        if isinstance(sequence_or_reduction, int):
-            return AsOutputFormat(color[sequence_or_reduction])
-        elif isinstance(sequence_or_reduction, str):
-            raise NotImplementedError
-        return sequence_or_reduction(tuple(AsOutputFormat(_) for _ in color))
-
-    return AsOutputFormat(color)
-
-
-"""
-COPYRIGHT NOTICE
-
-This software is governed by the CeCILL  license under French law and
-abiding by the rules of distribution of free software.  You can  use,
-modify and/ or redistribute the software under the terms of the CeCILL
-license as circulated by CEA, CNRS and INRIA at the following URL
-"http://www.cecill.info".
-
-As a counterpart to the access to the source code and  rights to copy,
-modify and redistribute granted by the license, users are provided only
-with a limited warranty  and the software's author,  the holder of the
-economic rights,  and the successive licensors  have only  limited
-liability.
-
-In this respect, the user's attention is drawn to the risks associated
-with loading,  using,  modifying and/or developing or reproducing the
-software by the user in light of its specific status of free software,
-that may mean  that it is complicated to manipulate,  and  that  also
-therefore means  that it is reserved for developers  and  experienced
-professionals having in-depth computer knowledge. Users are therefore
-encouraged to load and test the software's suitability as regards their
-requirements in conditions enabling the security of their systems and/or
-data to be ensured and,  more generally, to use and operate it in the
-same conditions as regards security.
-
-The fact that you are presently reading this means that you have had
-knowledge of the CeCILL license and that you accept its terms.
-
-SEE LICENCE NOTICE: file README-LICENCE-utf8.txt at project source root.
-
-This software is being developed by Eric Debreuve, a CNRS employee and
-member of team Morpheme.
-Team Morpheme is a joint team between Inria, CNRS, and UniCA.
-It is hosted by the Centre Inria d'Université Côte d'Azur, Laboratory
-I3S, and Laboratory iBV.
-
-CNRS: https://www.cnrs.fr/index.php/en
-Inria: https://www.inria.fr/en/
-UniCA: https://univ-cotedazur.eu/
-Centre Inria d'Université Côte d'Azur: https://www.inria.fr/en/centre/sophia/
-I3S: https://www.i3s.unice.fr/en/
-iBV: http://ibv.unice.fr/
-Team Morpheme: https://team.inria.fr/morpheme/
-"""