fastplotlib · kushalkolar · Mar 5, 2023 · Mar 8, 2023 · Mar 8, 2023 · Mar 8, 2023
diff --git a/examples/garbage_collection.ipynb b/examples/garbage_collection.ipynb
diff --git a/examples/simple.ipynb b/examples/simple.ipynb
diff --git a/fastplotlib/VERSION b/fastplotlib/VERSION
@@ -1 +1 @@
-0.1.0.a9
+0.1.0.a10
diff --git a/fastplotlib/graphics/_base.py b/fastplotlib/graphics/_base.py
@@ -1,4 +1,5 @@
 from typing import *
+import weakref
 from warnings import warn

 import numpy as np
@@ -14,6 +15,11 @@
 from dataclasses import dataclass


+# dict that holds all world objects for a given python kernel/session
+# Graphic objects only use proxies to WorldObjects
+WORLD_OBJECTS: Dict[str, WorldObject] = dict()  #: {hex id str: WorldObject}
+
+
 PYGFX_EVENTS = [
    "key_down",
    "key_up",
@@ -44,7 +50,8 @@ def __init_subclass__(cls, **kwargs):

 class Graphic(BaseGraphic):
    def __init__(
-            self, name: str = None):
+            self, name: str = None
+    ):
        """

        Parameters
@@ -58,10 +65,16 @@ def __init__(
        self.registered_callbacks = dict()
        self.present = PresentFeature(parent=self)

+        # store hex id str of Graphic instance mem location
+        self.loc: str = hex(id(self))
+
    @property
    def world_object(self) -> WorldObject:
-        """Associated pygfx WorldObject."""
-        return self._world_object
+        """Associated pygfx WorldObject. Always returns a proxy, real object cannot be accessed directly."""
+        return weakref.proxy(WORLD_OBJECTS[hex(id(self))])
+
+    def _set_world_object(self, wo: WorldObject):
+        WORLD_OBJECTS[hex(id(self))] = wo

    @property
    def position(self) -> Vector3:
@@ -75,7 +88,7 @@ def visible(self) -> bool:
        return self.world_object.visible

    @visible.setter
-    def visible(self, v) -> bool:
+    def visible(self, v: bool):
        """Access or change the visibility."""
        self.world_object.visible = v

@@ -100,6 +113,9 @@ def __repr__(self):
        else:
            return rval

+    def __del__(self):
+        del WORLD_OBJECTS[self.loc]
+

 class Interaction(ABC):
    """Mixin class that makes graphics interactive"""
@@ -159,7 +175,7 @@ def link(

        """
        if event_type in PYGFX_EVENTS:
-            self.world_object.add_event_handler(self.event_handler, event_type)
+            self.world_object.add_event_handler(self._event_handler, event_type)

        # make sure event is valid
        elif event_type in self.feature_events:
@@ -216,8 +232,13 @@ def _event_handler(self, event):

                    # for now we only have line collections so this works
                    else:
-                        for i, item in enumerate(self._graphics):
-                            if item.world_object is event.pick_info["world_object"]:
+                        # get index of world object that made this event
+                        for i, item in enumerate(self.graphics):
+                            wo = WORLD_OBJECTS[item.loc]
+                            # we only store hex id of worldobject, but worldobject `pick_info` is always the real object
+                            # so if pygfx worldobject triggers an event by itself, such as `click`, etc., this will be
+                            # the real world object in the pick_info and not the proxy
+                            if wo is event.pick_info["world_object"]:
                                indices = i
                    target_info.target._set_feature(feature=target_info.feature, new_data=target_info.new_data, indices=indices)
                else:
@@ -264,22 +285,21 @@ class PreviouslyModifiedData:
    indices: Any


+COLLECTION_GRAPHICS: dict[str, Graphic] = dict()
+
+
 class GraphicCollection(Graphic):
    """Graphic Collection base class"""

    def __init__(self, name: str = None):
        super(GraphicCollection, self).__init__(name)
-        self._graphics: List[Graphic] = list()
-
-    @property
-    def world_object(self) -> Group:
-        """Returns the underling pygfx WorldObject."""
-        return self._world_object
+        self._graphics: List[str] = list()

    @property
    def graphics(self) -> Tuple[Graphic]:
-        """returns the Graphics within this collection"""
-        return tuple(self._graphics)
+        """The Graphics within this collection. Always returns a proxy to the Graphics."""
+        proxies = [weakref.proxy(COLLECTION_GRAPHICS[loc]) for loc in self._graphics]
+        return tuple(proxies)

    def add_graphic(self, graphic: Graphic, reset_index: True):
        """Add a graphic to the collection"""
@@ -289,17 +309,31 @@ def add_graphic(self, graphic: Graphic, reset_index: True):
                f"You can only add {self.child_type} to a {self.__class__.__name__}, "
                f"you are trying to add a {graphic.__class__.__name__}."
            )
-        self._graphics.append(graphic)
+
+        loc = hex(id(graphic))
+        COLLECTION_GRAPHICS[loc] = graphic
+
+        self._graphics.append(loc)
        if reset_index:
            self._reset_index()
        self.world_object.add(graphic.world_object)

    def remove_graphic(self, graphic: Graphic, reset_index: True):
        """Remove a graphic from the collection"""
-        self._graphics.remove(graphic)
+        self._graphics.remove(graphic.loc)
+
        if reset_index:
            self._reset_index()
-        self.world_object.remove(graphic)
+
+        self.world_object.remove(graphic.world_object)
+
+    def __del__(self):
+        self.world_object.clear()
+
+        for loc in self._graphics:
+            del COLLECTION_GRAPHICS[loc]
+
+        super().__del__()

    def _reset_index(self):
        for new_index, graphic in enumerate(self._graphics):
@@ -312,7 +346,7 @@ def __getitem__(self, key):
        if isinstance(key, slice):
            key = cleanup_slice(key, upper_bound=len(self))
            selection_indices = range(key.start, key.stop, key.step)
-            selection = self._graphics[key]
+            selection = self.graphics[key]

        # fancy-ish indexing
        elif isinstance(key, (tuple, list, np.ndarray)):
@@ -324,7 +358,7 @@ def __getitem__(self, key):
            selection = list()

            for ix in key:
-                selection.append(self._graphics[ix])
+                selection.append(self.graphics[ix])

            selection_indices = key
        else:
@@ -365,7 +399,7 @@ def __init__(
        selection_indices: Union[list, range]
            the corresponding indices from the parent GraphicCollection that were selected
        """
-        self._parent = parent
+        self._parent = weakref.proxy(parent)
        self._selection = selection
        self._selection_indices = selection_indices


diff --git a/fastplotlib/graphics/features/_base.py b/fastplotlib/graphics/features/_base.py
@@ -2,9 +2,10 @@
 from inspect import getfullargspec
 from warnings import warn
 from typing import *
+import weakref

 import numpy as np
-from pygfx import Buffer
+from pygfx import Buffer, Texture


 supported_dtypes = [
@@ -71,7 +72,7 @@ def __init__(self, parent, data: Any, collection_index: int = None):
            if part of a collection, index of this graphic within the collection

        """
-        self._parent = parent
+        self._parent = weakref.proxy(parent)

        self._data = to_gpu_supported_dtype(data)

@@ -226,7 +227,7 @@ def _update_range(self, key):

    @property
    @abstractmethod
-    def _buffer(self) -> Buffer:
+    def buffer(self) -> Union[Buffer, Texture]:
        pass

    @property
@@ -238,21 +239,21 @@ def _update_range_indices(self, key):
        key = cleanup_slice(key, self._upper_bound)

        if isinstance(key, int):
-            self._buffer.update_range(key, size=1)
+            self.buffer.update_range(key, size=1)
            return

        # else if it's a slice obj
        if isinstance(key, slice):
            if key.step == 1:  # we cleaned up the slice obj so step of None becomes 1
                # update range according to size using the offset
-                self._buffer.update_range(offset=key.start, size=key.stop - key.start)
+                self.buffer.update_range(offset=key.start, size=key.stop - key.start)

            else:
                step = key.step
                # convert slice to indices
                ixs = range(key.start, key.stop, step)
                for ix in ixs:
-                    self._buffer.update_range(ix, size=1)
+                    self.buffer.update_range(ix, size=1)
        else:
            raise TypeError("must pass int or slice to update range")

diff --git a/fastplotlib/graphics/features/_colors.py b/fastplotlib/graphics/features/_colors.py
@@ -7,11 +7,11 @@

 class ColorFeature(GraphicFeatureIndexable):
    @property
-    def _buffer(self):
+    def buffer(self):
        return self._parent.world_object.geometry.colors

    def __getitem__(self, item):
-        return self._buffer.data[item]
+        return self.buffer.data[item]

    def __init__(self, parent, colors, n_colors: int, alpha: float = 1.0, collection_index: int = None):
        """
@@ -113,7 +113,7 @@ def __setitem__(self, key, value):
                raise ValueError("fancy indexing for colors must be 2-dimension, i.e. [n_datapoints, RGBA]")

            # set the user passed data directly
-            self._buffer.data[key] = value
+            self.buffer.data[key] = value

            # update range
            # first slice obj is going to be the indexing so use key[0]
@@ -162,7 +162,7 @@ def __setitem__(self, key, value):
            else:
                raise ValueError("numpy array passed to color must be of shape (4,) or (n_colors_modify, 4)")

-        self._buffer.data[key] = new_colors
+        self.buffer.data[key] = new_colors

        self._update_range(key)
        self._feature_changed(key, new_colors)
@@ -220,8 +220,8 @@ def __init__(self, parent, cmap: str):
        self.name = cmap

    def _set(self, cmap_name: str):
-        self._parent.world_object.material.map.texture.data[:] = make_colors(256, cmap_name)
-        self._parent.world_object.material.map.texture.update_range((0, 0, 0), size=(256, 1, 1))
+        self._parent.world_object.material.map.data[:] = make_colors(256, cmap_name)
+        self._parent.world_object.material.map.update_range((0, 0, 0), size=(256, 1, 1))
        self.name = cmap_name

        self._feature_changed(key=None, new_data=self.name)
@@ -246,8 +246,8 @@ class HeatmapCmapFeature(ImageCmapFeature):
    """

    def _set(self, cmap_name: str):
-        self._parent._material.map.texture.data[:] = make_colors(256, cmap_name)
-        self._parent._material.map.texture.update_range((0, 0, 0), size=(256, 1, 1))
+        self._parent._material.map.data[:] = make_colors(256, cmap_name)
+        self._parent._material.map.update_range((0, 0, 0), size=(256, 1, 1))
        self.name = cmap_name

        self._feature_changed(key=None, new_data=self.name)