pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/visualization/pcp.py

@@ -0,0 +1,121 @@
+import numpy as np
+
+from pymoo.docs import parse_doc_string
+from pymoo.core.plot import Plot
+from pymoo.util.misc import set_if_none, set_if_none_from_tuples
+from pymoo.visualization.util import parse_bounds, normalize
+from pymoo.visualization.matplotlib import plt
+
+
+class PCP(Plot):
+
+    def __init__(self,
+                 bounds=None,
+                 show_bounds=True,
+                 n_ticks=5,
+                 normalize_each_axis=True,
+                 bbox=False,
+                 **kwargs):
+        """
+
+        Parallel Coordinate Plot
+
+
+        Parameters
+        ----------
+
+        bounds : {bounds}
+
+        axis_style : {axis_style}
+
+        labels : {labels}
+
+        n_ticks : int
+            Number of ticks to be shown on each parallel axis.
+
+        show_bounds : bool
+            Whether the value of the boundaries are shown in the plot or not.
+
+        normalize_each_axis : bool
+            Whether the values should be normalized either by bounds or implicitly.
+
+        Other Parameters
+        ----------------
+
+        figsize : {figsize}
+        title : {title}
+        legend : {legend}
+        tight_layout : {tight_layout}
+        cmap : {cmap}
+
+        """
+
+        super().__init__(bounds=bounds, **kwargs)
+        self.show_bounds = show_bounds
+        self.n_ticks = n_ticks
+        self.bbox = bbox
+        self.normalize_each_axis = normalize_each_axis
+
+        set_if_none_from_tuples(self.axis_style, ("color", "red"), ("linewidth", 2), ("alpha", 0.75))
+
+    def _do(self):
+
+        # initial a figure with a single plot
+        self.init_figure()
+
+        # if no normalization of each axis the bounds are based on the overall min and max
+        if not self.normalize_each_axis and self.bounds is None:
+            _F = np.vstack([e[0] for e in self.to_plot])
+            self.bounds = [_F.min(), _F.max()]
+
+        # normalize the input
+        bounds = parse_bounds(self.bounds, self.n_dim)
+        to_plot_norm, bounds = normalize(self.to_plot, bounds, return_bounds=True)
+
+        # plot for each set the lines
+        for k, (F, kwargs) in enumerate(to_plot_norm):
+
+            _kwargs = kwargs.copy()
+            set_if_none(_kwargs, "color", self.colors[k % len(self.colors)])
+
+            for i in range(len(F)):
+                plt.plot(np.arange(F.shape[1]), F[i, :], **_kwargs)
+
+        # Plot the parallel coordinate axes
+        for i in range(self.n_dim):
+            self.ax.axvline(i, **self.axis_style)
+
+            bottom, top = -0.1, 1.075
+            margin_left = 0.08
+
+            if self.show_bounds:
+                lower = self.ax.text(i - margin_left, bottom, self.func_number_to_text(bounds[0][i]))
+                upper = self.ax.text(i - margin_left, top, self.func_number_to_text(bounds[1][i]))
+
+                if self.bbox:
+                    lower.set_bbox(dict(facecolor='white', alpha=0.8))
+                    upper.set_bbox(dict(facecolor='white', alpha=0.8))
+
+            if self.n_ticks is not None:
+                n_length = 0.03
+                for y in np.linspace(0, 1, self.n_ticks):
+                    self.ax.hlines(y, i - n_length, i + n_length, **self.axis_style)
+
+        # if bounds are shown, then move them to the bottom
+        if self.show_bounds:
+            self.ax.tick_params(axis='x', which='major', pad=25)
+
+        self.ax.spines['right'].set_visible(False)
+        self.ax.spines['left'].set_visible(False)
+
+        self.ax.set_yticklabels([])
+        self.ax.set_yticks([])
+        self.ax.set_ylim((-0.05, 1.05))
+
+        self.ax.set_xticks(np.arange(self.n_dim))
+        self.ax.set_xticklabels(self.get_labels())
+
+        return self
+
+
+parse_doc_string(PCP.__init__)

pymoo/visualization/petal.py

@@ -0,0 +1,91 @@
+import numpy as np
+
+from pymoo.docs import parse_doc_string
+from pymoo.core.plot import Plot
+from pymoo.util.misc import set_if_none
+from pymoo.visualization.util import get_circle_points, plot_axes_lines, \
+    plot_axis_labels, plot_circle, plot_polygon, parse_bounds, normalize, equal_axis, no_ticks
+
+
+class Petal(Plot):
+
+    def __init__(self,
+                 bounds=None,
+                 **kwargs):
+        """
+
+        Petal Diagram
+
+
+        Parameters
+        ----------
+        bounds : tuple
+            The boundaries for each objective. Necessary to be provided for this plot!
+        axis_style : {axis_style}
+        reverse : bool
+            Default false. Otherwise, larger area means smaller value.
+
+        Other Parameters
+        ----------------
+
+        figsize : {figsize}
+        title : {title}
+        legend : {legend}
+        tight_layout : {tight_layout}
+        cmap : {cmap}
+
+        """
+
+        super().__init__(bounds=bounds, **kwargs)
+
+        if bounds is None:
+            raise Exception("Boundaries must be provided for Petal Width. Otherwise, no trade-offs can be calculated.")
+
+        set_if_none(self.axis_style, "color", "black")
+        set_if_none(self.axis_style, "linewidth", 2)
+        set_if_none(self.axis_style, "alpha", 0.5)
+
+    def _plot(self, ax, F):
+
+        # equal axis length and no ticks
+        equal_axis(ax)
+        no_ticks(ax)
+
+        V = get_circle_points(len(F))
+
+        # sections to plot
+        sections = np.linspace(0, 2 * np.pi, self.n_dim + 1)
+
+        t = [(sections[i] + sections[i + 1]) / 2 for i in range(len(sections) - 1)]
+        endpoints = np.column_stack([np.cos(t), np.sin(t)])
+        plot_axis_labels(ax, endpoints, self.get_labels(), **self.axis_label_style)
+
+        center = np.zeros(2)
+
+        for i in range(len(sections) - 1):
+            t = np.linspace(sections[i], sections[i + 1], 100)
+            v = np.column_stack([np.cos(t), np.sin(t)])
+
+            P = np.vstack([center, F[i] * v])
+            plot_polygon(ax, P, color=self.colors[i])
+
+        # draw the outer circle
+        plot_circle(ax, **self.axis_style)
+        plot_axes_lines(ax, V, **self.axis_style)
+
+    def _do(self):
+
+        n_rows = len(self.to_plot)
+        n_cols = max([len(e[0]) for e in self.to_plot])
+        self.init_figure(n_rows=n_rows, n_cols=n_cols, force_axes_as_matrix=True)
+
+        # normalize the input
+        bounds = parse_bounds(self.bounds, self.n_dim)
+        to_plot_norm = normalize(self.to_plot, bounds, reverse=self.reverse)
+
+        for k, (F, kwargs) in enumerate(to_plot_norm):
+            for j, _F in enumerate(F):
+                self._plot(self.ax[k, j], _F)
+
+
+parse_doc_string(Petal.__init__)

pymoo/visualization/radar.py

@@ -0,0 +1,108 @@
+import numpy as np
+
+from pymoo.docs import parse_doc_string
+from pymoo.core.plot import Plot
+from pymoo.util.misc import set_if_none_from_tuples
+from pymoo.visualization.util import plot_axes_lines, plot_axis_labels, plot_polygon, get_circle_points, \
+    plot_radar_line, equal_axis, no_ticks, parse_bounds, normalize
+
+
+class Radar(Plot):
+
+    def __init__(self,
+                 normalize_each_objective=True,
+                 n_partitions=3,
+                 point_style={},
+                 **kwargs):
+
+        """
+        Radar Plot
+
+        Parameters
+        ----------
+        normalize_each_objective : bool
+            Whether each objective is normalized. Otherwise, the inner and outer bound is plotted.
+        point_style : dict
+            The style being used to visualize the points
+        n_partitions : int
+            Number of partitions to show in the radar.
+        reverse : {reverse}
+        axis_style : {axis_style}
+        labels : {labels}
+
+        Other Parameters
+        ----------------
+        figsize : {figsize}
+        title : {title}
+        legend : {legend}
+        tight_layout : {tight_layout}
+        cmap : {cmap}
+        """
+
+        super().__init__(**kwargs)
+        self.normalize_each_objective = normalize_each_objective
+        self.n_partitions = n_partitions
+
+        self.point_style = point_style
+        set_if_none_from_tuples(self.point_style, ("s", 15))
+
+        set_if_none_from_tuples(self.axis_style, ("color", "black"), ("linewidth", 0.5), ("alpha", 0.75))
+
+    def _plot(self, ax, _F, inner, outer, kwargs):
+
+        set_if_none_from_tuples(kwargs, ("alpha", 0.5))
+
+        # equal axis length and no ticks
+        equal_axis(ax)
+        no_ticks(ax)
+
+        # draw the axis lines and labels
+        plot_axes_lines(ax, outer, extend_factor=1.0, **self.axis_style)
+        plot_axis_labels(ax, outer, self.get_labels(), margin=0.015, **self.axis_label_style)
+
+        # plot the outer radar line and the inner polygon
+        plot_radar_line(ax, outer, **self.axis_style)
+        plot_polygon(ax, inner)
+
+        # find the corresponding point
+        _F = inner + _F[:, None] * (outer - inner)
+
+        # plot the points and no polygon
+        ax.scatter(_F[:, 0], _F[:, 1], **self.point_style)
+        plot_polygon(ax, _F, **kwargs)
+
+    def _do(self):
+
+        if self.bounds is None:
+            raise Exception("The boundaries must be provided.")
+
+        _F = np.vstack([e[0] for e in self.to_plot])
+        if np.any(_F < self.bounds[0]) or np.any(_F > self.bounds[1]):
+            raise Exception(
+                "Points out of the boundaries exist! Please make sure the boundaries are indeed boundaries.")
+
+        n_rows = len(self.to_plot)
+        n_cols = max([len(e[0]) for e in self.to_plot])
+        self.init_figure(n_rows=n_rows, n_cols=n_cols, force_axes_as_matrix=True)
+
+        # normalize the input
+        bounds = parse_bounds(self.bounds, self.n_dim)
+        to_plot_norm = normalize(self.to_plot, bounds, reverse=self.reverse)
+
+        # get the endpoints of circle
+        V = get_circle_points(self.n_dim)
+
+        if self.normalize_each_objective:
+            inner = np.zeros((self.n_dim, 1)) * V
+            outer = np.ones((self.n_dim, 1)) * V
+        else:
+            inner = bounds[[0]].T * V
+            outer = (bounds[[1]].T * V) / bounds[1].max()
+
+        for k, (F, kwargs) in enumerate(to_plot_norm):
+
+            for j, _F in enumerate(F):
+                self._plot(self.ax[k, j], _F, inner, outer, kwargs)
+
+
+parse_doc_string(Radar.__init__)

pymoo/visualization/radviz.py

@@ -0,0 +1,68 @@
+from pymoo.docs import parse_doc_string
+from pymoo.core.plot import Plot
+from pymoo.util.misc import set_if_none_from_tuples
+from pymoo.visualization.util import plot_circle, plot_radar_line, plot_axis_labels, equal_axis, no_ticks, \
+    get_uniform_points_around_circle
+
+
+class Radviz(Plot):
+
+    def __init__(self, endpoint_style={}, **kwargs):
+        """
+
+        Radviz Plot
+
+        Parameters
+        ----------
+
+        axis_style : {axis_style}
+        endpoint_style : dict
+            Endpoints are drawn at each extreme point of an objective. This style can be modified.
+        labels : {labels}
+
+        Other Parameters
+        ----------------
+
+        figsize : {figsize}
+        title : {title}
+        legend : {legend}
+        tight_layout : {tight_layout}
+        cmap : {cmap}
+
+        """
+
+        super().__init__(**kwargs)
+
+        # set the default axis style
+        set_if_none_from_tuples(self.axis_style, ("color", "black"), ("linewidth", 1), ("alpha", 0.75))
+
+        self.endpoint_style = endpoint_style
+        set_if_none_from_tuples(self.endpoint_style, ("color", "black"), ("s", 70), ("alpha", 0.3))
+
+    def _do(self):
+
+        # initial a figure with a single plot
+        self.init_figure()
+
+        # equal axis length and no ticks
+        equal_axis(self.ax)
+        no_ticks(self.ax)
+
+        V = get_uniform_points_around_circle(self.n_dim)
+        plot_axis_labels(self.ax, V, self.get_labels(), **self.axis_label_style)
+
+        # draw the outer circle and radar lines
+        plot_circle(self.ax, **self.axis_style)
+        plot_radar_line(self.ax, V, **self.axis_style)
+
+        # draw the endpoints of each objective
+        if self.endpoint_style:
+            self.ax.scatter(V[:, 0], V[:, 1], **self.endpoint_style)
+
+        # plot all the points
+        for k, (F, kwargs) in enumerate(self.to_plot):
+            N = (F[..., None] * V).sum(axis=1) / F.sum(axis=1)[:, None]
+            self.ax.scatter(N[:, 0], N[:, 1], **kwargs)
+
+
+parse_doc_string(Radviz.__init__)

pymoo/visualization/scatter.py

@@ -0,0 +1,150 @@
+import numpy as np
+
+from pymoo.core.plot import Plot
+from pymoo.docs import parse_doc_string
+from pymoo.util.misc import set_if_none
+
+
+def plot_1d(sc):
+    sc.init_figure()
+    labels = sc.get_labels()
+    ax = sc.ax
+
+    for k, (F, kwargs) in enumerate(sc.to_plot):
+        func = getattr(ax, kwargs.pop("mode"))
+        func(F, np.zeros_like(F), **kwargs)
+        ax.set_xlabel(labels[0])
+
+
+def plot_2d(sc):
+    sc.init_figure()
+    labels = sc.get_labels()
+    ax = sc.ax
+
+    for k, (F, kwargs) in enumerate(sc.to_plot):
+        func = getattr(ax, kwargs.pop("mode"))
+        func(F[:, 0], F[:, 1], **kwargs)
+        ax.set_xlabel(labels[0])
+        ax.set_ylabel(labels[1])
+
+    return sc
+
+
+def plot_3d(sc, angle):
+    sc.init_figure(plot_3D=True)
+    labels = sc.get_labels()
+    ax = sc.ax
+
+    for k, (F, kwargs) in enumerate(sc.to_plot):
+
+        # here alo `plot_trisurf` is allowed
+        func = getattr(ax, kwargs.pop("mode"))
+        func(F[:, 0], F[:, 1], F[:, 2], **kwargs)
+
+        ax.xaxis.pane.fill = False
+        ax.yaxis.pane.fill = False
+        ax.zaxis.pane.fill = False
+
+        ax.set_xlabel(labels[0])
+        ax.set_ylabel(labels[1])
+        ax.set_zlabel(labels[2])
+
+        if sc.angle is not None:
+            ax.view_init(*angle)
+
+
+def plot_pairwise(sc):
+    sc.init_figure(n_rows=sc.n_dim, n_cols=sc.n_dim)
+    labels = sc.get_labels()
+
+    for k, (F, kwargs) in enumerate(sc.to_plot):
+
+        assert F.shape[1] >= 2, "A pairwise sc plot needs at least two dimensions."
+        mode = kwargs.pop("mode")
+
+        for i in range(sc.n_dim):
+            for j in range(sc.n_dim):
+
+                ax = sc.ax[i, j]
+                func = getattr(ax, mode)
+
+                if i != j:
+                    func(F[:, i], F[:, j], **kwargs)
+                    ax.set_xlabel(labels[i])
+                    ax.set_ylabel(labels[j])
+                else:
+                    func(0, 0, s=1, color="white")
+                    ax.set_xticks([])
+                    ax.set_yticks([])
+                    ax.text(0, 0, labels[i], ha='center', va='center', fontsize=20)
+
+
+class Scatter(Plot):
+
+    def __init__(self,
+                 plot_3d=True,
+                 angle=(45, 45),
+                 **kwargs):
+        """
+
+        Scatter Plot
+
+        Parameters
+        ----------
+
+        axis_style : {axis_style}
+        labels : {labels}
+
+        Other Parameters
+        ----------------
+
+        figsize : {figsize}
+        title : {title}
+        legend : {legend}
+        tight_layout : {tight_layout}
+
+        """
+
+        super().__init__(**kwargs)
+        self.angle = angle
+        self.plot_3d = plot_3d
+
+    def _do(self):
+
+        # set some default values
+        to_plot = []
+        for k, (F, v) in enumerate(self.to_plot):
+            v = dict(v)
+            set_if_none(v, "color", self.colors[k % len(self.colors)])
+            set_if_none(v, "alpha", 1.0)
+
+            # this is added to have compatibility to an old version
+            # should be removed when the documentation is updated
+            if "plot_type" in v:
+                name = v.pop("plot_type")
+
+                if name == "line":
+                    name = "plot"
+                elif name == "surface":
+                    name = "plot_trisurf"
+
+                v["mode"] = name
+            set_if_none(v, "mode", "scatter")
+
+            to_plot.append([F, v])
+
+        self.to_plot = to_plot
+
+        if self.n_dim == 1:
+            plot_1d(self)
+        elif self.n_dim == 2:
+            plot_2d(self)
+        elif self.n_dim == 3 and self.plot_3d:
+            plot_3d(self, self.angle)
+        else:
+            plot_pairwise(self)
+
+        return self
+
+
+parse_doc_string(Scatter.__init__)

pymoo/visualization/star_coordinate.py

@@ -0,0 +1,75 @@
+import numpy as np
+
+from pymoo.visualization.util import plot_axes_arrow, plot_axis_labels, equal_axis, no_ticks, parse_bounds, \
+    normalize, get_uniform_points_around_circle
+from pymoo.docs import parse_doc_string
+from pymoo.core.plot import Plot
+
+
+class StarCoordinate(Plot):
+
+    def __init__(self,
+                 axis_extension=1.03,
+                 **kwargs):
+        """
+
+        Star Coordinate Plot
+
+        Parameters
+        ----------
+
+        axis_style : {axis_style}
+        labels : {labels}
+        endpoint_style : dict
+            Endpoints are drawn at each extreme point of an objective. This style can be modified.
+
+        Other Parameters
+        ----------------
+
+        figsize : {figsize}
+        title : {title}
+        legend : {legend}
+        tight_layout : {tight_layout}
+        cmap : {cmap}
+
+        """
+        super().__init__(**kwargs)
+
+        self.axis_extension = axis_extension
+
+        if "arrow_style" not in kwargs:
+            self.arrow_style = {
+                "head_width": 0.02,
+                "head_length": 0.01
+            }
+        else:
+            self.arrow_style = kwargs["arrow_style"]
+
+    def _do(self):
+
+        # initial a figure with a single plot
+        self.init_figure()
+
+        # equal axis length and no ticks
+        equal_axis(self.ax)
+        no_ticks(self.ax)
+
+        # determine the overall scale of points
+        _F = np.vstack([e[0] for e in self.to_plot])
+        _min, _max = _F.min(axis=0), _F.max(axis=0)
+
+        V = get_uniform_points_around_circle(self.n_dim)
+
+        plot_axes_arrow(self.ax, V, extend_factor=self.axis_extension, **{**self.axis_style, **self.arrow_style})
+        plot_axis_labels(self.ax, V, self.get_labels(), **self.axis_label_style)
+
+        # normalize in range for this plot - here no implicit normalization as in radviz
+        bounds = parse_bounds(self.bounds, self.n_dim)
+        to_plot_norm = normalize(self.to_plot, bounds)
+
+        for k, (F, kwargs) in enumerate(to_plot_norm):
+            N = (F[..., None] * V).sum(axis=1)
+            self.ax.scatter(N[:, 0], N[:, 1], **kwargs)
+
+
+parse_doc_string(StarCoordinate.__init__)