graphic features refactor

[kushalkolar]

See #511 , I accidentally merged this into main 🤦‍♂️

[kushalkolar]

Working on this, Graphic features should have no access to collection_index. When we emit events, we can have the graphic accessible and then the collection index of the graphic can be accessed if required.

[kushalkolar]

ok so PointsDataFeature working, and we have negative and multi-dim slicing now 🥳

[kushalkolar]

I should double check to make sure we don't get any off by 1 errors in the slicing and with size in update_range

[kushalkolar]

Ideas for event adding:

# graphic base class
Graphic:
  def add_event_handler(func, "event-name")

Where "event-name" is either a feature name or pygfx event name (ex: "click" etc.). And emitted feature events use a pick_info dict that holds event information just like pygfx events. Might make sense to subclass pygfx.Event here for feature events, will see.

[kushalkolar]

@almarklein I've arrived at this parser that takes the key used to index the buffer and auto determines the offset & size to mark for upload, do you think this would be useful to have directly in pygfx?

snippet:

    def _update_range(self, key: int | slice | np.ndarray[int | bool] | list[bool | int] | tuple[slice, ...]):
        """
        Uses key from slicing to determine the offset and
        size of the buffer to mark for upload to the GPU
        """
        # number of elements in the buffer
        upper_bound = self.value.shape[0]

        if isinstance(key, tuple):
            # if multiple dims are sliced, we only need the key for
            # the first dimension corresponding to n_datapoints
            key: int | np.ndarray[int | bool] | slice = key[0]

        if isinstance(key, int):
            # simplest case
            offset = key
            size = 1

        elif isinstance(key, slice):
            # parse slice
            start, stop, step = key.indices(upper_bound)

            # account for backwards indexing
            if (start > stop) and step < 0:
                offset = stop
            else:
                offset = start

            # slice.indices will give -1 if None is passed
            # which just means 0 here since buffers do not
            # use negative indexing
            offset = max(0, offset)

            # number of elements to upload
            # this is indexing so do not add 1
            size = abs(stop - start)

        elif isinstance(key, (np.ndarray, list)):
            if isinstance(key, list):
                # convert to array
                key = np.array(key)

            if not key.ndim == 1:
                raise TypeError(key)

            if key.dtype == bool:
                # convert bool mask to integer indices
                key = np.nonzero(key)[0]

            if not np.issubdtype(key.dtype, np.integer):
                # fancy indexing doesn't make sense with non-integer types
                raise TypeError(key)

            if key.size < 1:
                # nothing to update
                return

            # convert any negative integer indices to positive indices
            key %= upper_bound

            # index of first element to upload
            offset = key.min()

            # number of elements to upload
            # add 1 because this is direct
            # passing of indices, not a start:stop
            size = np.ptp(key) + 1

        else:
            raise TypeError(key)

        self.buffer.update_range(offset=offset, size=size)

[kushalkolar]

I need to do a thing in the tests where we just draw frames on demand to test that the right things are in buffer._gfx_pending_uploads, and that after a frame is draw this list is cleared and take a screenshot and see that it looks right.

[clewis7]

Started reviewing things...

Things with lines appear to be working well - shared buffers, event handling

Images are a bit wonking - updating data, changing cmap, etc.

[clewis7]

Suggested change

	| graphic | Graphic | graphic instance that the event is from |
	| graphic | Graphic | graphic instance that emitted the event |

[kushalkolar]

Thought from Billy: make the simplest use cases default kwargs, ex: uniform_colors for line and scatter.

[clewis7]

Adding a LinearRegionSelector to an ImageGraphic has a default fill that is solid:

Especially now that heatmap is part of ImageGraphic, we should pass the fill so that it is transparent, just so then you can see the data that you are selecting

[clewis7]

TODO: need to fix HLUT in ImageWidget to mirror changes in LinearRegionSelector

[clewis7]

In a previous example with lines we had setting the cmap_values from a list, with this change we would no longer be supporting

for now, I changed the example to just cast the list to an array

[kushalkolar]

see if this can reopen

Edit: apparently not