refactor vizualize module into separate files

Author: SimonBlanke

src/surfaces/visualize/__init__.py

@@ -59,15 +59,13 @@
     PlotCompatibilityError,
     VisualizationError,
 )
-from ._plots import (
-    auto_plot,
-    plot_contour,
-    plot_convergence,
-    plot_fitness_distribution,
-    plot_latex,
-    plot_multi_slice,
-    plot_surface,
-)
+from ._auto import auto_plot
+from ._contour import plot_contour
+from ._convergence import plot_convergence
+from ._distribution import plot_fitness_distribution
+from ._latex import plot_latex
+from ._slices import plot_multi_slice
+from ._surface import plot_surface
 
 __all__ = [
     # Discovery functions

src/surfaces/visualize/_auto.py

@@ -0,0 +1,68 @@
+# Author: Simon Blanke
+# Email: [email protected]
+# License: MIT License
+
+"""Auto-selection of best visualization for a test function."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Dict, List, Optional, Union
+
+if TYPE_CHECKING:
+    import plotly.graph_objects as go
+
+    from ..test_functions._base_test_function import BaseTestFunction
+
+from ._compatibility import _get_function_dimensions
+from ._convergence import plot_convergence
+from ._slices import plot_multi_slice
+from ._surface import plot_surface
+from ._utils import check_plotly
+
+
+def auto_plot(
+    func: "BaseTestFunction",
+    history: Optional[Union[List[float], Dict[str, List[float]]]] = None,
+    resolution: int = 50,
+    **kwargs,
+) -> "go.Figure":
+    """Automatically select and create the best visualization for a function.
+
+    Selection logic:
+    - 2D functions: surface plot
+    - N-D functions (N > 2): multi_slice plot
+    - 1D functions: multi_slice plot (single panel)
+    - If history provided: convergence plot
+
+    Args:
+        func: A test function of any dimension.
+        history: Optional optimization history. If provided, creates convergence plot.
+        resolution: Resolution for grid-based plots.
+        **kwargs: Additional arguments passed to the selected plot function.
+
+    Returns:
+        Plotly Figure object.
+
+    Examples:
+        >>> from surfaces.test_functions import SphereFunction
+        >>> from surfaces.visualize import auto_plot
+        >>> func = SphereFunction(n_dim=2)
+        >>> fig = auto_plot(func)  # Returns surface plot
+        >>> fig.show()
+        >>> func5d = SphereFunction(n_dim=5)
+        >>> fig = auto_plot(func5d)  # Returns multi_slice plot
+        >>> fig.show()
+    """
+    check_plotly()
+
+    # If history is provided, show convergence
+    if history is not None:
+        return plot_convergence(func, history, **kwargs)
+
+    n_dim = _get_function_dimensions(func)
+
+    # Select best plot for this function
+    if n_dim == 2:
+        return plot_surface(func, resolution=resolution, **kwargs)
+    else:
+        return plot_multi_slice(func, resolution=resolution, **kwargs)

src/surfaces/visualize/_contour.py

@@ -0,0 +1,101 @@
+# Author: Simon Blanke
+# Email: [email protected]
+# License: MIT License
+
+"""2D contour plot for 2D test functions."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Dict, Optional, Tuple
+
+if TYPE_CHECKING:
+    import plotly.graph_objects as go
+
+    from ..test_functions._base_test_function import BaseTestFunction
+
+from ._utils import (
+    DEFAULT_COLORSCALE,
+    check_plotly,
+    create_search_space_grid,
+    evaluate_grid_2d,
+    go,
+    validate_plot,
+)
+
+
+def plot_contour(
+    func: "BaseTestFunction",
+    resolution: int = 50,
+    bounds: Optional[Dict[str, Tuple[float, float]]] = None,
+    title: Optional[str] = None,
+    width: int = 700,
+    height: int = 600,
+    colorscale: Optional[str] = None,
+    n_contours: int = 20,
+    show_labels: bool = True,
+) -> "go.Figure":
+    """Create a 2D contour plot of a 2D objective function.
+
+    Args:
+        func: A 2-dimensional test function.
+        resolution: Number of points per dimension (default: 50).
+        bounds: Optional custom bounds as {'x0': (min, max), 'x1': (min, max)}.
+        title: Plot title. Defaults to function name.
+        width: Plot width in pixels.
+        height: Plot height in pixels.
+        colorscale: Plotly colorscale name.
+        n_contours: Number of contour levels.
+        show_labels: Whether to show contour value labels.
+
+    Returns:
+        Plotly Figure object.
+
+    Raises:
+        PlotCompatibilityError: If function is not 2-dimensional.
+
+    Examples:
+        >>> from surfaces.test_functions import RosenbrockFunction
+        >>> from surfaces.visualize import plot_contour
+        >>> func = RosenbrockFunction(n_dim=2)
+        >>> fig = plot_contour(func)
+        >>> fig.show()
+    """
+    check_plotly()
+    validate_plot(func, "contour")
+
+    # Create grid
+    search_space = create_search_space_grid(func, resolution, bounds)
+    param_names = list(search_space.keys())[:2]
+    x_name, y_name = param_names[0], param_names[1]
+
+    x_values = search_space[x_name]
+    y_values = search_space[y_name]
+
+    # Evaluate
+    z_values = evaluate_grid_2d(func, x_values, y_values, x_name, y_name)
+
+    # Create figure
+    fig = go.Figure(
+        data=go.Contour(
+            x=x_values,
+            y=y_values,
+            z=z_values,
+            colorscale=colorscale or DEFAULT_COLORSCALE,
+            contours=dict(
+                showlabels=show_labels,
+                labelfont=dict(size=10, color="white"),
+            ),
+            ncontours=n_contours,
+        )
+    )
+
+    func_name = getattr(func, "name", type(func).__name__)
+    fig.update_layout(
+        title=title or f"{func_name} - Contour Plot",
+        xaxis_title=x_name,
+        yaxis_title=y_name,
+        width=width,
+        height=height,
+    )
+
+    return fig

src/surfaces/visualize/_convergence.py

@@ -0,0 +1,110 @@
+# Author: Simon Blanke
+# Email: [email protected]
+# License: MIT License
+
+"""Convergence plot for optimization history."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Dict, List, Optional, Union
+
+import numpy as np
+
+if TYPE_CHECKING:
+    import plotly.graph_objects as go
+
+    from ..test_functions._base_test_function import BaseTestFunction
+
+from ._errors import MissingDataError
+from ._utils import check_plotly, go
+
+
+def plot_convergence(
+    func: "BaseTestFunction",
+    history: Union[List[float], Dict[str, List[float]], np.ndarray],
+    title: Optional[str] = None,
+    width: int = 800,
+    height: int = 500,
+    log_scale: bool = False,
+    show_best: bool = True,
+) -> "go.Figure":
+    """Create a convergence plot showing optimization progress.
+
+    Args:
+        func: The test function (used for title and context).
+        history: Objective values per evaluation. Can be:
+            - List of values from a single run
+            - Dict mapping run names to lists of values
+            - 2D array where each row is a run
+        title: Plot title. Defaults to function name.
+        width: Plot width in pixels.
+        height: Plot height in pixels.
+        log_scale: Whether to use log scale for y-axis.
+        show_best: Whether to show best-so-far instead of raw values.
+
+    Returns:
+        Plotly Figure object.
+
+    Raises:
+        MissingDataError: If history is empty.
+
+    Examples:
+        >>> from surfaces.test_functions import SphereFunction
+        >>> from surfaces.visualize import plot_convergence
+        >>> func = SphereFunction(n_dim=2)
+        >>> # Simulated optimization history
+        >>> history = [10.0, 8.0, 5.0, 3.0, 1.0, 0.5, 0.1]
+        >>> fig = plot_convergence(func, history)
+        >>> fig.show()
+    """
+    check_plotly()
+
+    if history is None or (hasattr(history, "__len__") and len(history) == 0):
+        raise MissingDataError("convergence", "optimization history")
+
+    # Normalize history to dict format
+    if isinstance(history, (list, np.ndarray)):
+        if isinstance(history, np.ndarray) and history.ndim == 2:
+            # Multiple runs as 2D array
+            history = {f"Run {i+1}": list(row) for i, row in enumerate(history)}
+        else:
+            # Single run
+            history = {"Optimization": list(history)}
+
+    fig = go.Figure()
+
+    for run_name, values in history.items():
+        if show_best:
+            # Cumulative minimum (best so far)
+            best_so_far = np.minimum.accumulate(values)
+            y_values = best_so_far
+            y_label = "Best Objective Value"
+        else:
+            y_values = values
+            y_label = "Objective Value"
+
+        evaluations = list(range(1, len(values) + 1))
+
+        fig.add_trace(
+            go.Scatter(
+                x=evaluations,
+                y=y_values,
+                mode="lines",
+                name=run_name,
+                line=dict(width=2),
+            )
+        )
+
+    func_name = getattr(func, "name", type(func).__name__)
+    fig.update_layout(
+        title=title or f"{func_name} - Convergence",
+        xaxis_title="Evaluation",
+        yaxis_title=y_label,
+        width=width,
+        height=height,
+    )
+
+    if log_scale:
+        fig.update_yaxes(type="log")
+
+    return fig