Visualization for Static Objects in Space

[truoineo]

What's the problem this feature will solve?

Not sure if it is an issue of my limited experience with Mesa but I was doing a variant of Passino's Bacterial Foraging and could not figure out a way t visualize static environmental objects (hazards and resources) with Solara. The only way to do so was to make Resources and Hazards also being agents thus they will work with the agent_portrayal() function. This is, however, very counterintuitive especially when your space has many features that you want to have and making them all agents breaks the paradigm. I managed to resolve this by defining a custom Solara component that draws the objects and agents separately from the one created by the default renderer that onlys show agents moving around and nothing else, albeit incurring redundant computation.

Left: The default visualization with only the agents in green circles
Right: The custom component I created with the static objects in green squares and red circles

Describe the solution you'd like

A new support for visualizing these static objects that belong to the environment itself.

Additional context
Space used: mesa.experimental.continuous_space

[EwoutH]

Sounds interesting and useful. I agree a consistent way to visualize (static) non-agent entities in continuous spaces.

Would you be interested in working on an implementation?

[Sahil-Chhoker]

I think the right way to handle custom graph rendering is probably by making it an extra Solara component. It’s hard to cover every possible case, and we’re not really trying to build a full graphing library anyway.

What’s interesting though is that even if you make the graph an external component, it still works pretty much the same as the renderer’s graphs, i.e., it gets called every frame, so you still end up with redundant calculations.

So I think what we really need is a way to make static plots that don’t get re-rendered by Solara every frame.

[truoineo]

@Sahil-Chhoker I'm not really talking about the performance by the way, so the fact it got re-rendered isn't really the issue. It's more like an ease-of-use thing, right now, as you can see from my image, the left graph is entirely useless, and I'm not sure of a way to actually turn it off. It being useless essentially means all the logic of agent_portrayal(), propertylayer_potrayal goes to waste when I create an extra Solara component that has nothing to do with the conventional approach by Mesa.

I wonder if it is possible, perhaps, to define an extra function similar to how agent_portrayal(), propertylayer_potrayal() work, maybe called it environment_portrayal() that deals specifically with these things so everytime one wants to add something it would be just renderer.draw_environment(environment_portray) rather than a redundant second graph to actually show it.

This is how I defined the custom Solara components, notice how I literally added a separate loop just to draw the agents and do not use any of the agent_portrayal(). I just think it is a waste to rebuild it like that when we already have everything in place.

`@solara.component
def SpaceWithStatics(model):
update_counter.get() # Required to update the visualization

fig = Figure()
ax = fig.subplots()

# Draw hazards as red circles
for hazard in model.hazards:
    circle = Circle(
        hazard.pos,
        radius=hazard.radius,
        color='red',
        alpha=0.3,
        edgecolor='darkred',
        linewidth=1
    )
    ax.add_patch(circle)

# Draw resources as green squares
for resource in model.resources:
    if not resource.is_depleted():
        size = 0.5 + (resource.amount / resource.initial_amount) * 1.5
        square = Rectangle(
            (resource.pos[0] - size/2, resource.pos[1] - size/2),
            width=size,
            height=size,
            color='lightgreen',
            alpha=0.7,
            edgecolor='darkgreen',
            linewidth=1
        )
        ax.add_patch(square)

# Draw agents
for agent in model.agents:
    if agent.energy > 75:
        color = "green"
    elif agent.energy > 50:
        color = "yellow"
    elif agent.energy > 25:
        color = "orange"
    else:
        color = "red"
    
    ax.plot(agent.pos[0], agent.pos[1], 'o', color=color, 
            markersize=10, markeredgecolor='black', markeredgewidth=0.5)

# Set up the axes
ax.set_xlim(0, model.space.size[0])
ax.set_ylim(0, model.space.size[1])
ax.set_aspect('equal')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_title('Unicellular Organism Simulation')

solara.FigureMatplotlib(fig)`

[Sahil-Chhoker]

@Sahil-Chhoker I'm not really talking about the performance by the way, so the fact it got re-rendered isn't really the issue. It's more like an ease-of-use thing, right now, as you can see from my image, the left graph is entirely useless, and I'm not sure of a way to actually turn it off.

You can just skip defining the SpaceRenderer, it will solve your problem.

I wonder if it is possible, perhaps, to define an extra function similar to how agent_portrayal(), propertylayer_potrayal() work, maybe called it environment_portrayal() that deals specifically with these things so everytime one wants to add something it would be just renderer.draw_environment(environment_portray) rather than a redundant second graph to actually show it.

You can directly define the Hazard and Resource as fixed agents and other moving agents as CellAgents. And defining a suitable agnet_portrayal you can get the desired results.

A very basic implementation:

from mesa.discrete_space import OrthogonalMooreGrid
from mesa import Model
from mesa.discrete_space import CellAgent
from mesa.visualization.components import AgentPortrayalStyle
from mesa.visualization import SpaceRenderer, SolaraViz
import random

class myAgent(CellAgent):
    def __init__(self, model, cell):
        super().__init__(model)
        self.cell = cell
        self.name = random.choice(['A', 'B', 'C'])

class mymodel(Model):
    def __init__(self, width=10, height=10, seed=None):
        super().__init__(seed=seed)
        self.grid = OrthogonalMooreGrid((width, height), random=self.random)

        for _ in range(100):
            cell = self.random.choice(self.grid.all_cells.cells)
            agent = myAgent(self, cell)
    

def agent_portrayal(agent):
    if agent.name == "A":
        return AgentPortrayalStyle(color="red", marker="o", size=500, alpha=0.4, zorder=-1)
    elif agent.name == "B":
        return AgentPortrayalStyle(color="lightgreen", marker="s", size=100, alpha=0.4, zorder=0)
    elif agent.name == "C":
        return AgentPortrayalStyle(color="green", marker="o", size=100, alpha=0.8, zorder=1)
    return AgentPortrayalStyle()

model = mymodel()
renderer = SpaceRenderer(model)
renderer.draw_agents(agent_portrayal)

page = SolaraViz(
    model,
    renderer,
    components=[],
    model_params={},
    name="My Model",
)

Gives this result: