Mesa 3.0.0__py3-none-any.whl → 3.0.0a0__py3-none-any.whl

mesa/experimental/cell_space/voronoi.py

@@ -1,257 +0,0 @@
-"""Support for Voronoi meshed grids."""
-
-from collections.abc import Sequence
-from itertools import combinations
-from random import Random
-
-import numpy as np
-
-from mesa.experimental.cell_space.cell import Cell
-from mesa.experimental.cell_space.discrete_space import DiscreteSpace
-
-
-class Delaunay:
-    """Class to compute a Delaunay triangulation in 2D.
-
-    ref: http://github.com/jmespadero/pyDelaunay2D
-    """
-
-    def __init__(self, center: tuple = (0, 0), radius: int = 9999) -> None:
-        """Init and create a new frame to contain the triangulation.
-
-        Args:
-            center: Optional position for the center of the frame. Default (0,0)
-            radius: Optional distance from corners to the center.
-        """
-        center = np.asarray(center)
-        # Create coordinates for the corners of the frame
-        self.coords = [
-            center + radius * np.array((-1, -1)),
-            center + radius * np.array((+1, -1)),
-            center + radius * np.array((+1, +1)),
-            center + radius * np.array((-1, +1)),
-        ]
-
-        # Create two dicts to store triangle neighbours and circumcircles.
-        self.triangles = {}
-        self.circles = {}
-
-        # Create two CCW triangles for the frame
-        triangle1 = (0, 1, 3)
-        triangle2 = (2, 3, 1)
-        self.triangles[triangle1] = [triangle2, None, None]
-        self.triangles[triangle2] = [triangle1, None, None]
-
-        # Compute circumcenters and circumradius for each triangle
-        for t in self.triangles:
-            self.circles[t] = self._circumcenter(t)
-
-    def _circumcenter(self, triangle: list) -> tuple:
-        """Compute circumcenter and circumradius of a triangle in 2D."""
-        points = np.asarray([self.coords[v] for v in triangle])
-        points2 = np.dot(points, points.T)
-        a = np.bmat([[2 * points2, [[1], [1], [1]]], [[[1, 1, 1, 0]]]])
-
-        b = np.hstack((np.sum(points * points, axis=1), [1]))
-        x = np.linalg.solve(a, b)
-        bary_coords = x[:-1]
-        center = np.dot(bary_coords, points)
-
-        radius = np.sum(np.square(points[0] - center))  # squared distance
-        return (center, radius)
-
-    def _in_circle(self, triangle: list, point: list) -> bool:
-        """Check if point p is inside of precomputed circumcircle of triangle."""
-        center, radius = self.circles[triangle]
-        return np.sum(np.square(center - point)) <= radius
-
-    def add_point(self, point: Sequence) -> None:
-        """Add a point to the current DT, and refine it using Bowyer-Watson."""
-        point_index = len(self.coords)
-        self.coords.append(np.asarray(point))
-
-        bad_triangles = []
-        for triangle in self.triangles:
-            if self._in_circle(triangle, point):
-                bad_triangles.append(triangle)
-
-        boundary = []
-        triangle = bad_triangles[0]
-        edge = 0
-
-        while True:
-            opposite_triangle = self.triangles[triangle][edge]
-            if opposite_triangle not in bad_triangles:
-                boundary.append(
-                    (
-                        triangle[(edge + 1) % 3],
-                        triangle[(edge - 1) % 3],
-                        opposite_triangle,
-                    )
-                )
-                edge = (edge + 1) % 3
-                if boundary[0][0] == boundary[-1][1]:
-                    break
-            else:
-                edge = (self.triangles[opposite_triangle].index(triangle) + 1) % 3
-                triangle = opposite_triangle
-
-        for triangle in bad_triangles:
-            del self.triangles[triangle]
-            del self.circles[triangle]
-
-        new_triangles = []
-        for e0, e1, opposite_triangle in boundary:
-            triangle = (point_index, e0, e1)
-            self.circles[triangle] = self._circumcenter(triangle)
-            self.triangles[triangle] = [opposite_triangle, None, None]
-            if opposite_triangle:
-                for i, neighbor in enumerate(self.triangles[opposite_triangle]):
-                    if neighbor and e1 in neighbor and e0 in neighbor:
-                        self.triangles[opposite_triangle][i] = triangle
-
-            new_triangles.append(triangle)
-
-        n = len(new_triangles)
-        for i, triangle in enumerate(new_triangles):
-            self.triangles[triangle][1] = new_triangles[(i + 1) % n]  # next
-            self.triangles[triangle][2] = new_triangles[(i - 1) % n]  # previous
-
-    def export_triangles(self) -> list:
-        """Export the current list of Delaunay triangles."""
-        triangles_list = [
-            (a - 4, b - 4, c - 4)
-            for (a, b, c) in self.triangles
-            if a > 3 and b > 3 and c > 3
-        ]
-        return triangles_list
-
-    def export_voronoi_regions(self):
-        """Export coordinates and regions of Voronoi diagram as indexed data."""
-        use_vertex = {i: [] for i in range(len(self.coords))}
-        vor_coors = []
-        index = {}
-        for triangle_index, (a, b, c) in enumerate(sorted(self.triangles)):
-            vor_coors.append(self.circles[(a, b, c)][0])
-            use_vertex[a] += [(b, c, a)]
-            use_vertex[b] += [(c, a, b)]
-            use_vertex[c] += [(a, b, c)]
-
-            index[(a, b, c)] = triangle_index
-            index[(c, a, b)] = triangle_index
-            index[(b, c, a)] = triangle_index
-
-        regions = {}
-        for i in range(4, len(self.coords)):
-            vertex = use_vertex[i][0][0]
-            region = []
-            for _ in range(len(use_vertex[i])):
-                triangle = next(
-                    triangle for triangle in use_vertex[i] if triangle[0] == vertex
-                )
-                region.append(index[triangle])
-                vertex = triangle[1]
-            regions[i - 4] = region
-
-        return vor_coors, regions
-
-
-def round_float(x: float) -> int:  # noqa
-    return int(x * 500)
-
-
-class VoronoiGrid(DiscreteSpace):
-    """Voronoi meshed GridSpace."""
-
-    triangulation: Delaunay
-    voronoi_coordinates: list
-    regions: list
-
-    def __init__(
-        self,
-        centroids_coordinates: Sequence[Sequence[float]],
-        capacity: float | None = None,
-        random: Random | None = None,
-        cell_klass: type[Cell] = Cell,
-        capacity_function: callable = round_float,
-        cell_coloring_property: str | None = None,
-    ) -> None:
-        """A Voronoi Tessellation Grid.
-
-        Given a set of points, this class creates a grid where a cell is centered in each point,
-        its neighbors are given by Voronoi Tessellation cells neighbors
-        and the capacity by the polygon area.
-
-        Args:
-            centroids_coordinates: coordinates of centroids to build the tessellation space
-            capacity (int) : capacity of the cells in the discrete space
-            random (Random): random number generator
-            cell_klass (type[Cell]): type of cell class
-            capacity_function (Callable): function to compute (int) capacity according to (float) area
-            cell_coloring_property (str): voronoi visualization polygon fill property
-        """
-        super().__init__(capacity=capacity, random=random, cell_klass=cell_klass)
-        self.centroids_coordinates = centroids_coordinates
-        self._validate_parameters()
-
-        self._cells = {
-            i: cell_klass(self.centroids_coordinates[i], capacity, random=self.random)
-            for i in range(len(self.centroids_coordinates))
-        }
-
-        self.regions = None
-        self.triangulation = None
-        self.voronoi_coordinates = None
-        self.capacity_function = capacity_function
-        self.cell_coloring_property = cell_coloring_property
-
-        self._connect_cells()
-        self._build_cell_polygons()
-
-    def _connect_cells(self) -> None:
-        """Connect cells to neighbors based on given centroids and using Delaunay Triangulation."""
-        self.triangulation = Delaunay()
-        for centroid in self.centroids_coordinates:
-            self.triangulation.add_point(centroid)
-
-        for point in self.triangulation.export_triangles():
-            for i, j in combinations(point, 2):
-                self._cells[i].connect(self._cells[j], (i, j))
-                self._cells[j].connect(self._cells[i], (j, i))
-
-    def _validate_parameters(self) -> None:
-        if self.capacity is not None and not isinstance(self.capacity, float | int):
-            raise ValueError("Capacity must be a number or None.")
-        if not isinstance(self.centroids_coordinates, Sequence) or not isinstance(
-            self.centroids_coordinates[0], Sequence
-        ):
-            raise ValueError("Centroids should be a list of lists")
-        dimension_1 = len(self.centroids_coordinates[0])
-        for coordinate in self.centroids_coordinates:
-            if dimension_1 != len(coordinate):
-                raise ValueError("Centroid coordinates should be a homogeneous array")
-
-    def _get_voronoi_regions(self) -> tuple:
-        if self.voronoi_coordinates is None or self.regions is None:
-            (
-                self.voronoi_coordinates,
-                self.regions,
-            ) = self.triangulation.export_voronoi_regions()
-        return self.voronoi_coordinates, self.regions
-
-    @staticmethod
-    def _compute_polygon_area(polygon: list) -> float:
-        polygon = np.array(polygon)
-        x = polygon[:, 0]
-        y = polygon[:, 1]
-        return 0.5 * np.abs(np.dot(x, np.roll(y, 1)) - np.dot(y, np.roll(x, 1)))
-
-    def _build_cell_polygons(self):
-        coordinates, regions = self._get_voronoi_regions()
-        for region in regions:
-            polygon = [coordinates[i] for i in regions[region]]
-            self._cells[region].properties["polygon"] = polygon
-            polygon_area = self._compute_polygon_area(polygon)
-            self._cells[region].properties["area"] = polygon_area
-            self._cells[region].capacity = self.capacity_function(polygon_area)
-            self._cells[region].properties[self.cell_coloring_property] = 0

mesa/experimental/components/matplotlib.py

@@ -1,242 +0,0 @@
-"""Support for using matplotlib to draw spaces."""
-
-from collections import defaultdict
-
-import networkx as nx
-import solara
-from matplotlib.figure import Figure
-from matplotlib.ticker import MaxNLocator
-
-import mesa
-from mesa.experimental.cell_space import VoronoiGrid
-
-
-@solara.component
-def SpaceMatplotlib(model, agent_portrayal, dependencies: list[any] | None = None):
-    """A component for rendering a space using Matplotlib.
-
-    Args:
-        model: a model instance
-        agent_portrayal: a specification of how to portray an agent.
-        dependencies: list of dependencies.
-
-    """
-    space_fig = Figure()
-    space_ax = space_fig.subplots()
-    space = getattr(model, "grid", None)
-    if space is None:
-        # Sometimes the space is defined as model.space instead of model.grid
-        space = model.space
-    if isinstance(space, mesa.space.NetworkGrid):
-        _draw_network_grid(space, space_ax, agent_portrayal)
-    elif isinstance(space, mesa.space.ContinuousSpace):
-        _draw_continuous_space(space, space_ax, agent_portrayal)
-    elif isinstance(space, VoronoiGrid):
-        _draw_voronoi(space, space_ax, agent_portrayal)
-    else:
-        _draw_grid(space, space_ax, agent_portrayal)
-    solara.FigureMatplotlib(space_fig, format="png", dependencies=dependencies)
-
-
-# matplotlib scatter does not allow for multiple shapes in one call
-def _split_and_scatter(portray_data, space_ax):
-    grouped_data = defaultdict(lambda: {"x": [], "y": [], "s": [], "c": []})
-
-    # Extract data from the dictionary
-    x = portray_data["x"]
-    y = portray_data["y"]
-    s = portray_data["s"]
-    c = portray_data["c"]
-    m = portray_data["m"]
-
-    if not (len(x) == len(y) == len(s) == len(c) == len(m)):
-        raise ValueError(
-            "Length mismatch in portrayal data lists: "
-            f"x: {len(x)}, y: {len(y)}, size: {len(s)}, "
-            f"color: {len(c)}, marker: {len(m)}"
-        )
-
-    # Group the data by marker
-    for i in range(len(x)):
-        marker = m[i]
-        grouped_data[marker]["x"].append(x[i])
-        grouped_data[marker]["y"].append(y[i])
-        grouped_data[marker]["s"].append(s[i])
-        grouped_data[marker]["c"].append(c[i])
-
-    # Plot each group with the same marker
-    for marker, data in grouped_data.items():
-        space_ax.scatter(data["x"], data["y"], s=data["s"], c=data["c"], marker=marker)
-
-
-def _draw_grid(space, space_ax, agent_portrayal):
-    def portray(g):
-        x = []
-        y = []
-        s = []  # size
-        c = []  # color
-        m = []  # shape
-        for i in range(g.width):
-            for j in range(g.height):
-                content = g._grid[i][j]
-                if not content:
-                    continue
-                if not hasattr(content, "__iter__"):
-                    # Is a single grid
-                    content = [content]
-                for agent in content:
-                    data = agent_portrayal(agent)
-                    x.append(i)
-                    y.append(j)
-
-                    # This is the default value for the marker size, which auto-scales
-                    # according to the grid area.
-                    default_size = (180 / max(g.width, g.height)) ** 2
-                    # establishing a default prevents misalignment if some agents are not given size, color, etc.
-                    size = data.get("size", default_size)
-                    s.append(size)
-                    color = data.get("color", "tab:blue")
-                    c.append(color)
-                    mark = data.get("shape", "o")
-                    m.append(mark)
-        out = {"x": x, "y": y, "s": s, "c": c, "m": m}
-        return out
-
-    space_ax.set_xlim(-1, space.width)
-    space_ax.set_ylim(-1, space.height)
-    _split_and_scatter(portray(space), space_ax)
-
-
-def _draw_network_grid(space, space_ax, agent_portrayal):
-    graph = space.G
-    pos = nx.spring_layout(graph, seed=0)
-    nx.draw(
-        graph,
-        ax=space_ax,
-        pos=pos,
-        **agent_portrayal(graph),
-    )
-
-
-def _draw_continuous_space(space, space_ax, agent_portrayal):
-    def portray(space):
-        x = []
-        y = []
-        s = []  # size
-        c = []  # color
-        m = []  # shape
-        for agent in space._agent_to_index:
-            data = agent_portrayal(agent)
-            _x, _y = agent.pos
-            x.append(_x)
-            y.append(_y)
-
-            # This is matplotlib's default marker size
-            default_size = 20
-            # establishing a default prevents misalignment if some agents are not given size, color, etc.
-            size = data.get("size", default_size)
-            s.append(size)
-            color = data.get("color", "tab:blue")
-            c.append(color)
-            mark = data.get("shape", "o")
-            m.append(mark)
-        out = {"x": x, "y": y, "s": s, "c": c, "m": m}
-        return out
-
-    # Determine border style based on space.torus
-    border_style = "solid" if not space.torus else (0, (5, 10))
-
-    # Set the border of the plot
-    for spine in space_ax.spines.values():
-        spine.set_linewidth(1.5)
-        spine.set_color("black")
-        spine.set_linestyle(border_style)
-
-    width = space.x_max - space.x_min
-    x_padding = width / 20
-    height = space.y_max - space.y_min
-    y_padding = height / 20
-    space_ax.set_xlim(space.x_min - x_padding, space.x_max + x_padding)
-    space_ax.set_ylim(space.y_min - y_padding, space.y_max + y_padding)
-
-    # Portray and scatter the agents in the space
-    _split_and_scatter(portray(space), space_ax)
-
-
-def _draw_voronoi(space, space_ax, agent_portrayal):
-    def portray(g):
-        x = []
-        y = []
-        s = []  # size
-        c = []  # color
-
-        for cell in g.all_cells:
-            for agent in cell.agents:
-                data = agent_portrayal(agent)
-                x.append(cell.coordinate[0])
-                y.append(cell.coordinate[1])
-                if "size" in data:
-                    s.append(data["size"])
-                if "color" in data:
-                    c.append(data["color"])
-        out = {"x": x, "y": y}
-        # This is the default value for the marker size, which auto-scales
-        # according to the grid area.
-        out["s"] = s
-        if len(c) > 0:
-            out["c"] = c
-
-        return out
-
-    x_list = [i[0] for i in space.centroids_coordinates]
-    y_list = [i[1] for i in space.centroids_coordinates]
-    x_max = max(x_list)
-    x_min = min(x_list)
-    y_max = max(y_list)
-    y_min = min(y_list)
-
-    width = x_max - x_min
-    x_padding = width / 20
-    height = y_max - y_min
-    y_padding = height / 20
-    space_ax.set_xlim(x_min - x_padding, x_max + x_padding)
-    space_ax.set_ylim(y_min - y_padding, y_max + y_padding)
-    space_ax.scatter(**portray(space))
-
-    for cell in space.all_cells:
-        polygon = cell.properties["polygon"]
-        space_ax.fill(
-            *zip(*polygon),
-            alpha=min(1, cell.properties[space.cell_coloring_property]),
-            c="red",
-        )  # Plot filled polygon
-        space_ax.plot(*zip(*polygon), color="black")  # Plot polygon edges in red
-
-
-@solara.component
-def PlotMatplotlib(model, measure, dependencies: list[any] | None = None):
-    """A solara component for creating a matplotlib figure.
-
-    Args:
-        model: Model instance
-        measure: measure to plot
-        dependencies: list of additional dependencies
-
-    """
-    fig = Figure()
-    ax = fig.subplots()
-    df = model.datacollector.get_model_vars_dataframe()
-    if isinstance(measure, str):
-        ax.plot(df.loc[:, measure])
-        ax.set_ylabel(measure)
-    elif isinstance(measure, dict):
-        for m, color in measure.items():
-            ax.plot(df.loc[:, m], label=m, color=color)
-        fig.legend()
-    elif isinstance(measure, list | tuple):
-        for m in measure:
-            ax.plot(df.loc[:, m], label=m)
-        fig.legend()
-    # Set integer x axis
-    ax.xaxis.set_major_locator(MaxNLocator(integer=True))
-    solara.FigureMatplotlib(fig, dependencies=dependencies)

mesa/visualization/components/__init__.py

@@ -1,83 +0,0 @@
-"""custom solara components."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-
-from .altair_components import SpaceAltair, make_altair_space
-from .matplotlib_components import (
-    SpaceMatplotlib,
-    make_mpl_plot_component,
-    make_mpl_space_component,
-)
-
-
-def make_space_component(
-    agent_portrayal: Callable | None = None,
-    propertylayer_portrayal: dict | None = None,
-    post_process: Callable | None = None,
-    backend: str = "matplotlib",
-    **space_drawing_kwargs,
-) -> SpaceMatplotlib | SpaceAltair:
-    """Create a Matplotlib-based space visualization component.
-
-    Args:
-        agent_portrayal: Function to portray agents.
-        propertylayer_portrayal: Dictionary of PropertyLayer portrayal specifications
-        post_process : a callable that will be called with the Axes instance. Allows for fine-tuning plots (e.g., control ticks)
-        backend: the backend to use {"matplotlib", "altair"}
-        space_drawing_kwargs : additional keyword arguments to be passed on to the underlying backend specific space drawer function. See
-                               the functions for drawing the various spaces for the appropriate backend further details.
-
-
-    Returns:
-        function: A function that creates a space component
-    """
-    if backend == "matplotlib":
-        return make_mpl_space_component(
-            agent_portrayal,
-            propertylayer_portrayal,
-            post_process,
-            **space_drawing_kwargs,
-        )
-    elif backend == "altair":
-        return make_altair_space(
-            agent_portrayal,
-            propertylayer_portrayal,
-            post_process,
-            **space_drawing_kwargs,
-        )
-    else:
-        raise ValueError(
-            f"unknown backend {backend}, must be one of matplotlib, altair"
-        )
-
-
-def make_plot_component(
-    measure: str | dict[str, str] | list[str] | tuple[str],
-    post_process: Callable | None = None,
-    backend: str = "matplotlib",
-    **plot_drawing_kwargs,
-):
-    """Create a plotting function for a specified measure using the specified backend.
-
-    Args:
-        measure (str | dict[str, str] | list[str] | tuple[str]): Measure(s) to plot.
-        post_process: a user-specified callable to do post-processing called with the Axes instance.
-        backend: the backend to use {"matplotlib", "altair"}
-        plot_drawing_kwargs: additional keyword arguments to pass onto the backend specific function for making a plotting component
-
-    Notes:
-        altair plotting backend is not yet implemented and planned for mesa 3.1.
-
-    Returns:
-        function: A function that creates a plot component
-    """
-    if backend == "matplotlib":
-        return make_mpl_plot_component(measure, post_process, **plot_drawing_kwargs)
-    elif backend == "altair":
-        raise NotImplementedError("altair line plots are not yet implemented")
-    else:
-        raise ValueError(
-            f"unknown backend {backend}, must be one of matplotlib, altair"
-        )