, "
+ f"you have passed a: <{type(frame_apply)}>"
+ )
+
+ # current_index stores {dimension_index: slice_index} for every dimension
+ self._current_index: dict[str, int] = {sax: 0 for sax in self.slider_dims}
+
+ self._window_funcs = None
+ self.window_funcs = window_funcs
+
+ # get max bound for all data arrays for all slider dimensions and ensure compatibility across slider dims
+ self._dims_max_bounds: dict[str, int] = {k: 0 for k in self.slider_dims}
+ for i, _dim in enumerate(list(self._dims_max_bounds.keys())):
+ for array, partition in zip(self.data, self.n_scrollable_dims):
+ if partition <= i:
+ continue
+ else:
+ if 0 < self._dims_max_bounds[_dim] != array.shape[i]:
+ raise ValueError(f"Two arrays differ along dimension {_dim}")
+ else:
+ self._dims_max_bounds[_dim] = max(
+ self._dims_max_bounds[_dim], array.shape[i]
+ )
+
+ figure_kwargs_default = {"controller_ids": "sync", "names": names}
+
+ # update the default kwargs with any user-specified kwargs
+ # user specified kwargs will overwrite the defaults
+ figure_kwargs_default.update(figure_kwargs)
+ figure_kwargs_default["shape"] = figure_shape
+
+ if graphic_kwargs is None:
+ graphic_kwargs = dict()
+
+ graphic_kwargs.update({"cmap": cmap})
+
+ vmin_specified, vmax_specified = None, None
+ if "vmin" in graphic_kwargs.keys():
+ vmin_specified = graphic_kwargs.pop("vmin")
+ if "vmax" in graphic_kwargs.keys():
+ vmax_specified = graphic_kwargs.pop("vmax")
+
+ self._figure: Figure = Figure(**figure_kwargs_default)
+
+ self._histogram_widget = histogram_widget
+ for data_ix, (d, subplot) in enumerate(zip(self.data, self.figure)):
+
+ frame = self._process_indices(d, slice_indices=self._current_index)
+ frame = self._process_frame_apply(frame, data_ix)
+
+ if (vmin_specified is None) or (vmax_specified is None):
+ # if either vmin or vmax are not specified, calculate an estimate by subsampling
+ vmin_estimate, vmax_estimate = quick_min_max(d)
+
+ # decide vmin, vmax passed to ImageGraphic constructor based on whether it's user specified or now
+ if vmin_specified is None:
+ # user hasn't specified vmin, use estimated value
+ vmin = vmin_estimate
+ else:
+ # user has provided a specific value, use that
+ vmin = vmin_specified
+
+ if vmax_specified is None:
+ vmax = vmax_estimate
+ else:
+ vmax = vmax_specified
+ else:
+ # both vmin and vmax are specified
+ vmin, vmax = vmin_specified, vmax_specified
+
+ ig = ImageGraphic(
+ frame,
+ name="image_widget_managed",
+ vmin=vmin,
+ vmax=vmax,
+ **graphic_kwargs,
+ )
+ subplot.add_graphic(ig)
+
+ if self._histogram_widget:
+ hlut = HistogramLUTTool(data=d, image_graphic=ig, name="histogram_lut")
+
+ subplot.docks["right"].add_graphic(hlut)
+ subplot.docks["right"].size = 80
+ subplot.docks["right"].auto_scale(maintain_aspect=False)
+ subplot.docks["right"].controller.enabled = False
+
+ # hard code the expected height so that the first render looks right in tests, docs etc.
+ if len(self.slider_dims) == 0:
+ ui_size = 57
+ if len(self.slider_dims) == 1:
+ ui_size = 106
+ elif len(self.slider_dims) == 2:
+ ui_size = 155
+
+ self._image_widget_sliders = ImageWidgetSliders(
+ figure=self.figure,
+ size=ui_size,
+ location="bottom",
+ title="ImageWidget Controls",
+ image_widget=self,
+ )
+
+ self.figure.add_gui(self._image_widget_sliders)
+
+ self._current_index_changed_handlers = set()
+
+ self._reentrant_block = False
+
+ self._initialized = True
+
+ @property
+ def frame_apply(self) -> dict | None:
+ return self._frame_apply
+
+ @frame_apply.setter
+ def frame_apply(self, frame_apply: dict[int, callable]):
+ if frame_apply is None:
+ frame_apply = dict()
+
+ self._frame_apply = frame_apply
+ # force update image graphic
+ self.current_index = self.current_index
+
+ @property
+ def window_funcs(self) -> dict[str, _WindowFunctions]:
+ """
+ Get or set the window functions
+
+ Returns
+ -------
+ Dict[str, _WindowFunctions]
+
+ """
+ return self._window_funcs
+
+ @window_funcs.setter
+ def window_funcs(self, callable_dict: dict[str, int]):
+ if callable_dict is None:
+ self._window_funcs = None
+ # force frame to update
+ self.current_index = self.current_index
+ return
+
+ elif isinstance(callable_dict, dict):
+ if not set(callable_dict.keys()).issubset(ALLOWED_WINDOW_DIMS):
+ raise ValueError(
+ f"The only allowed keys to window funcs are {list(ALLOWED_WINDOW_DIMS)} "
+ f"Your window func passed in these keys: {list(callable_dict.keys())}"
+ )
+ if not all(
+ [
+ isinstance(_callable_dict, tuple)
+ for _callable_dict in callable_dict.values()
+ ]
+ ):
+ raise TypeError(
+ "dict argument to `window_funcs` must be in the form of: "
+ "`{dimension: (func, window_size)}`. "
+ "See the docstring."
+ )
+ for v in callable_dict.values():
+ if not callable(v[0]):
+ raise TypeError(
+ "dict argument to `window_funcs` must be in the form of: "
+ "`{dimension: (func, window_size)}`. "
+ "See the docstring."
+ )
+ if not isinstance(v[1], int):
+ raise TypeError(
+ f"dict argument to `window_funcs` must be in the form of: "
+ "`{dimension: (func, window_size)}`. "
+ f"where window_size is integer. you passed in {v[1]} for window_size"
+ )
+
+ if not isinstance(self._window_funcs, dict):
+ self._window_funcs = dict()
+
+ for k in list(callable_dict.keys()):
+ self._window_funcs[k] = _WindowFunctions(self, *callable_dict[k])
+
+ else:
+ raise TypeError(
+ f"`window_funcs` must be either Nonetype or dict."
+ f"You have passed a {type(callable_dict)}. See the docstring."
+ )
+
+ # force frame to update
+ self.current_index = self.current_index
+
+ def _process_indices(
+ self, array: np.ndarray, slice_indices: dict[str, int]
+ ) -> np.ndarray:
+ """
+ Get the 2D array from the given slice indices. If not returning a 2D slice (such as due to window_funcs)
+ then `frame_apply` must take this output and return a 2D array
+
+ Parameters
+ ----------
+ array: np.ndarray
+ array-like to get a 2D slice from
+
+ slice_indices: Dict[str, int]
+ dict in form of {dimension_index: current_index}
+ For example if an array has shape [1000, 30, 512, 512] corresponding to [t, z, x, y]:
+ To get the 100th timepoint and 3rd z-plane pass:
+ {"t": 100, "z": 3}
+
+ Returns
+ -------
+ np.ndarray
+ array-like, 2D slice
+
+ """
+
+ data_ix = None
+ for i in range(len(self.data)):
+ if self.data[i] is array:
+ data_ix = i
+ break
+
+ numerical_dims = list()
+
+ # Totally number of dimensions for this specific array
+ curr_ndim = self.data[data_ix].ndim
+
+ # Initialize slices for each dimension of array
+ indexer = [slice(None)] * curr_ndim
+
+ # Maps from n_scrollable_dims to one of "", "t", "tz", etc.
+ curr_scrollable_format = SCROLLABLE_DIMS_ORDER[self.n_scrollable_dims[data_ix]]
+ for dim in list(slice_indices.keys()):
+ if dim not in curr_scrollable_format:
+ continue
+ # get axes order for that specific array
+ numerical_dim = curr_scrollable_format.index(dim)
+
+ indices_dim = slice_indices[dim]
+
+ # takes care of index selection (window slicing) for this specific axis
+ indices_dim = self._get_window_indices(data_ix, numerical_dim, indices_dim)
+
+ # set the indices for this dimension
+ indexer[numerical_dim] = indices_dim
+
+ numerical_dims.append(numerical_dim)
+
+ # apply indexing to the array
+ # use window function is given for this dimension
+ if self.window_funcs is not None:
+ a = array
+ for i, dim in enumerate(sorted(numerical_dims)):
+ dim_str = curr_scrollable_format[dim]
+ dim = dim - i # since we loose a dimension every iteration
+ _indexer = [slice(None)] * (curr_ndim - i)
+ _indexer[dim] = indexer[dim + i]
+
+ # if the indexer is an int, this dim has no window func
+ if isinstance(_indexer[dim], int):
+ a = a[tuple(_indexer)]
+ else:
+ # if the indices are from `self._get_window_indices`
+ func = self.window_funcs[dim_str].func
+ window = a[tuple(_indexer)]
+ a = func(window, axis=dim)
+ return a
+ else:
+ return array[tuple(indexer)]
+
+ def _get_window_indices(self, data_ix, dim, indices_dim):
+ if self.window_funcs is None:
+ return indices_dim
+
+ else:
+ ix = indices_dim
+
+ dim_str = SCROLLABLE_DIMS_ORDER[self.n_scrollable_dims[data_ix]][dim]
+
+ # if no window stuff specified for this dim
+ if dim_str not in self.window_funcs.keys():
+ return indices_dim
+
+ # if window stuff is set to None for this dim
+ # example: {"t": None}
+ if self.window_funcs[dim_str] is None:
+ return indices_dim
+
+ window_size = self.window_funcs[dim_str].window_size
+
+ if (window_size == 0) or (window_size is None):
+ return indices_dim
+
+ half_window = int((window_size - 1) / 2) # half-window size
+ # get the max bound for that dimension
+ max_bound = self._dims_max_bounds[dim_str]
+ indices_dim = range(
+ max(0, ix - half_window), min(max_bound, ix + half_window)
+ )
+ return indices_dim
+
+ def _process_frame_apply(self, array, data_ix) -> np.ndarray:
+ if callable(self._frame_apply):
+ return self._frame_apply(array)
+
+ if data_ix not in self._frame_apply.keys():
+ return array
+
+ elif self._frame_apply[data_ix] is not None:
+ return self._frame_apply[data_ix](array)
+
+ return array
+
+ def add_event_handler(self, handler: callable, event: str = "current_index"):
+ """
+ Register an event handler.
+
+ Currently the only event that ImageWidget supports is "current_index". This event is
+ emitted whenever the index of the ImageWidget changes.
+
+ Parameters
+ ----------
+ handler: callable
+ callback function, must take a dict as the only argument. This dict will be the `current_index`
+
+ event: str, "current_index"
+ the only supported event is "current_index"
+
+ Example
+ -------
+
+ .. code-block:: py
+
+ def my_handler(index):
+ print(index)
+ # example prints: {"t": 100} if data has only time dimension
+ # "z" index will be another key if present in the data, ex: {"t": 100, "z": 5}
+
+ # create an image widget
+ iw = ImageWidget(...)
+
+ # add event handler
+ iw.add_event_handler(my_handler)
+
+ """
+ if event != "current_index":
+ raise ValueError(
+ "`current_index` is the only event supported by `ImageWidget`"
+ )
+
+ self._current_index_changed_handlers.add(handler)
+
+ def remove_event_handler(self, handler: callable):
+ """Remove a registered event handler"""
+ self._current_index_changed_handlers.remove(handler)
+
+ def clear_event_handlers(self):
+ """Clear all registered event handlers"""
+ self._current_index_changed_handlers.clear()
+
+ def reset_vmin_vmax(self):
+ """
+ Reset the vmin and vmax w.r.t. the full data
+ """
+ for data, subplot in zip(self.data, self.figure):
+ if "histogram_lut" not in subplot.docks["right"]:
+ continue
+ hlut = subplot.docks["right"]["histogram_lut"]
+ hlut.set_data(data, reset_vmin_vmax=True)
+
+ def reset_vmin_vmax_frame(self):
+ """
+ Resets the vmin vmax and HistogramLUT widgets w.r.t. the current data shown in the
+ ImageGraphic instead of the data in the full data array. For example, if a post-processing
+ function is used, the range of values in the ImageGraphic can be very different from the
+ range of values in the full data array.
+
+ TODO: We could think of applying the frame_apply funcs to a subsample of the entire array to get a better estimate of vmin vmax?
+ """
+
+ for subplot in self.figure:
+ if "histogram_lut" not in subplot.docks["right"]:
+ continue
+
+ hlut = subplot.docks["right"]["histogram_lut"]
+ # set the data using the current image graphic data
+ hlut.set_data(subplot["image_widget_managed"].data.value)
+
+ def set_data(
+ self,
+ new_data: np.ndarray | list[np.ndarray],
+ reset_vmin_vmax: bool = True,
+ reset_indices: bool = True,
+ ):
+ """
+ Change data of widget. Note: sliders max currently update only for ``txy`` and ``tzxy`` data.
+
+ Parameters
+ ----------
+ new_data: array-like or list of array-like
+ The new data to display in the widget
+
+ reset_vmin_vmax: bool, default ``True``
+ reset the vmin vmax levels based on the new data
+
+ reset_indices: bool, default ``True``
+ reset the current index for all dimensions to 0
+
+ """
+
+ if reset_indices:
+ for key in self.current_index:
+ self.current_index[key] = 0
+
+ # set slider max according to new data
+ max_lengths = dict()
+ for scroll_dim in self.slider_dims:
+ max_lengths[scroll_dim] = np.inf
+
+ if _is_arraylike(new_data):
+ new_data = [new_data]
+
+ if len(self._data) != len(new_data):
+ raise ValueError(
+ f"number of new data arrays {len(new_data)} must match"
+ f" current number of data arrays {len(self._data)}"
+ )
+ # check all arrays
+ for i, (new_array, current_array) in enumerate(zip(new_data, self._data)):
+ if new_array.ndim != current_array.ndim:
+ raise ValueError(
+ f"new data ndim {new_array.ndim} at index {i} "
+ f"does not equal current data ndim {current_array.ndim}"
+ )
+
+ # Computes the number of scrollable dims and also validates new_array
+ new_scrollable_dims = self._get_n_scrollable_dims(new_array, self._rgb[i])
+
+ if self.n_scrollable_dims[i] != new_scrollable_dims:
+ raise ValueError(
+ f"number of dimensions of data arrays must match number of dimensions of "
+ f"existing data arrays"
+ )
+
+ # if checks pass, update with new data
+ for i, (new_array, current_array, subplot) in enumerate(
+ zip(new_data, self._data, self.figure)
+ ):
+ # check last two dims (x and y) to see if data shape is changing
+ old_data_shape = self._data[i].shape[-self.n_img_dims[i] :]
+ self._data[i] = new_array
+
+ if old_data_shape != new_array.shape[-self.n_img_dims[i] :]:
+ frame = self._process_indices(
+ new_array, slice_indices=self._current_index
+ )
+ frame = self._process_frame_apply(frame, i)
+
+ # make new graphic first
+ new_graphic = ImageGraphic(data=frame, name="image_widget_managed")
+
+ if self._histogram_widget:
+ # set hlut tool to use new graphic
+ subplot.docks["right"]["histogram_lut"].image_graphic = new_graphic
+
+ # delete old graphic after setting hlut tool to new graphic
+ # this ensures gc
+ subplot.delete_graphic(graphic=subplot["image_widget_managed"])
+ subplot.insert_graphic(graphic=new_graphic)
+
+ # Returns "", "t", or "tz"
+ curr_scrollable_format = SCROLLABLE_DIMS_ORDER[self.n_scrollable_dims[i]]
+
+ for scroll_dim in self.slider_dims:
+ if scroll_dim in curr_scrollable_format:
+ new_length = new_array.shape[
+ curr_scrollable_format.index(scroll_dim)
+ ]
+ if max_lengths[scroll_dim] == np.inf:
+ max_lengths[scroll_dim] = new_length
+ elif max_lengths[scroll_dim] != new_length:
+ raise ValueError(
+ f"New arrays have differing values along dim {scroll_dim}"
+ )
+
+ self._dims_max_bounds[scroll_dim] = max_lengths[scroll_dim]
+
+ # set histogram widget
+ if self._histogram_widget:
+ subplot.docks["right"]["histogram_lut"].set_data(
+ new_array, reset_vmin_vmax=reset_vmin_vmax
+ )
+
+ # force graphics to update
+ self.current_index = self.current_index
+
+ def show(self, **kwargs):
+ """
+ Show the widget.
+
+ Parameters
+ ----------
+
+ kwargs: Any
+ passed to `Figure.show()`
+
+ Returns
+ -------
+ BaseRenderCanvas
+ In Qt or GLFW, the canvas window containing the Figure will be shown.
+ In jupyter, it will display the plot in the output cell or sidecar.
+
+ """
+
+ return self.figure.show(**kwargs)
+
+ def close(self):
+ """Close Widget"""
+ self.figure.close()
diff --git a/pyproject.toml b/pyproject.toml
index 4d957aee3..216b4ab46 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,3 +1,84 @@
+# ===== Project info
+
+[project]
+dynamic = ["version"]
+name = "fastplotlib"
+description = "Next-gen fast plotting library running on WGPU using the Pygfx rendering engine "
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [{ name = "Kushal Kolar" }, { name = "Caitlin Lewis" }]
+keywords = [
+ "visualization",
+ "science",
+ "interactive",
+ "pygfx",
+ "webgpu",
+ "wgpu",
+ "vulkan",
+ "gpu",
+]
+requires-python = ">= 3.10"
+dependencies = [
+ "numpy>=1.23.0",
+ "pygfx==0.10.0",
+ "wgpu>=0.20.0",
+ "cmap>=0.1.3",
+ # (this comment keeps this list multiline in VSCode)
+]
+
+[project.optional-dependencies]
+docs = [
+ "sphinx",
+ "sphinx-gallery",
+ "pydata-sphinx-theme",
+ "glfw",
+ "ipywidgets>=8.0.0,<9",
+ "sphinx-copybutton",
+ "sphinx-design",
+ "pandoc",
+ "imageio[ffmpeg]",
+ "matplotlib",
+ "scikit-learn",
+]
+notebook = [
+ "jupyterlab",
+ "jupyter-rfb>=0.5.1",
+ "ipywidgets>=8.0.0,<9",
+ "sidecar",
+]
+tests = [
+ "pytest",
+ "nbmake",
+ "black",
+ "scipy",
+ "imageio[ffmpeg]",
+ "scikit-learn",
+ "tqdm",
+]
+imgui = ["imgui-bundle"]
+dev = ["fastplotlib[docs,notebook,tests,imgui]"]
+
+[project.urls]
+Homepage = "https://www.fastplotlib.org/"
+Documentation = "https://www.fastplotlib.org/"
+Repository = "https://github.com/fastplotlib/fastplotlib"
+
+# ===== Building
+
[build-system]
-requires = ["setuptools", "wheel"]
+requires = ["flit_core >=3.2,<4"]
+build-backend = "flit_core.buildapi"
+
+# ===== Tooling
+
+# [tool.ruff]
+# line-length = 88
+# [tool.ruff.lint]
+# select = ["F", "E", "W", "N", "B", "RUF", "TC"]
+# ignore = [
+# "E501", # Line too long
+# "E731", # Do not assign a `lambda` expression, use a `def`
+# "B019", # Use of `functools.lru_cache` or `functools.cache` on methods can lead to memory leaks
+# "RUF012", # Mutable class attributes should be annotated with `typing.ClassVar`"
+# ]
diff --git a/requirements.txt b/requirements.txt
deleted file mode 100644
index d0bc814f2..000000000
--- a/requirements.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-numpy
-jupyterlab
-jupyter_rfb
-pygfx>=0.1.10
-imageio
\ No newline at end of file
diff --git a/scripts/generate_add_graphic_methods.py b/scripts/generate_add_graphic_methods.py
new file mode 100644
index 000000000..85e0be669
--- /dev/null
+++ b/scripts/generate_add_graphic_methods.py
@@ -0,0 +1,90 @@
+import inspect
+import pathlib
+
+import black
+
+root = pathlib.Path(__file__).parent.parent.resolve()
+filename = root.joinpath("fastplotlib", "layouts", "_graphic_methods_mixin.py")
+
+# if there is an existing mixin class, replace it with an empty class
+# so that fastplotlib will import
+# hacky but it works
+with open(filename, "w") as f:
+ f.write(f"class GraphicMethodsMixin:\n" f" pass")
+
+from fastplotlib import graphics
+
+
+modules = list()
+
+for name, obj in inspect.getmembers(graphics):
+ if inspect.isclass(obj):
+ modules.append(obj)
+
+
+def generate_add_graphics_methods():
+ # clear file and regenerate from scratch
+ f = open(filename, "w", encoding="utf-8")
+
+ f.write("# This is an auto-generated file and should not be modified directly\n\n")
+
+ f.write("from typing import *\n\n")
+ f.write("import numpy\n\n")
+ f.write("from ..graphics import *\n")
+ f.write("from ..graphics._base import Graphic\n\n")
+
+ f.write("\nclass GraphicMethodsMixin:\n")
+
+ f.write(
+ " def _create_graphic(self, graphic_class, *args, **kwargs) -> Graphic:\n"
+ )
+ f.write(" if 'center' in kwargs.keys():\n")
+ f.write(" center = kwargs.pop('center')\n")
+ f.write(" else:\n")
+ f.write(" center = False\n\n")
+ f.write(" if 'name' in kwargs.keys():\n")
+ f.write(" self._check_graphic_name_exists(kwargs['name'])\n\n")
+ f.write(" graphic = graphic_class(*args, **kwargs)\n")
+ f.write(" self.add_graphic(graphic, center=center)\n\n")
+ f.write(" return graphic\n\n")
+
+ for m in modules:
+ cls = m
+ if cls.__name__ == "Graphic":
+ # skip base class
+ continue
+ method_name = cls.type
+
+ class_args = inspect.getfullargspec(cls)[0][1:]
+ class_args = [arg + ", " for arg in class_args]
+ s = ""
+ for a in class_args:
+ s += a
+
+ f.write(
+ f" def add_{method_name}{inspect.signature(cls.__init__)} -> {cls.__name__}:\n"
+ )
+ f.write(' """\n')
+ f.write(f" {cls.__init__.__doc__}\n")
+ f.write(' """\n')
+ f.write(
+ f" return self._create_graphic({cls.__name__}, {s} **kwargs)\n\n"
+ )
+
+ f.close()
+
+
+def blacken():
+ with open(filename, "r", encoding="utf-8") as f:
+ text = f.read()
+
+ mode = black.FileMode(line_length=88)
+ text = black.format_str(text, mode=mode)
+
+ with open(filename, "w", encoding="utf-8") as f:
+ f.write(text)
+
+
+if __name__ == "__main__":
+ generate_add_graphics_methods()
+ blacken()
diff --git a/setup.py b/setup.py
deleted file mode 100644
index f7195461c..000000000
--- a/setup.py
+++ /dev/null
@@ -1,90 +0,0 @@
-from setuptools import setup, find_packages
-from pathlib import Path
-
-
-install_requires = [
- "numpy>=1.23.0",
- "pygfx>=0.1.14",
-]
-
-
-extras_require = {
- "docs": [
- "sphinx",
- "furo",
- "glfw",
- "jupyter-rfb>=0.4.1", # required so ImageWidget docs show up
- "ipywidgets>=8.0.0,<9",
- "sphinx-copybutton",
- "sphinx-design",
- "nbsphinx",
- "pandoc",
- "jupyterlab",
- "sidecar"
- ],
-
- "notebook":
- [
- "jupyterlab",
- "jupyter-rfb>=0.4.1",
- "ipywidgets>=8.0.0,<9",
- "sidecar"
- ],
-
- "tests":
- [
- "pytest",
- "nbmake",
- "scipy",
- "imageio",
- "jupyterlab",
- "jupyter-rfb>=0.4.1",
- "ipywidgets>=8.0.0,<9",
- "scikit-learn",
- "tqdm",
- "sidecar"
- ],
-
- "tests-desktop":
- [
- "pytest",
- "scipy",
- "imageio",
- "scikit-learn",
- "tqdm",
- ]
-}
-
-
-with open(Path(__file__).parent.joinpath("README.md")) as f:
- readme = f.read()
-
-with open(Path(__file__).parent.joinpath("fastplotlib", "VERSION"), "r") as f:
- ver = f.read().split("\n")[0]
-
-
-classifiers = [
- "Programming Language :: Python :: 3",
- "Topic :: Scientific/Engineering :: Visualization",
- "License :: OSI Approved :: Apache Software License",
- "Intended Audience :: Science/Research",
-]
-
-
-setup(
- name='fastplotlib',
- version=ver,
- long_description=readme,
- long_description_content_type='text/markdown',
- packages=find_packages(),
- url='https://github.com/fastplotlib/fastplotlib',
- license='Apache 2.0',
- author='Kushal Kolar, Caitlin Lewis',
- author_email='',
- python_requires='>=3.9',
- install_requires=install_requires,
- extras_require=extras_require,
- include_package_data=True,
- description='A fast plotting library built using the pygfx render engine'
-)
-
diff --git a/examples/desktop/gridplot/__init__.py b/tests/__init__.py
similarity index 100%
rename from examples/desktop/gridplot/__init__.py
rename to tests/__init__.py
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 000000000..3f5414a71
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,8 @@
+import pygfx
+
+
+MAX_TEXTURE_SIZE = 1024
+
+
+def pytest_sessionstart(session):
+ pygfx.renderers.wgpu.set_wgpu_limits(**{"max-texture-dimension-2d": MAX_TEXTURE_SIZE})
diff --git a/tests/events.py b/tests/events.py
new file mode 100644
index 000000000..e9b212adb
--- /dev/null
+++ b/tests/events.py
@@ -0,0 +1,91 @@
+from functools import partial
+import pytest
+import numpy as np
+from numpy import testing as npt
+import pygfx
+
+import fastplotlib as fpl
+from fastplotlib.graphics.features import GraphicFeatureEvent
+
+
+def make_positions_data() -> np.ndarray:
+ xs = np.linspace(0, 10 * np.pi, 10)
+ ys = np.sin(xs)
+ return np.column_stack([xs, ys])
+
+
+def make_line_graphic() -> fpl.LineGraphic:
+ return fpl.LineGraphic(make_positions_data())
+
+
+def make_scatter_graphic() -> fpl.ScatterGraphic:
+ return fpl.ScatterGraphic(make_positions_data())
+
+
+event_instance: GraphicFeatureEvent = None
+
+
+def event_handler(event):
+ global event_instance
+ event_instance = event
+
+
+decorated_event_instance: GraphicFeatureEvent = None
+
+
+@pytest.mark.parametrize("graphic", [make_line_graphic(), make_scatter_graphic()])
+def test_positions_data_event(graphic: fpl.LineGraphic | fpl.ScatterGraphic):
+ global decorated_event_instance
+ global event_instance
+
+ value = np.cos(np.linspace(0, 10 * np.pi, 10))[3:8]
+
+ info = {"key": (slice(3, 8, None), 1), "value": value}
+
+ expected = GraphicFeatureEvent(type="data", info=info)
+
+ def validate(graphic, handler, expected_feature_event, event_to_test):
+ assert expected_feature_event.type == event_to_test.type
+ assert expected_feature_event.info["key"] == event_to_test.info["key"]
+
+ npt.assert_almost_equal(
+ expected_feature_event.info["value"], event_to_test.info["value"]
+ )
+
+ # should only have one event handler
+ assert graphic._event_handlers["data"] == {handler}
+
+ # make sure wrappers are correct
+ wrapper_map = tuple(graphic._event_handler_wrappers["data"])[0]
+ assert wrapper_map[0] is handler
+ assert isinstance(wrapper_map[1], partial)
+ assert wrapper_map[1].func == graphic._handle_event
+ assert wrapper_map[1].args[0] is handler
+
+ # test remove handler
+ graphic.remove_event_handler(handler, "data")
+ assert len(graphic._event_handlers["click"]) == 0
+ assert len(graphic._event_handler_wrappers["click"]) == 0
+ assert len(graphic.world_object._event_handlers["click"]) == 0
+
+ # reset data
+ graphic.data[:, :-1] = make_positions_data()
+ event_to_test = None
+
+ # test decorated function
+ @graphic.add_event_handler("data")
+ def decorated_handler(event):
+ global decorated_event_instance
+ decorated_event_instance = event
+
+ # test decorated
+ graphic.data[3:8, 1] = value
+ validate(graphic, decorated_handler, expected, decorated_event_instance)
+
+ # test regular
+ graphic.add_event_handler(event_handler, "data")
+ graphic.data[3:8, 1] = value
+
+ validate(graphic, event_handler, expected, event_instance)
+
+ event_instance = None
diff --git a/tests/test_colors_buffer_manager.py b/tests/test_colors_buffer_manager.py
new file mode 100644
index 000000000..7b1aef16a
--- /dev/null
+++ b/tests/test_colors_buffer_manager.py
@@ -0,0 +1,240 @@
+import numpy as np
+from numpy import testing as npt
+import pytest
+
+import pygfx
+
+import fastplotlib as fpl
+from fastplotlib.graphics.features import VertexColors, GraphicFeatureEvent
+from .utils import (
+ generate_slice_indices,
+ generate_color_inputs,
+ generate_positions_spiral_data,
+)
+
+
+def make_colors_buffer() -> VertexColors:
+ colors = VertexColors(colors="w", n_colors=10)
+ return colors
+
+
+EVENT_RETURN_VALUE: GraphicFeatureEvent = None
+
+
+def event_handler(ev):
+ global EVENT_RETURN_VALUE
+ EVENT_RETURN_VALUE = ev
+
+
+@pytest.mark.parametrize(
+ "color_input",
+ [
+ *generate_color_inputs("r"),
+ *generate_color_inputs("g"),
+ *generate_color_inputs("b"),
+ ],
+)
+def test_create_buffer(color_input):
+ colors = VertexColors(colors=color_input, n_colors=10)
+ truth = np.repeat([pygfx.Color(color_input)], 10, axis=0)
+ npt.assert_almost_equal(colors[:], truth)
+
+
+@pytest.mark.parametrize("test_graphic", [False, "line", "scatter"])
+def test_int(test_graphic):
+ # setting single points
+ if test_graphic:
+ fig = fpl.Figure()
+
+ data = generate_positions_spiral_data("xyz")
+ if test_graphic == "line":
+ graphic = fig[0, 0].add_line(data=data)
+
+ elif test_graphic == "scatter":
+ graphic = fig[0, 0].add_scatter(data=data)
+
+ colors = graphic.colors
+ global EVENT_RETURN_VALUE
+ graphic.add_event_handler(event_handler, "colors")
+ else:
+ colors = make_colors_buffer()
+
+ # TODO: placeholder until I make a testing figure where we draw frames only on call
+ colors[3] = "r"
+ npt.assert_almost_equal(colors[3], [1.0, 0.0, 0.0, 1.0])
+
+ if test_graphic:
+ # test event
+ assert isinstance(EVENT_RETURN_VALUE, GraphicFeatureEvent)
+ assert EVENT_RETURN_VALUE.graphic == graphic
+ assert EVENT_RETURN_VALUE.target is graphic.world_object
+ assert EVENT_RETURN_VALUE.info["key"] == 3
+ npt.assert_almost_equal(
+ EVENT_RETURN_VALUE.info["value"], np.array([[1, 0, 0, 1]])
+ )
+ assert EVENT_RETURN_VALUE.info["user_value"] == "r"
+
+ colors[6] = [0.0, 1.0, 1.0, 1.0]
+ npt.assert_almost_equal(colors[6], [0.0, 1.0, 1.0, 1.0])
+
+ colors[7] = (0.0, 1.0, 1.0, 1.0)
+ npt.assert_almost_equal(colors[6], [0.0, 1.0, 1.0, 1.0])
+
+ colors[8] = np.array([1, 0, 1, 1])
+ npt.assert_almost_equal(colors[8], [1.0, 0.0, 1.0, 1.0])
+
+ colors[2] = [1, 0, 1, 0.5]
+ npt.assert_almost_equal(colors[2], [1.0, 0.0, 1.0, 0.5])
+
+
+@pytest.mark.parametrize("test_graphic", [False, "line", "scatter"])
+@pytest.mark.parametrize(
+ "slice_method", [generate_slice_indices(i) for i in range(0, 16)]
+)
+def test_tuple(test_graphic, slice_method):
+ # setting entire array manually
+ if test_graphic:
+ fig = fpl.Figure()
+
+ data = generate_positions_spiral_data("xyz")
+ if test_graphic == "line":
+ graphic = fig[0, 0].add_line(data=data)
+
+ elif test_graphic == "scatter":
+ graphic = fig[0, 0].add_scatter(data=data)
+
+ colors = graphic.colors
+ global EVENT_RETURN_VALUE
+ graphic.add_event_handler(event_handler, "colors")
+ else:
+ colors = make_colors_buffer()
+
+ s = slice_method["slice"]
+ indices = slice_method["indices"]
+ others = slice_method["others"]
+
+ # set all RGBA vals
+ colors[s, :] = 0.5
+ truth = np.repeat([[0.5, 0.5, 0.5, 0.5]], repeats=len(indices), axis=0)
+ npt.assert_almost_equal(colors[indices], truth)
+
+ if test_graphic:
+ # test event
+ assert isinstance(EVENT_RETURN_VALUE, GraphicFeatureEvent)
+ assert EVENT_RETURN_VALUE.graphic == graphic
+ assert EVENT_RETURN_VALUE.target is graphic.world_object
+ assert EVENT_RETURN_VALUE.info["key"] == (s, slice(None))
+ npt.assert_almost_equal(EVENT_RETURN_VALUE.info["value"], truth)
+ assert EVENT_RETURN_VALUE.info["user_value"] == 0.5
+
+ # check others are not modified
+ others_truth = np.repeat([[1.0, 1.0, 1.0, 1.0]], repeats=len(others), axis=0)
+ npt.assert_almost_equal(colors[others], others_truth)
+
+ # reset
+ if test_graphic:
+ # test setter
+ graphic.colors = "w"
+ else:
+ colors[:] = [1, 1, 1, 1]
+ truth = np.repeat([[1.0, 1.0, 1.0, 1.0]], 10, axis=0)
+ npt.assert_almost_equal(colors[:], truth)
+
+ if test_graphic:
+ # test event
+ assert isinstance(EVENT_RETURN_VALUE, GraphicFeatureEvent)
+ assert EVENT_RETURN_VALUE.graphic == graphic
+ assert EVENT_RETURN_VALUE.target is graphic.world_object
+ assert EVENT_RETURN_VALUE.info["key"] == slice(None)
+ npt.assert_almost_equal(EVENT_RETURN_VALUE.info["value"], truth)
+ assert EVENT_RETURN_VALUE.info["user_value"] == "w"
+
+ # set just R values
+ colors[s, 0] = 0.5
+ truth = np.repeat([[0.5, 1.0, 1.0, 1.0]], repeats=len(indices), axis=0)
+ # check others not modified
+ npt.assert_almost_equal(colors[indices], truth)
+ npt.assert_almost_equal(colors[others], others_truth)
+
+ # reset
+ colors[:] = (1, 1, 1, 1)
+ npt.assert_almost_equal(colors[:], np.repeat([[1.0, 1.0, 1.0, 1.0]], 10, axis=0))
+
+ # set green and blue
+ colors[s, 1:-1] = 0.7
+ truth = np.repeat([[1.0, 0.7, 0.7, 1.0]], repeats=len(indices), axis=0)
+ npt.assert_almost_equal(colors[indices], truth)
+ npt.assert_almost_equal(colors[others], others_truth)
+
+ # reset
+ colors[:] = (1, 1, 1, 1)
+ npt.assert_almost_equal(colors[:], np.repeat([[1.0, 1.0, 1.0, 1.0]], 10, axis=0))
+
+ # set only alpha
+ colors[s, -1] = 0.2
+ truth = np.repeat([[1.0, 1.0, 1.0, 0.2]], repeats=len(indices), axis=0)
+ npt.assert_almost_equal(colors[indices], truth)
+ npt.assert_almost_equal(colors[others], others_truth)
+
+
+@pytest.mark.parametrize("color_input", generate_color_inputs("red"))
+# skip testing with int since that results in shape [1, 4] with np.repeat, int tested in independent unit test
+@pytest.mark.parametrize(
+ "slice_method", [generate_slice_indices(i) for i in range(1, 16)]
+)
+@pytest.mark.parametrize("test_graphic", [False, "line", "scatter"])
+def test_slice(color_input, slice_method: dict, test_graphic: bool):
+ # slicing only first dim
+ if test_graphic:
+ fig = fpl.Figure()
+
+ data = generate_positions_spiral_data("xyz")
+ if test_graphic == "line":
+ graphic = fig[0, 0].add_line(data=data)
+
+ elif test_graphic == "scatter":
+ graphic = fig[0, 0].add_scatter(data=data)
+
+ colors = graphic.colors
+
+ global EVENT_RETURN_VALUE
+ graphic.add_event_handler(event_handler, "colors")
+ else:
+ colors = make_colors_buffer()
+
+ s = slice_method["slice"]
+ indices = slice_method["indices"]
+ offset = slice_method["offset"]
+ size = slice_method["size"]
+ others = slice_method["others"]
+
+ colors[s] = color_input
+ truth = np.repeat([pygfx.Color(color_input)], repeats=len(indices), axis=0)
+ # check that correct indices are modified
+ npt.assert_almost_equal(colors[s], truth)
+ npt.assert_almost_equal(colors[indices], truth)
+
+ # check event
+ if test_graphic:
+ global EVENT_RETURN_VALUE
+
+ assert isinstance(EVENT_RETURN_VALUE, GraphicFeatureEvent)
+ assert EVENT_RETURN_VALUE.graphic == graphic
+ assert EVENT_RETURN_VALUE.target is graphic.world_object
+ if isinstance(s, slice):
+ assert EVENT_RETURN_VALUE.info["key"] == s
+ else:
+ npt.assert_almost_equal(EVENT_RETURN_VALUE.info["key"], s)
+ npt.assert_almost_equal(EVENT_RETURN_VALUE.info["value"], truth)
+ if isinstance(color_input, str):
+ assert EVENT_RETURN_VALUE.info["user_value"] == color_input
+ else:
+ npt.assert_almost_equal(EVENT_RETURN_VALUE.info["user_value"], color_input)
+
+ # check that others are not touched
+ others_truth = np.repeat([[1.0, 1.0, 1.0, 1.0]], repeats=len(others), axis=0)
+ npt.assert_almost_equal(colors[others], others_truth)
+
+ # reset
+ colors[:] = (1, 1, 1, 1)
+ npt.assert_almost_equal(colors[:], np.repeat([[1.0, 1.0, 1.0, 1.0]], 10, axis=0))
diff --git a/tests/test_common_features.py b/tests/test_common_features.py
new file mode 100644
index 000000000..5671478a7
--- /dev/null
+++ b/tests/test_common_features.py
@@ -0,0 +1,282 @@
+import numpy
+import numpy as np
+from numpy import testing as npt
+import pytest
+
+import fastplotlib as fpl
+from fastplotlib.graphics.features import GraphicFeatureEvent, Name, Offset, Rotation, Visible
+
+
+def make_graphic(kind: str, **kwargs):
+ match kind:
+ case "image":
+ return fpl.ImageGraphic(np.random.rand(10, 10), **kwargs)
+ case "line":
+ return fpl.LineGraphic(np.random.rand(10), **kwargs)
+ case "scatter":
+ return fpl.ScatterGraphic(
+ np.column_stack([np.random.rand(10), np.random.rand(10)]), **kwargs
+ )
+ case "text":
+ return fpl.TextGraphic("bah", **kwargs)
+
+
+graphic_kinds = [
+ "image",
+ "line",
+ "scatter",
+ "text",
+]
+
+
+RETURN_EVENT_VALUE: GraphicFeatureEvent = None
+DECORATED_EVENT_VALUE: GraphicFeatureEvent = None
+
+
+def return_event(ev: GraphicFeatureEvent):
+ global RETURN_EVENT_VALUE
+ RETURN_EVENT_VALUE = ev
+
+
+@pytest.mark.parametrize("graphic", [make_graphic(k) for k in graphic_kinds])
+def test_name(graphic):
+ assert graphic.name is None
+
+ graphic.add_event_handler(return_event, "name")
+
+ graphic.name = "new_name"
+
+ assert graphic.name == "new_name"
+
+ global RETURN_EVENT_VALUE
+
+ assert RETURN_EVENT_VALUE.type == "name"
+ assert RETURN_EVENT_VALUE.graphic is graphic
+ assert RETURN_EVENT_VALUE.target is graphic.world_object
+ assert RETURN_EVENT_VALUE.info["value"] == "new_name"
+
+ # check removing event handler
+ RETURN_EVENT_VALUE = None
+ graphic.remove_event_handler(return_event, "name")
+ assert len(graphic._event_handlers["name"]) == 0
+
+ graphic.name = "new_name2"
+
+ assert RETURN_EVENT_VALUE is None
+ assert graphic.name == "new_name2"
+
+ # check adding event with decorator
+ global DECORATED_EVENT_VALUE
+ DECORATED_EVENT_VALUE = None
+
+ @graphic.add_event_handler("name")
+ def decorated_handler(ev):
+ global DECORATED_EVENT_VALUE
+ DECORATED_EVENT_VALUE = ev
+
+ graphic.name = "test_dec"
+ assert graphic.name == "test_dec"
+
+ assert DECORATED_EVENT_VALUE.type == "name"
+ assert DECORATED_EVENT_VALUE.graphic is graphic
+ assert DECORATED_EVENT_VALUE.target is graphic.world_object
+ assert DECORATED_EVENT_VALUE.info["value"] == "test_dec"
+
+
+@pytest.mark.parametrize(
+ "graphic", [make_graphic(k, name="init_name") for k in graphic_kinds]
+)
+def test_name_init(graphic):
+ assert graphic.name == "init_name"
+
+ graphic.name = "new_name"
+
+ assert graphic.name == "new_name"
+
+
+@pytest.mark.parametrize("graphic", [make_graphic(k) for k in graphic_kinds])
+def test_offset(graphic):
+ npt.assert_almost_equal(graphic.offset, (0.0, 0.0, 0.0))
+ npt.assert_almost_equal(graphic.world_object.world.position, (0.0, 0.0, 0.0))
+
+ graphic.add_event_handler(return_event, "offset")
+
+ graphic.offset = (1.0, 2.0, 3.0)
+
+ npt.assert_almost_equal(graphic.offset, (1.0, 2.0, 3.0))
+ npt.assert_almost_equal(graphic.world_object.world.position, (1.0, 2.0, 3.0))
+
+ global RETURN_EVENT_VALUE
+
+ assert RETURN_EVENT_VALUE.type == "offset"
+ assert RETURN_EVENT_VALUE.graphic is graphic
+ assert RETURN_EVENT_VALUE.target is graphic.world_object
+ npt.assert_almost_equal(RETURN_EVENT_VALUE.info["value"], (1.0, 2.0, 3.0))
+
+ # check removing event handler
+ RETURN_EVENT_VALUE = None
+ graphic.remove_event_handler(return_event, "offset")
+ assert len(graphic._event_handlers["offset"]) == 0
+
+ graphic.offset = (4, 5, 6)
+
+ assert RETURN_EVENT_VALUE is None
+ npt.assert_almost_equal(graphic.offset, (4.0, 5.0, 6.0))
+
+ # check adding event with decorator
+ global DECORATED_EVENT_VALUE
+ DECORATED_EVENT_VALUE = None
+
+ @graphic.add_event_handler("offset")
+ def decorated_handler(ev):
+ global DECORATED_EVENT_VALUE
+ DECORATED_EVENT_VALUE = ev
+
+ graphic.offset = (7, 8, 9)
+ npt.assert_almost_equal(graphic.offset, (7.0, 8.0, 9.0))
+
+ assert DECORATED_EVENT_VALUE.type == "offset"
+ assert DECORATED_EVENT_VALUE.graphic is graphic
+ assert DECORATED_EVENT_VALUE.target is graphic.world_object
+ npt.assert_almost_equal(DECORATED_EVENT_VALUE.info["value"], (7.0, 8.0, 9.0))
+
+
+@pytest.mark.parametrize(
+ "graphic", [make_graphic(k, offset=(3.0, 4.0, 5.0)) for k in graphic_kinds]
+)
+def test_offset_init(graphic):
+ npt.assert_almost_equal(graphic.offset, (3.0, 4.0, 5.0))
+ npt.assert_almost_equal(graphic.world_object.world.position, (3.0, 4.0, 5.0))
+
+ graphic.offset = (6.0, 7.0, 8.0)
+
+ npt.assert_almost_equal(graphic.offset, (6.0, 7.0, 8.0))
+ npt.assert_almost_equal(graphic.world_object.world.position, (6.0, 7.0, 8.0))
+
+
+@pytest.mark.parametrize("graphic", [make_graphic(k) for k in graphic_kinds])
+def test_rotation(graphic):
+ npt.assert_almost_equal(graphic.rotation, (0, 0, 0, 1))
+ npt.assert_almost_equal(graphic.world_object.world.rotation, (0, 0, 0, 1))
+
+ graphic.add_event_handler(return_event, "rotation")
+
+ graphic.rotation = (0.0, 0.0, 0.30001427, 0.95393471)
+
+ npt.assert_almost_equal(graphic.rotation, (0.0, 0.0, 0.30001427, 0.95393471))
+ npt.assert_almost_equal(
+ graphic.world_object.world.rotation, (0.0, 0.0, 0.30001427, 0.95393471)
+ )
+
+ global RETURN_EVENT_VALUE
+
+ assert RETURN_EVENT_VALUE.type == "rotation"
+ assert RETURN_EVENT_VALUE.graphic is graphic
+ assert RETURN_EVENT_VALUE.target is graphic.world_object
+ npt.assert_almost_equal(
+ RETURN_EVENT_VALUE.info["value"], (0.0, 0.0, 0.30001427, 0.95393471)
+ )
+
+ # check removing event handler
+ RETURN_EVENT_VALUE = None
+ graphic.remove_event_handler(return_event, "rotation")
+ assert len(graphic._event_handlers["rotation"]) == 0
+
+ graphic.rotation = (0, 0, 0, 1)
+
+ assert RETURN_EVENT_VALUE is None
+ npt.assert_almost_equal(graphic.rotation, (0, 0, 0, 1))
+
+ # check adding event with decorator
+ global DECORATED_EVENT_VALUE
+ DECORATED_EVENT_VALUE = None
+
+ @graphic.add_event_handler("rotation")
+ def decorated_handler(ev):
+ global DECORATED_EVENT_VALUE
+ DECORATED_EVENT_VALUE = ev
+
+ graphic.rotation = (0, 0, 0.6, 0.8)
+ npt.assert_almost_equal(graphic.rotation, (0, 0, 0.6, 0.8))
+
+ assert DECORATED_EVENT_VALUE.type == "rotation"
+ assert DECORATED_EVENT_VALUE.graphic is graphic
+ assert DECORATED_EVENT_VALUE.target is graphic.world_object
+ npt.assert_almost_equal(DECORATED_EVENT_VALUE.info["value"], (0, 0, 0.6, 0.8))
+
+
+@pytest.mark.parametrize(
+ "graphic",
+ [
+ make_graphic(k, rotation=(0.0, 0.0, 0.30001427, 0.95393471))
+ for k in graphic_kinds
+ ],
+)
+def test_rotation(graphic):
+ npt.assert_almost_equal(graphic.rotation, (0.0, 0.0, 0.30001427, 0.95393471))
+ npt.assert_almost_equal(
+ graphic.world_object.world.rotation, (0.0, 0.0, 0.30001427, 0.95393471)
+ )
+
+ graphic.rotation = (0, 0.0, 0.6, 0.8)
+
+ npt.assert_almost_equal(graphic.rotation, (0, 0.0, 0.6, 0.8))
+ npt.assert_almost_equal(graphic.world_object.world.rotation, (0, 0.0, 0.6, 0.8))
+
+
+@pytest.mark.parametrize("graphic", [make_graphic(k) for k in graphic_kinds])
+def test_visible(graphic):
+ assert graphic.visible is True
+ assert graphic.world_object.visible is True
+
+ graphic.add_event_handler(return_event, "rotation")
+
+ graphic.visible = False
+ assert graphic.visible is False
+ assert graphic.world_object.visible is False
+
+ global RETURN_EVENT_VALUE
+
+ assert RETURN_EVENT_VALUE.type == "visible"
+ assert RETURN_EVENT_VALUE.graphic is graphic
+ assert RETURN_EVENT_VALUE.target is graphic.world_object
+ assert RETURN_EVENT_VALUE.info["value"] is False
+
+ # check removing event handler
+ RETURN_EVENT_VALUE = None
+ graphic.remove_event_handler(return_event, "visible")
+ assert len(graphic._event_handlers["visible"]) == 0
+
+ graphic.visible = True
+
+ assert RETURN_EVENT_VALUE is None
+ assert graphic.visible is True
+
+ # check adding event with decorator
+ global DECORATED_EVENT_VALUE
+ DECORATED_EVENT_VALUE = None
+
+ @graphic.add_event_handler("visible")
+ def decorated_handler(ev):
+ global DECORATED_EVENT_VALUE
+ DECORATED_EVENT_VALUE = ev
+
+ graphic.visible = False
+ assert graphic.visible is False
+
+ assert DECORATED_EVENT_VALUE.type == "visible"
+ assert DECORATED_EVENT_VALUE.graphic is graphic
+ assert DECORATED_EVENT_VALUE.target is graphic.world_object
+ assert DECORATED_EVENT_VALUE.info["value"] is False
+
+
+@pytest.mark.parametrize(
+ "graphic", [make_graphic(k, visible=False) for k in graphic_kinds]
+)
+def test_visible(graphic):
+ assert graphic.visible is False
+ assert graphic.world_object.visible is False
+
+ graphic.visible = True
+ assert graphic.visible is True
+ assert graphic.world_object.visible is True
diff --git a/tests/test_figure.py b/tests/test_figure.py
new file mode 100644
index 000000000..520091009
--- /dev/null
+++ b/tests/test_figure.py
@@ -0,0 +1,262 @@
+import numpy as np
+import pytest
+
+import fastplotlib as fpl
+import pygfx
+
+
+def test_cameras_controller_properties():
+ cameras = [["2d", "3d", "3d"], ["3d", "3d", "3d"]]
+
+ controller_types = [
+ ["panzoom", "panzoom", "fly"],
+ ["orbit", "trackball", "panzoom"],
+ ]
+
+ fig = fpl.Figure(
+ shape=(2, 3),
+ cameras=cameras,
+ controller_types=controller_types,
+ canvas="offscreen",
+ )
+
+ print(fig.canvas)
+
+ subplot_cameras = [subplot.camera for subplot in fig]
+ subplot_controllers = [subplot.controller for subplot in fig]
+
+ for c1, c2 in zip(subplot_cameras, fig.cameras.ravel()):
+ assert c1 is c2
+
+ for c1, c2 in zip(subplot_controllers, fig.controllers.ravel()):
+ assert c1 is c2
+
+ for camera_type, subplot_camera in zip(
+ np.asarray(cameras).ravel(), fig.cameras.ravel()
+ ):
+ if camera_type == "2d":
+ assert subplot_camera.fov == 0
+ else:
+ assert subplot_camera.fov == 50
+
+ for controller_type, subplot_controller in zip(
+ np.asarray(controller_types).ravel(), fig.controllers.ravel()
+ ):
+ match controller_type:
+ case "panzoom":
+ assert isinstance(subplot_controller, pygfx.PanZoomController)
+ case "fly":
+ assert isinstance(subplot_controller, pygfx.FlyController)
+ case "orbit":
+ assert isinstance(subplot_controller, pygfx.OrbitController)
+ case "trackball":
+ assert isinstance(subplot_controller, pygfx.TrackballController)
+
+ # check changing cameras
+ fig[0, 0].camera = "3d"
+ assert fig[0, 0].camera.fov == 50
+ fig[1, 0].camera = "2d"
+ assert fig[1, 0].camera.fov == 0
+
+ # test changing controller
+ fig[1, 1].controller = "fly"
+ assert isinstance(fig[1, 1].controller, pygfx.FlyController)
+ assert fig[1, 1].controller is fig.controllers[1, 1]
+ fig[0, 2].controller = "panzoom"
+ assert isinstance(fig[0, 2].controller, pygfx.PanZoomController)
+ assert fig[0, 2].controller is fig.controllers[0, 2]
+
+
+def test_controller_ids_int():
+ ids = [[0, 1, 1], [0, 2, 3], [4, 1, 2]]
+
+ fig = fpl.Figure(shape=(3, 3), controller_ids=ids, canvas="offscreen")
+
+ assert fig[0, 0].controller is fig[1, 0].controller
+ assert fig[0, 1].controller is fig[0, 2].controller is fig[2, 1].controller
+ assert fig[1, 1].controller is fig[2, 2].controller
+
+
+def test_controller_ids_int_change_controllers():
+ ids = [[0, 1, 1], [0, 2, 3], [4, 1, 2]]
+
+ cameras = [["2d", "3d", "3d"], ["2d", "3d", "2d"], ["3d", "3d", "3d"]]
+
+ fig = fpl.Figure(
+ shape=(3, 3), cameras=cameras, controller_ids=ids, canvas="offscreen"
+ )
+
+ assert isinstance(fig[0, 1].controller, pygfx.FlyController)
+
+ # changing controller when id matches should change the others too
+ fig[0, 1].controller = "panzoom"
+ assert isinstance(fig[0, 1].controller, pygfx.PanZoomController)
+ assert fig[0, 1].controller is fig[0, 2].controller is fig[2, 1].controller
+ assert set(fig[0, 1].controller.cameras) == {
+ fig[0, 1].camera,
+ fig[0, 2].camera,
+ fig[2, 1].camera,
+ }
+
+ # change to orbit
+ fig[0, 1].controller = "orbit"
+ assert isinstance(fig[0, 1].controller, pygfx.OrbitController)
+ assert fig[0, 1].controller is fig[0, 2].controller is fig[2, 1].controller
+ assert set(fig[0, 1].controller.cameras) == {
+ fig[0, 1].camera,
+ fig[0, 2].camera,
+ fig[2, 1].camera,
+ }
+
+
+def test_controller_ids_str():
+ names = [["a", "b", "c"], ["d", "e", "f"]]
+
+ controller_ids = [["a", "f"], ["b", "d", "e"]]
+
+ fig = fpl.Figure(
+ shape=(2, 3), controller_ids=controller_ids, names=names, canvas="offscreen"
+ )
+
+ assert (
+ fig[0, 0].controller
+ is fig[1, 2].controller
+ is fig["a"].controller
+ is fig["f"].controller
+ )
+ assert (
+ fig[0, 1].controller
+ is fig[1, 0].controller
+ is fig[1, 1].controller
+ is fig["b"].controller
+ is fig["d"].controller
+ is fig["e"].controller
+ )
+
+ # make sure subplot c is unique
+ exclude_c = [fig[n].controller for n in ["a", "b", "d", "e", "f"]]
+ assert fig["c"] not in exclude_c
+
+
+def test_set_controllers_from_existing_controllers():
+ fig = fpl.Figure(shape=(3, 3), canvas="offscreen")
+ fig2 = fpl.Figure(shape=fig.shape, controllers=fig.controllers, canvas="offscreen")
+
+ assert fig.controllers[:-1].size == 6
+ with pytest.raises(ValueError):
+ fig3 = fpl.Figure(
+ shape=fig.shape, controllers=fig.controllers[:-1], canvas="offscreen"
+ )
+
+ for fig1_subplot, fig2_subplot in zip(fig, fig2):
+ assert fig1_subplot.controller is fig2_subplot.controller
+
+ cameras = [[pygfx.PerspectiveCamera(), "3d"], ["3d", "2d"]]
+
+ controllers = [
+ [pygfx.FlyController(cameras[0][0]), pygfx.TrackballController()],
+ [pygfx.OrbitController(), pygfx.PanZoomController()],
+ ]
+
+ fig = fpl.Figure(
+ shape=(2, 2), cameras=cameras, controllers=controllers, canvas="offscreen"
+ )
+
+ assert fig[0, 0].controller is controllers[0][0]
+ assert fig[0, 1].controller is controllers[0][1]
+ assert fig[1, 0].controller is controllers[1][0]
+ assert fig[1, 1].controller is controllers[1][1]
+
+ assert fig[0, 0].camera is cameras[0][0]
+
+ assert fig[0, 1].camera.fov == 50
+
+
+def test_subplot_names():
+ # names must be unique
+ with pytest.raises(ValueError):
+ fpl.Figure(
+ shape=(2, 3),
+ names=["1", "2", "3", "4", "4", "5"]
+ )
+
+ with pytest.raises(ValueError):
+ fpl.Figure(
+ shape=(2, 3),
+ names=["1", "2", None, "4", "4", "5"]
+ )
+
+ with pytest.raises(ValueError):
+ fpl.Figure(
+ shape=(2, 3),
+ names=[None, "2", None, "4", "4", "5"]
+ )
+
+ # len(names) <= n_subplots
+ fig = fpl.Figure(
+ shape=(2, 3),
+ names=["1", "2", "3", "4", "5", "6"]
+ )
+
+ assert fig[0, 0].name == "1"
+ assert fig[0, 1].name == "2"
+ assert fig[0, 2].name == "3"
+ assert fig[1, 0].name == "4"
+ assert fig[1, 1].name == "5"
+ assert fig[1, 2].name == "6"
+
+ fig = fpl.Figure(
+ shape=(2, 3),
+ names=["1", "2", "3", None, "5", "6"]
+ )
+
+ assert fig[0, 0].name == "1"
+ assert fig[0, 1].name == "2"
+ assert fig[0, 2].name == "3"
+ assert fig[1, 0].name is None
+ assert fig[1, 1].name == "5"
+ assert fig[1, 2].name == "6"
+
+ fig = fpl.Figure(
+ shape=(2, 3),
+ names=["1", "2", "3", None, "5", None]
+ )
+
+ assert fig[0, 0].name == "1"
+ assert fig[0, 1].name == "2"
+ assert fig[0, 2].name == "3"
+ assert fig[1, 0].name is None
+ assert fig[1, 1].name == "5"
+ assert fig[1, 2].name is None
+
+ # if fewer subplot names are given than n_sublots, pad with Nones
+ fig = fpl.Figure(
+ shape=(2, 3),
+ names=["1", "2", "3", "4"]
+ )
+
+ assert fig[0, 0].name == "1"
+ assert fig[0, 1].name == "2"
+ assert fig[0, 2].name == "3"
+ assert fig[1, 0].name == "4"
+ assert fig[1, 1].name is None
+ assert fig[1, 2].name is None
+
+ # raise if len(names) > n_subplots
+ with pytest.raises(ValueError):
+ fpl.Figure(
+ shape=(2, 3),
+ names=["1", "2", "3", "4", "5", "6", "7"]
+ )
+
+ with pytest.raises(ValueError):
+ fpl.Figure(
+ shape=(2, 3),
+ names=["1", "2", "3", "4", None, "6", "7"]
+ )
+
+ with pytest.raises(ValueError):
+ fpl.Figure(
+ shape=(2, 3),
+ names=["1", None, "3", "4", None, "6", "7"]
+ )
diff --git a/tests/test_image_graphic.py b/tests/test_image_graphic.py
new file mode 100644
index 000000000..f2d87860b
--- /dev/null
+++ b/tests/test_image_graphic.py
@@ -0,0 +1,219 @@
+import numpy as np
+from numpy import testing as npt
+import imageio.v3 as iio
+
+import pygfx
+
+import fastplotlib as fpl
+from fastplotlib.graphics.features import GraphicFeatureEvent
+from fastplotlib.utils import make_colors
+
+GRAY_IMAGE = iio.imread("imageio:camera.png")
+RGB_IMAGE = iio.imread("imageio:astronaut.png")
+
+
+COFFEE_IMAGE = iio.imread("imageio:coffee.png")
+
+# image cmap, vmin, vmax, interpolations
+# new screenshot tests too for these when in graphics
+
+
+EVENT_RETURN_VALUE: GraphicFeatureEvent = None
+
+
+def event_handler(ev):
+ global EVENT_RETURN_VALUE
+ EVENT_RETURN_VALUE = ev
+
+
+def check_event(graphic, feature, value):
+ global EVENT_RETURN_VALUE
+ assert isinstance(EVENT_RETURN_VALUE, GraphicFeatureEvent)
+ assert EVENT_RETURN_VALUE.type == feature
+ assert EVENT_RETURN_VALUE.graphic == graphic
+ assert EVENT_RETURN_VALUE.target == graphic.world_object
+ if isinstance(EVENT_RETURN_VALUE.info["value"], float):
+ # floating point error
+ npt.assert_almost_equal(EVENT_RETURN_VALUE.info["value"], value)
+ else:
+ assert EVENT_RETURN_VALUE.info["value"] == value
+
+
+def check_set_slice(
+ data: np.ndarray,
+ image_graphic: fpl.ImageGraphic,
+ row_slice: slice,
+ col_slice: slice,
+):
+ image_graphic.data[row_slice, col_slice] = 1
+ data_values = image_graphic.data.value
+ npt.assert_almost_equal(data_values[row_slice, col_slice], 1)
+
+ # make sure other vals unchanged
+ npt.assert_almost_equal(data_values[: row_slice.start], data[: row_slice.start])
+ npt.assert_almost_equal(data_values[row_slice.stop :], data[row_slice.stop :])
+ npt.assert_almost_equal(
+ data_values[:, : col_slice.start], data[:, : col_slice.start]
+ )
+ npt.assert_almost_equal(data_values[:, col_slice.stop :], data[:, col_slice.stop :])
+
+ global EVENT_RETURN_VALUE
+ assert isinstance(EVENT_RETURN_VALUE, GraphicFeatureEvent)
+ assert EVENT_RETURN_VALUE.type == "data"
+ assert EVENT_RETURN_VALUE.graphic == image_graphic
+ assert EVENT_RETURN_VALUE.target == image_graphic.world_object
+ assert EVENT_RETURN_VALUE.info["key"] == (row_slice, col_slice)
+ npt.assert_almost_equal(EVENT_RETURN_VALUE.info["value"], 1)
+
+
+def test_gray():
+ fig = fpl.Figure()
+ ig = fig[0, 0].add_image(GRAY_IMAGE)
+ assert isinstance(ig, fpl.ImageGraphic)
+
+ ig.add_event_handler(
+ event_handler,
+ "data",
+ "cmap",
+ "vmin",
+ "vmax",
+ "interpolation",
+ "cmap_interpolation",
+ )
+
+ # make sure entire data is the same
+ npt.assert_almost_equal(ig.data.value, GRAY_IMAGE)
+
+ # since this entire image is under the wgpu max texture limit,
+ # the entire image should be in the single Texture buffer
+ npt.assert_almost_equal(ig.data.buffer[0, 0].data, GRAY_IMAGE)
+
+ assert isinstance(ig._material, pygfx.ImageBasicMaterial)
+ assert isinstance(ig._material.map, pygfx.TextureMap)
+ assert isinstance(ig._material.map.texture, pygfx.Texture)
+
+ ig.cmap = "viridis"
+ assert ig.cmap == "viridis"
+ check_event(graphic=ig, feature="cmap", value="viridis")
+
+ new_colors = make_colors(256, "viridis")
+ for child in ig.world_object.children:
+ npt.assert_almost_equal(child.material.map.texture.data, new_colors)
+
+ ig.cmap = "jet"
+ assert ig.cmap == "jet"
+
+ new_colors = make_colors(256, "jet")
+ for child in ig.world_object.children:
+ npt.assert_almost_equal(child.material.map.texture.data, new_colors)
+
+ assert ig.interpolation == "nearest"
+ for child in ig.world_object.children:
+ assert child.material.interpolation == "nearest"
+
+ ig.interpolation = "linear"
+ assert ig.interpolation == "linear"
+ for child in ig.world_object.children:
+ assert child.material.interpolation == "linear"
+ check_event(graphic=ig, feature="interpolation", value="linear")
+
+ assert ig.cmap_interpolation == "linear"
+ for child in ig.world_object.children:
+ assert child.material.map.min_filter == "linear"
+ assert child.material.map.mag_filter == "linear"
+
+ ig.cmap_interpolation = "nearest"
+ assert ig.cmap_interpolation == "nearest"
+ for child in ig.world_object.children:
+ assert child.material.map.min_filter == "nearest"
+ assert child.material.map.mag_filter == "nearest"
+
+ check_event(graphic=ig, feature="cmap_interpolation", value="nearest")
+
+ npt.assert_almost_equal(ig.vmin, GRAY_IMAGE.min())
+ npt.assert_almost_equal(ig.vmax, GRAY_IMAGE.max())
+
+ ig.vmin = 50
+ assert ig.vmin == 50
+ for child in ig.world_object.children:
+ assert child.material.clim == (50, ig.vmax)
+ check_event(graphic=ig, feature="vmin", value=50)
+
+ ig.vmax = 100
+ assert ig.vmax == 100
+ for child in ig.world_object.children:
+ assert child.material.clim == (ig.vmin, 100)
+ check_event(graphic=ig, feature="vmax", value=100)
+
+ # test reset
+ ig.reset_vmin_vmax()
+ npt.assert_almost_equal(ig.vmin, GRAY_IMAGE.min())
+ npt.assert_almost_equal(ig.vmax, GRAY_IMAGE.max())
+
+ check_set_slice(GRAY_IMAGE, ig, slice(100, 200), slice(200, 300))
+
+ # test setting all values
+ ig.data = 1
+ npt.assert_almost_equal(ig.data.value, 1)
+
+
+def test_rgb():
+ fig = fpl.Figure()
+ ig = fig[0, 0].add_image(RGB_IMAGE)
+ assert isinstance(ig, fpl.ImageGraphic)
+
+ ig.add_event_handler(event_handler, "data")
+
+ npt.assert_almost_equal(ig.data.value, RGB_IMAGE)
+
+ assert ig.interpolation == "nearest"
+ for child in ig.world_object.children:
+ assert child.material.interpolation == "nearest"
+
+ ig.interpolation = "linear"
+ assert ig.interpolation == "linear"
+ for child in ig.world_object.children:
+ assert child.material.interpolation == "linear"
+
+ npt.assert_almost_equal(ig.vmin, RGB_IMAGE.min())
+ npt.assert_almost_equal(ig.vmax, RGB_IMAGE.max())
+
+ ig.vmin = 50
+ assert ig.vmin == 50
+ for child in ig.world_object.children:
+ assert child.material.clim == (50, ig.vmax)
+
+ ig.vmax = 100
+ assert ig.vmax == 100
+ for child in ig.world_object.children:
+ assert child.material.clim == (ig.vmin, 100)
+
+ # test reset
+ ig.reset_vmin_vmax()
+ npt.assert_almost_equal(ig.vmin, RGB_IMAGE.min())
+ npt.assert_almost_equal(ig.vmax, RGB_IMAGE.max())
+
+ check_set_slice(RGB_IMAGE, ig, slice(100, 200), slice(200, 300))
+
+
+def test_rgba():
+ rgba = np.zeros(shape=(*COFFEE_IMAGE.shape[:2], 4), dtype=np.float32)
+
+ fig = fpl.Figure()
+ ig = fig[0, 0].add_image(rgba)
+ assert isinstance(ig, fpl.ImageGraphic)
+
+ npt.assert_almost_equal(ig.data.value, rgba)
+
+ # fancy indexing
+ # set the blue values of some pixels with an alpha > 1
+ ig.data[COFFEE_IMAGE[:, :, -1] > 200] = np.array([0.0, 0.0, 1.0, 0.6]).astype(
+ np.float32
+ )
+
+ rgba[COFFEE_IMAGE[:, :, -1] > 200] = np.array([0.0, 0.0, 1.0, 0.6]).astype(
+ np.float32
+ )
+
+ # check that fancy indexing works
+ npt.assert_almost_equal(ig.data.value, rgba)
diff --git a/tests/test_plot_helpers.py b/tests/test_plot_helpers.py
new file mode 100644
index 000000000..b4abe55fc
--- /dev/null
+++ b/tests/test_plot_helpers.py
@@ -0,0 +1,33 @@
+import numpy as np
+import fastplotlib as fpl
+
+
+def make_circle(center, radius: float, n_points: int = 75) -> np.ndarray:
+ theta = np.linspace(0, 2 * np.pi, n_points)
+ xs = radius * np.sin(theta)
+ ys = radius * np.cos(theta)
+
+ return np.column_stack([xs, ys]) + center
+
+
+def test_get_nearest_graphics():
+ circles = list()
+
+ centers = [[0, 0], [0, 20], [20, 0], [20, 20]]
+
+ for center in centers:
+ circles.append(make_circle(center, 5, n_points=75))
+
+ fig = fpl.Figure()
+
+ lines = fig[0, 0].add_line_collection(circles, cmap="jet", thickness=5)
+
+ fig[0, 0].add_scatter(np.array([[0, 12, 0]]))
+
+ # check distances
+ nearest = fpl.utils.get_nearest_graphics((0, 12), lines)
+ assert nearest[0] is lines[1] # closest
+ assert nearest[1] is lines[0]
+ assert nearest[2] is lines[3]
+ assert nearest[3] is lines[2] # furthest
+ assert nearest[-1] is lines[2]
diff --git a/tests/test_positions_data_buffer_manager.py b/tests/test_positions_data_buffer_manager.py
new file mode 100644
index 000000000..18a7b36e8
--- /dev/null
+++ b/tests/test_positions_data_buffer_manager.py
@@ -0,0 +1,201 @@
+import numpy as np
+from numpy import testing as npt
+import pytest
+
+import fastplotlib as fpl
+from fastplotlib.graphics.features import VertexPositions, GraphicFeatureEvent
+from .utils import (
+ generate_slice_indices,
+ generate_positions_spiral_data,
+)
+
+
+EVENT_RETURN_VALUE: GraphicFeatureEvent = None
+
+
+def event_handler(ev):
+ global EVENT_RETURN_VALUE
+ EVENT_RETURN_VALUE = ev
+
+
+@pytest.mark.parametrize(
+ "data", [generate_positions_spiral_data(v) for v in ["y", "xy", "xyz"]]
+)
+def test_create_buffer(data):
+ points_data = VertexPositions(data)
+
+ if data.ndim == 1:
+ # only y-vals specified
+ npt.assert_almost_equal(points_data[:, 1], generate_positions_spiral_data("y"))
+ # x-vals are auto generated just using arange
+ npt.assert_almost_equal(points_data[:, 0], np.arange(data.size))
+
+ elif data.shape[1] == 2:
+ # test 2D
+ npt.assert_almost_equal(
+ points_data[:, :-1], generate_positions_spiral_data("xy")
+ )
+ npt.assert_almost_equal(points_data[:, -1], 0.0)
+
+ elif data.shape[1] == 3:
+ # test 3D spiral
+ npt.assert_almost_equal(points_data[:], generate_positions_spiral_data("xyz"))
+
+
+@pytest.mark.parametrize("test_graphic", [False, "line", "scatter"])
+def test_int(test_graphic):
+ # test setting single points
+
+ data = generate_positions_spiral_data("xyz")
+ if test_graphic:
+ fig = fpl.Figure()
+
+ if test_graphic == "line":
+ graphic = fig[0, 0].add_line(data=data)
+
+ elif test_graphic == "scatter":
+ graphic = fig[0, 0].add_scatter(data=data)
+
+ points = graphic.data
+ global EVENT_RETURN_VALUE
+ graphic.add_event_handler(event_handler, "data")
+ else:
+ points = VertexPositions(data)
+
+ # set all x, y, z points, create a kink in the spiral
+ points[2] = 1.0
+ npt.assert_almost_equal(points[2], 1.0)
+ # make sure other points are not affected
+ indices = list(range(10))
+ indices.pop(2)
+ npt.assert_almost_equal(points[indices], data[indices])
+
+ # check event
+ if test_graphic:
+ assert isinstance(EVENT_RETURN_VALUE, GraphicFeatureEvent)
+ assert EVENT_RETURN_VALUE.graphic == graphic
+ assert EVENT_RETURN_VALUE.target is graphic.world_object
+ assert EVENT_RETURN_VALUE.info["key"] == 2
+ npt.assert_almost_equal(EVENT_RETURN_VALUE.info["value"], 1.0)
+
+ # reset
+ if test_graphic:
+ graphic.data = data
+ else:
+ points[:] = data
+ npt.assert_almost_equal(points[:], data)
+
+ # check event
+ if test_graphic:
+ assert isinstance(EVENT_RETURN_VALUE, GraphicFeatureEvent)
+ assert EVENT_RETURN_VALUE.graphic == graphic
+ assert EVENT_RETURN_VALUE.target is graphic.world_object
+ assert EVENT_RETURN_VALUE.info["key"] == slice(None)
+ npt.assert_almost_equal(EVENT_RETURN_VALUE.info["value"], data)
+
+ # just set y value
+ points[3, 1] = 1.0
+ npt.assert_almost_equal(points[3, 1], 1.0)
+ # make sure others not modified
+ npt.assert_almost_equal(points[3, 0], data[3, 0])
+ npt.assert_almost_equal(points[3, 2], data[3, 2])
+ indices = list(range(10))
+ indices.pop(3)
+ npt.assert_almost_equal(points[indices], data[indices])
+
+
+@pytest.mark.parametrize("test_graphic", [False, "line", "scatter"])
+@pytest.mark.parametrize(
+ "slice_method", [generate_slice_indices(i) for i in range(1, 16)]
+) # int tested separately
+@pytest.mark.parametrize("test_axis", ["y", "xy", "xyz"])
+def test_slice(test_graphic, slice_method: dict, test_axis: str):
+ data = generate_positions_spiral_data("xyz")
+
+ if test_graphic:
+ fig = fpl.Figure()
+
+ if test_graphic == "line":
+ graphic = fig[0, 0].add_line(data=data)
+
+ elif test_graphic == "scatter":
+ graphic = fig[0, 0].add_scatter(data=data)
+
+ points = graphic.data
+ global EVENT_RETURN_VALUE
+ graphic.add_event_handler(event_handler, "data")
+ else:
+ points = VertexPositions(data)
+
+ s = slice_method["slice"]
+ indices = slice_method["indices"]
+ offset = slice_method["offset"]
+ size = slice_method["size"]
+ others = slice_method["others"]
+
+ match test_axis:
+ case "y":
+ points[s, 1] = -data[s, 1]
+ npt.assert_almost_equal(points[s, 1], -data[s, 1])
+ npt.assert_almost_equal(points[indices, 1], -data[indices, 1])
+ # make sure other points are not modified
+ npt.assert_almost_equal(
+ points[others, 1], data[others, 1]
+ ) # other points in same dimension
+ npt.assert_almost_equal(
+ points[:, 2:], data[:, 2:]
+ ) # dimensions that are not sliced
+
+ # check event
+ if test_graphic:
+ assert isinstance(EVENT_RETURN_VALUE, GraphicFeatureEvent)
+ assert EVENT_RETURN_VALUE.graphic == graphic
+ assert EVENT_RETURN_VALUE.target is graphic.world_object
+ if isinstance(s, slice):
+ assert EVENT_RETURN_VALUE.info["key"] == (s, 1)
+ else:
+ npt.assert_almost_equal(EVENT_RETURN_VALUE.info["key"][0], s)
+ assert EVENT_RETURN_VALUE.info["key"][1] == 1
+ npt.assert_almost_equal(EVENT_RETURN_VALUE.info["value"], -data[s, 1])
+
+ case "xy":
+ points[s, :-1] = -data[s, :-1]
+ npt.assert_almost_equal(points[s, :-1], -data[s, :-1])
+ npt.assert_almost_equal(points[indices, :-1], -data[s, :-1])
+ # make sure other points are not modified
+ npt.assert_almost_equal(
+ points[others, :-1], data[others, :-1]
+ ) # other points in the same dimensions
+ npt.assert_almost_equal(
+ points[:, -1], data[:, -1]
+ ) # dimensions that are not touched
+
+ # check event
+ if test_graphic:
+ assert isinstance(EVENT_RETURN_VALUE, GraphicFeatureEvent)
+ assert EVENT_RETURN_VALUE.graphic == graphic
+ assert EVENT_RETURN_VALUE.target is graphic.world_object
+ if isinstance(s, slice):
+ assert EVENT_RETURN_VALUE.info["key"] == (s, slice(None, -1, None))
+ else:
+ npt.assert_almost_equal(EVENT_RETURN_VALUE.info["key"][0], s)
+ assert EVENT_RETURN_VALUE.info["key"][1] == slice(None, -1, None)
+ npt.assert_almost_equal(EVENT_RETURN_VALUE.info["value"], -data[s, :-1])
+
+ case "xyz":
+ points[s] = -data[s]
+ npt.assert_almost_equal(points[s], -data[s])
+ npt.assert_almost_equal(points[indices], -data[s])
+ # make sure other points are not modified
+ npt.assert_almost_equal(points[others], data[others])
+
+ # check event
+ if test_graphic:
+ assert isinstance(EVENT_RETURN_VALUE, GraphicFeatureEvent)
+ assert EVENT_RETURN_VALUE.graphic == graphic
+ assert EVENT_RETURN_VALUE.target is graphic.world_object
+ if isinstance(s, slice):
+ assert EVENT_RETURN_VALUE.info["key"] == s
+ else:
+ npt.assert_almost_equal(EVENT_RETURN_VALUE.info["key"], s)
+ npt.assert_almost_equal(EVENT_RETURN_VALUE.info["value"], -data[s])
diff --git a/tests/test_positions_graphics.py b/tests/test_positions_graphics.py
new file mode 100644
index 000000000..ed791b6fa
--- /dev/null
+++ b/tests/test_positions_graphics.py
@@ -0,0 +1,487 @@
+import numpy as np
+from numpy import testing as npt
+import pytest
+
+import pygfx
+
+import fastplotlib as fpl
+from fastplotlib.graphics.features import (
+ VertexPositions,
+ VertexColors,
+ VertexCmap,
+ UniformColor,
+ UniformSize,
+ PointsSizesFeature,
+ Thickness,
+ GraphicFeatureEvent,
+)
+
+from .utils import (
+ generate_positions_spiral_data,
+ generate_color_inputs,
+ MULTI_COLORS_TRUTH,
+ generate_slice_indices,
+)
+
+
+TRUTH_CMAPS = {
+ "jet": np.array(
+ [
+ [0.0, 0.0, 0.5, 1.0],
+ [0.0, 0.0, 0.99910873, 1.0],
+ [0.0, 0.37843138, 1.0, 1.0],
+ [0.0, 0.8333333, 1.0, 1.0],
+ [0.30044276, 1.0, 0.66729915, 1.0],
+ [0.65464896, 1.0, 0.31309298, 1.0],
+ [1.0, 0.90123457, 0.0, 1.0],
+ [1.0, 0.4945534, 0.0, 1.0],
+ [1.0, 0.08787218, 0.0, 1.0],
+ [0.5, 0.0, 0.0, 1.0],
+ ],
+ dtype=np.float32,
+ ),
+ "viridis": np.array(
+ [
+ [0.267004, 0.004874, 0.329415, 1.0],
+ [0.281412, 0.155834, 0.469201, 1.0],
+ [0.244972, 0.287675, 0.53726, 1.0],
+ [0.190631, 0.407061, 0.556089, 1.0],
+ [0.147607, 0.511733, 0.557049, 1.0],
+ [0.119483, 0.614817, 0.537692, 1.0],
+ [0.20803, 0.718701, 0.472873, 1.0],
+ [0.421908, 0.805774, 0.35191, 1.0],
+ [0.699415, 0.867117, 0.175971, 1.0],
+ [0.993248, 0.906157, 0.143936, 1.0],
+ ],
+ dtype=np.float32,
+ ),
+}
+
+
+EVENT_RETURN_VALUE: GraphicFeatureEvent = None
+
+
+def event_handler(ev):
+ global EVENT_RETURN_VALUE
+ EVENT_RETURN_VALUE = ev
+
+
+def test_sizes_slice():
+ pass
+
+
+@pytest.mark.parametrize("graphic_type", ["line", "scatter"])
+@pytest.mark.parametrize("colors", [None, *generate_color_inputs("b")])
+@pytest.mark.parametrize("uniform_color", [True, False])
+@pytest.mark.parametrize("alpha", [1.0, 0.5, 0.0])
+def test_uniform_color(graphic_type, colors, uniform_color, alpha):
+ fig = fpl.Figure()
+
+ kwargs = dict()
+ for kwarg in ["colors", "uniform_color", "alpha"]:
+ if locals()[kwarg] is not None:
+ # add to dict of arguments that will be passed
+ kwargs[kwarg] = locals()[kwarg]
+
+ data = generate_positions_spiral_data("xy")
+
+ if graphic_type == "line":
+ graphic = fig[0, 0].add_line(data=data, **kwargs)
+ elif graphic_type == "scatter":
+ graphic = fig[0, 0].add_scatter(data=data, **kwargs)
+
+ if uniform_color:
+ assert isinstance(graphic._colors, UniformColor)
+ assert isinstance(graphic.colors, pygfx.Color)
+ if colors is None:
+ # default white
+ assert graphic.colors == pygfx.Color([1, 1, 1, alpha])
+ else:
+ # should be blue
+ assert graphic.colors == pygfx.Color([0, 0, 1, alpha])
+
+ # check pygfx material
+ npt.assert_almost_equal(
+ graphic.world_object.material.color, np.asarray(graphic.colors)
+ )
+ else:
+ assert isinstance(graphic._colors, VertexColors)
+ assert isinstance(graphic.colors, VertexColors)
+ if colors is None:
+ # default white
+ npt.assert_almost_equal(
+ graphic.colors.value,
+ np.repeat([[1, 1, 1, alpha]], repeats=len(graphic.data), axis=0),
+ )
+ else:
+ # blue
+ npt.assert_almost_equal(
+ graphic.colors.value,
+ np.repeat([[0, 0, 1, alpha]], repeats=len(graphic.data), axis=0),
+ )
+
+ # check geometry
+ npt.assert_almost_equal(
+ graphic.world_object.geometry.colors.data, graphic.colors.value
+ )
+
+
+@pytest.mark.parametrize("graphic_type", ["line", "scatter"])
+@pytest.mark.parametrize(
+ "data", [generate_positions_spiral_data(v) for v in ["y", "xy", "xyz"]]
+)
+def test_positions_graphics_data(
+ graphic_type,
+ data,
+):
+ # tests with different ways of passing positions data, x, xy and xyz
+ fig = fpl.Figure()
+
+ if graphic_type == "line":
+ graphic = fig[0, 0].add_line(data=data)
+
+ elif graphic_type == "scatter":
+ graphic = fig[0, 0].add_scatter(data=data)
+
+ assert isinstance(graphic._data, VertexPositions)
+ assert isinstance(graphic.data, VertexPositions)
+
+ # n_datapoints must match
+ assert len(graphic.data.value) == len(data)
+
+ # make sure data is correct
+ match data.shape[-1]:
+ case 1: # only y-vals given
+ npt.assert_almost_equal(graphic.data[:, 1], data) # y vals must match
+ npt.assert_almost_equal(
+ graphic.data[:, 0], np.arange(data.size)
+ ) # VertexData makes x-vals with arange
+ npt.assert_almost_equal(graphic.data[:, -1], 0) # z-vals must be zeros
+ case 2: # xy vals given
+ npt.assert_almost_equal(graphic.data[:, :-1], data) # x and y must match
+ npt.assert_almost_equal(graphic.data[:, -1], 0) # z-vals must be zero
+ case 3: # xyz vals given
+ npt.assert_almost_equal(graphic.data[:], data[:]) # everything must match
+
+
+@pytest.mark.parametrize("graphic_type", ["line", "scatter"])
+@pytest.mark.parametrize("colors", [None, *generate_color_inputs("r")])
+@pytest.mark.parametrize("uniform_color", [None, False])
+@pytest.mark.parametrize("alpha", [None, 0.5, 0.0])
+def test_positions_graphic_vertex_colors(
+ graphic_type,
+ colors,
+ uniform_color,
+ alpha,
+):
+ # test different ways of passing vertex colors
+ fig = fpl.Figure()
+
+ kwargs = dict()
+ for kwarg in ["colors", "uniform_color", "alpha"]:
+ if locals()[kwarg] is not None:
+ # add to dict of arguments that will be passed
+ kwargs[kwarg] = locals()[kwarg]
+
+ data = generate_positions_spiral_data("xy")
+
+ if graphic_type == "line":
+ graphic = fig[0, 0].add_line(data=data, **kwargs)
+ elif graphic_type == "scatter":
+ graphic = fig[0, 0].add_scatter(data=data, **kwargs)
+
+ if alpha is None: # default arg
+ alpha = 1
+
+ # color per vertex
+ # uniform colors is default False, or set to False
+ assert isinstance(graphic._colors, VertexColors)
+ assert isinstance(graphic.colors, VertexColors)
+ assert len(graphic.colors) == len(graphic.data)
+
+ if colors is None:
+ # default
+ npt.assert_almost_equal(
+ graphic.colors.value,
+ np.repeat([[1, 1, 1, alpha]], repeats=len(graphic.data), axis=0),
+ )
+ else:
+ if len(colors) != len(graphic.data):
+ # should be single red, regardless of input variant (i.e. str, array, RGBA tuple, etc.
+ npt.assert_almost_equal(
+ graphic.colors.value,
+ np.repeat([[1, 0, 0, alpha]], repeats=len(graphic.data), axis=0),
+ )
+ else:
+ # multi colors
+ # use the truth for multi colors test that is pre-set
+ npt.assert_almost_equal(graphic.colors.value, MULTI_COLORS_TRUTH)
+
+
+@pytest.mark.parametrize("graphic_type", ["line", "scatter"])
+@pytest.mark.parametrize("colors", [None, *generate_color_inputs("r")])
+@pytest.mark.parametrize("uniform_color", [None, False])
+@pytest.mark.parametrize("cmap", ["jet"])
+@pytest.mark.parametrize(
+ "cmap_transform", [None, [3, 5, 2, 1, 0, 6, 9, 7, 4, 8], np.arange(9, -1, -1)]
+)
+@pytest.mark.parametrize("alpha", [None, 0.5, 0.0])
+def test_cmap(
+ graphic_type,
+ colors,
+ uniform_color,
+ cmap,
+ cmap_transform,
+ alpha,
+):
+ # test different ways of passing cmap args
+ fig = fpl.Figure()
+
+ kwargs = dict()
+ for kwarg in ["cmap", "cmap_transform", "colors", "uniform_color", "alpha"]:
+ if locals()[kwarg] is not None:
+ # add to dict of arguments that will be passed
+ kwargs[kwarg] = locals()[kwarg]
+
+ data = generate_positions_spiral_data("xy")
+
+ if graphic_type == "line":
+ graphic = fig[0, 0].add_line(data=data, **kwargs)
+ elif graphic_type == "scatter":
+ graphic = fig[0, 0].add_scatter(data=data, **kwargs)
+
+ if alpha is None:
+ alpha = 1.0
+
+ truth = TRUTH_CMAPS[cmap].copy()
+ truth[:, -1] = alpha
+
+ # permute if transform is provided
+ if cmap_transform is not None:
+ truth = truth[cmap_transform]
+ npt.assert_almost_equal(graphic.cmap.transform, cmap_transform)
+
+ assert isinstance(graphic._cmap, VertexCmap)
+
+ assert graphic.cmap.name == cmap
+
+ # make sure buffer is identical
+ # cmap overrides colors argument
+ assert graphic.colors.buffer is graphic.cmap.buffer
+
+ npt.assert_almost_equal(graphic.cmap.value, truth)
+ npt.assert_almost_equal(graphic.colors.value, truth)
+
+ # test changing cmap but not transform
+ graphic.cmap = "viridis"
+ truth = TRUTH_CMAPS["viridis"].copy()
+ truth[:, -1] = alpha
+
+ if cmap_transform is not None:
+ truth = truth[cmap_transform]
+
+ assert graphic.cmap.name == "viridis"
+ npt.assert_almost_equal(graphic.cmap.value, truth)
+ npt.assert_almost_equal(graphic.colors.value, truth)
+
+ # test changing transform
+ cmap_transform = np.random.rand(10)
+
+ # cmap transform is internally normalized between 0 - 1
+ cmap_transform_norm = cmap_transform.copy()
+ cmap_transform_norm -= cmap_transform.min()
+ cmap_transform_norm /= cmap_transform_norm.max()
+ cmap_transform_norm *= 255
+
+ truth = fpl.utils.get_cmap("viridis", alpha=alpha)
+ truth = np.vstack([truth[val] for val in cmap_transform_norm.astype(int)])
+
+ graphic.cmap.transform = cmap_transform
+ npt.assert_almost_equal(graphic.cmap.transform, cmap_transform)
+
+ npt.assert_almost_equal(graphic.cmap.value, truth)
+ npt.assert_almost_equal(graphic.colors.value, truth)
+
+
+@pytest.mark.parametrize("graphic_type", ["line", "scatter"])
+@pytest.mark.parametrize("cmap", ["jet"])
+@pytest.mark.parametrize(
+ "colors", [None, *generate_color_inputs("multi")]
+) # cmap arg overrides colors
+@pytest.mark.parametrize(
+ "uniform_color", [True] # none of these will work with a uniform buffer
+)
+def test_incompatible_cmap_color_args(graphic_type, cmap, colors, uniform_color):
+ # test incompatible cmap args
+ fig = fpl.Figure()
+
+ kwargs = dict()
+ for kwarg in ["cmap", "colors", "uniform_color"]:
+ if locals()[kwarg] is not None:
+ # add to dict of arguments that will be passed
+ kwargs[kwarg] = locals()[kwarg]
+
+ data = generate_positions_spiral_data("xy")
+
+ if graphic_type == "line":
+ with pytest.raises(TypeError):
+ graphic = fig[0, 0].add_line(data=data, **kwargs)
+ elif graphic_type == "scatter":
+ with pytest.raises(TypeError):
+ graphic = fig[0, 0].add_scatter(data=data, **kwargs)
+
+
+@pytest.mark.parametrize("graphic_type", ["line", "scatter"])
+@pytest.mark.parametrize("colors", [*generate_color_inputs("multi")])
+@pytest.mark.parametrize(
+ "uniform_color", [True] # none of these will work with a uniform buffer
+)
+def test_incompatible_color_args(graphic_type, colors, uniform_color):
+ # test incompatible color args
+ fig = fpl.Figure()
+
+ kwargs = dict()
+ for kwarg in ["colors", "uniform_color"]:
+ if locals()[kwarg] is not None:
+ # add to dict of arguments that will be passed
+ kwargs[kwarg] = locals()[kwarg]
+
+ data = generate_positions_spiral_data("xy")
+
+ if graphic_type == "line":
+ with pytest.raises(TypeError):
+ graphic = fig[0, 0].add_line(data=data, **kwargs)
+ elif graphic_type == "scatter":
+ with pytest.raises(TypeError):
+ graphic = fig[0, 0].add_scatter(data=data, **kwargs)
+
+
+@pytest.mark.parametrize("sizes", [None, 5.0, np.linspace(3, 8, 10, dtype=np.float32)])
+@pytest.mark.parametrize("uniform_size", [None, False])
+def test_sizes(sizes, uniform_size):
+ # test scatter sizes
+ fig = fpl.Figure()
+
+ kwargs = dict()
+ for kwarg in ["sizes"]:
+ if locals()[kwarg] is not None:
+ # add to dict of arguments that will be passed
+ kwargs[kwarg] = locals()[kwarg]
+
+ data = generate_positions_spiral_data("xy")
+
+ graphic = fig[0, 0].add_scatter(data=data, **kwargs)
+
+ assert isinstance(graphic.sizes, PointsSizesFeature)
+ assert isinstance(graphic._sizes, PointsSizesFeature)
+ assert len(data) == len(graphic.sizes)
+
+ if sizes is None:
+ sizes = 1 # default sizes
+
+ npt.assert_almost_equal(graphic.sizes.value, sizes)
+ npt.assert_almost_equal(
+ graphic.world_object.geometry.sizes.data, graphic.sizes.value
+ )
+
+
+@pytest.mark.parametrize("sizes", [None, 5.0])
+@pytest.mark.parametrize("uniform_size", [True])
+def test_uniform_size(sizes, uniform_size):
+ fig = fpl.Figure()
+
+ kwargs = dict()
+ for kwarg in ["sizes", "uniform_size"]:
+ if locals()[kwarg] is not None:
+ # add to dict of arguments that will be passed
+ kwargs[kwarg] = locals()[kwarg]
+
+ data = generate_positions_spiral_data("xy")
+
+ graphic = fig[0, 0].add_scatter(data=data, **kwargs)
+
+ assert isinstance(graphic.sizes, (float, int))
+ assert isinstance(graphic._sizes, UniformSize)
+
+ if sizes is None:
+ sizes = 1 # default sizes
+
+ npt.assert_almost_equal(graphic.sizes, sizes)
+ npt.assert_almost_equal(graphic.world_object.material.size, sizes)
+
+ # test changing size
+ graphic.sizes = 10.0
+ assert isinstance(graphic.sizes, float)
+ assert isinstance(graphic._sizes, UniformSize)
+ assert graphic.sizes == 10.0
+
+
+@pytest.mark.parametrize("thickness", [None, 0.5, 5.0])
+def test_thickness(thickness):
+ fig = fpl.Figure()
+
+ kwargs = dict()
+ for kwarg in ["thickness"]:
+ if locals()[kwarg] is not None:
+ # add to dict of arguments that will be passed
+ kwargs[kwarg] = locals()[kwarg]
+
+ data = generate_positions_spiral_data("xy")
+
+ graphic = fig[0, 0].add_line(data=data, **kwargs)
+
+ if thickness is None:
+ thickness = 2.0 # default thickness
+
+ assert isinstance(graphic._thickness, Thickness)
+
+ assert graphic.thickness == thickness
+ assert graphic.world_object.material.thickness == thickness
+
+ if thickness == 0.5:
+ assert isinstance(graphic.world_object.material, pygfx.LineThinMaterial)
+
+ else:
+ assert isinstance(graphic.world_object.material, pygfx.LineMaterial)
+
+
+@pytest.mark.parametrize("graphic_type", ["line", "scatter"])
+@pytest.mark.parametrize("size_space", ["screen", "world", "model"])
+def test_size_space(graphic_type, size_space):
+ fig = fpl.Figure()
+
+ kwargs = dict()
+ for kwarg in ["size_space"]:
+ if locals()[kwarg] is not None:
+ # add to dict of arguments that will be passed
+ kwargs[kwarg] = locals()[kwarg]
+
+ data = generate_positions_spiral_data("xy")
+
+ if size_space is None:
+ size_space = "screen" # default space
+
+ # size_space is really an alias for pygfx.utils.enums.CoordSpace
+ if graphic_type == "line":
+ graphic = fig[0, 0].add_line(data=data, **kwargs)
+
+ # test getter
+ assert graphic.world_object.material.thickness_space == size_space
+ assert graphic.size_space == size_space
+
+ # test setter
+ graphic.size_space = "world"
+ assert graphic.size_space == "world"
+ assert graphic.world_object.material.thickness_space == "world"
+
+ elif graphic_type == "scatter":
+
+ # test getter
+ graphic = fig[0, 0].add_scatter(data=data, **kwargs)
+ assert graphic.world_object.material.size_space == size_space
+ assert graphic.size_space == size_space
+
+ # test setter
+ graphic.size_space = "world"
+ assert graphic.size_space == "world"
+ assert graphic.world_object.material.size_space == "world"
diff --git a/tests/test_sizes_buffer_manager.py b/tests/test_sizes_buffer_manager.py
new file mode 100644
index 000000000..2f55eab27
--- /dev/null
+++ b/tests/test_sizes_buffer_manager.py
@@ -0,0 +1,70 @@
+import numpy as np
+from numpy import testing as npt
+import pytest
+
+from fastplotlib.graphics.features import PointsSizesFeature
+from .utils import generate_slice_indices
+
+
+def generate_data(input_type: str) -> np.ndarray | float:
+ """
+ Point sizes varying with a sine wave
+
+ Parameters
+ ----------
+ input_type: str
+ one of "sine", "cosine", or "float"
+ """
+ if input_type == "float":
+ return 10.0
+ xs = np.linspace(0, 10 * np.pi, 10)
+
+ if input_type == "sine":
+ return np.abs(np.sin(xs)).astype(np.float32)
+
+ if input_type == "cosine":
+ return np.abs(np.cos(xs)).astype(np.float32)
+
+
+@pytest.mark.parametrize("data", [generate_data(v) for v in ["float", "sine"]])
+def test_create_buffer(data):
+ sizes = PointsSizesFeature(data, n_datapoints=10)
+
+ if isinstance(data, float):
+ npt.assert_almost_equal(sizes[:], generate_data("float"))
+
+ elif isinstance(data, np.ndarray):
+ npt.assert_almost_equal(sizes[:], generate_data("sine"))
+
+
+@pytest.mark.parametrize(
+ "slice_method", [generate_slice_indices(i) for i in range(0, 16)]
+)
+@pytest.mark.parametrize("user_input", ["float", "cosine"])
+def test_slice(slice_method: dict, user_input: str):
+ data = generate_data("sine")
+
+ s = slice_method["slice"]
+ indices = slice_method["indices"]
+ offset = slice_method["offset"]
+ size = slice_method["size"]
+ others = slice_method["others"]
+
+ sizes = PointsSizesFeature(data, n_datapoints=10)
+
+ match user_input:
+ case "float":
+ sizes[s] = 20.0
+ truth = np.full(len(indices), 20.0)
+ npt.assert_almost_equal(sizes[s], truth)
+ npt.assert_almost_equal(sizes[indices], truth)
+ # make sure other sizes not modified
+ npt.assert_almost_equal(sizes[others], data[others])
+
+ case "cosine":
+ cosine = generate_data("cosine")
+ sizes[s] = cosine[s]
+ npt.assert_almost_equal(sizes[s], cosine[s])
+ npt.assert_almost_equal(sizes[indices], cosine[s])
+ # make sure other sizes not modified
+ npt.assert_almost_equal(sizes[others], data[others])
diff --git a/tests/test_text_graphic.py b/tests/test_text_graphic.py
new file mode 100644
index 000000000..ec3d0be54
--- /dev/null
+++ b/tests/test_text_graphic.py
@@ -0,0 +1,101 @@
+from numpy import testing as npt
+
+import fastplotlib as fpl
+from fastplotlib.graphics.features import (
+ GraphicFeatureEvent,
+ TextData,
+ FontSize,
+ TextFaceColor,
+ TextOutlineColor,
+ TextOutlineThickness,
+)
+
+import pygfx
+
+
+def test_create_graphic():
+ fig = fpl.Figure()
+ data = "lorem ipsum"
+ text = fig[0, 0].add_text(data)
+
+ assert isinstance(text, fpl.TextGraphic)
+
+ assert isinstance(text._text, TextData)
+ assert text.text == data
+
+ assert text.font_size == 14
+ assert isinstance(text._font_size, FontSize)
+ assert text.world_object.font_size == 14
+
+ assert text.face_color == pygfx.Color("w")
+ assert isinstance(text._face_color, TextFaceColor)
+ assert text.world_object.material.color == pygfx.Color("w")
+
+ assert text.outline_color == pygfx.Color("w")
+ assert isinstance(text._outline_color, TextOutlineColor)
+ assert text.world_object.material.outline_color == pygfx.Color("w")
+
+ assert text.outline_thickness == 0
+ assert isinstance(text._outline_thickness, TextOutlineThickness)
+ assert text.world_object.material.outline_thickness == 0
+
+
+EVENT_RETURN_VALUE: GraphicFeatureEvent = None
+
+
+def event_handler(ev):
+ global EVENT_RETURN_VALUE
+ EVENT_RETURN_VALUE = ev
+
+
+def check_event(graphic, feature, value):
+ global EVENT_RETURN_VALUE
+ assert isinstance(EVENT_RETURN_VALUE, GraphicFeatureEvent)
+ assert EVENT_RETURN_VALUE.type == feature
+ assert EVENT_RETURN_VALUE.graphic == graphic
+ assert EVENT_RETURN_VALUE.target == graphic.world_object
+ if isinstance(EVENT_RETURN_VALUE.info["value"], float):
+ # floating point error
+ npt.assert_almost_equal(EVENT_RETURN_VALUE.info["value"], value)
+ else:
+ assert EVENT_RETURN_VALUE.info["value"] == value
+
+
+def test_text_changes_events():
+ fig = fpl.Figure()
+ data = "lorem ipsum"
+ text = fig[0, 0].add_text(data)
+
+ text.add_event_handler(
+ event_handler,
+ "text",
+ "font_size",
+ "face_color",
+ "outline_color",
+ "outline_thickness",
+ )
+
+ text.text = "bah"
+ assert text.text == "bah"
+ # TODO: seems like there isn't a way in pygfx to get the current text as a str?
+ check_event(graphic=text, feature="text", value="bah")
+
+ text.font_size = 10.0
+ assert text.font_size == 10.0
+ assert text.world_object.font_size == 10
+ check_event(text, "font_size", 10)
+
+ text.face_color = "r"
+ assert text.face_color == pygfx.Color("r")
+ assert text.world_object.material.color == pygfx.Color("r")
+ check_event(text, "face_color", pygfx.Color("r"))
+
+ text.outline_color = "b"
+ assert text.outline_color == pygfx.Color("b")
+ assert text.world_object.material.outline_color == pygfx.Color("b")
+ check_event(text, "outline_color", pygfx.Color("b"))
+
+ text.outline_thickness = 0.3
+ npt.assert_almost_equal(text.outline_thickness, 0.3)
+ npt.assert_almost_equal(text.world_object.material.outline_thickness, 0.3)
+ check_event(text, "outline_thickness", 0.3)
diff --git a/tests/test_texture_array.py b/tests/test_texture_array.py
new file mode 100644
index 000000000..6220f2fe5
--- /dev/null
+++ b/tests/test_texture_array.py
@@ -0,0 +1,233 @@
+import numpy as np
+from numpy import testing as npt
+import pytest
+
+import pygfx
+
+import fastplotlib as fpl
+from fastplotlib.graphics.features import TextureArray
+from fastplotlib.graphics.image import _ImageTile
+
+
+MAX_TEXTURE_SIZE = 1024
+
+
+def make_data(n_rows: int, n_cols: int) -> np.ndarray:
+ """
+ Makes a 2D array where the amplitude of the sine wave
+ is increasing along the y-direction (along rows), and
+ the wavelength is increasing along the x-axis (columns)
+ """
+ xs = np.linspace(0, 1_000, n_cols)
+
+ sine = np.sin(np.sqrt(xs))
+
+ return np.vstack([sine * i for i in range(n_rows)]).astype(np.float32)
+
+
+def check_texture_array(
+ data: np.ndarray,
+ ta: TextureArray,
+ buffer_size: int,
+ buffer_shape: tuple[int, int],
+ row_indices_size: int,
+ col_indices_size: int,
+ row_indices_values: np.ndarray,
+ col_indices_values: np.ndarray,
+):
+
+ npt.assert_almost_equal(ta.value, data)
+
+ assert ta.buffer.size == buffer_size
+ assert ta.buffer.shape == buffer_shape
+
+ assert all([isinstance(texture, pygfx.Texture) for texture in ta.buffer.ravel()])
+
+ assert ta.row_indices.size == row_indices_size
+ assert ta.col_indices.size == col_indices_size
+ npt.assert_array_equal(ta.row_indices, row_indices_values)
+ npt.assert_array_equal(ta.col_indices, col_indices_values)
+
+ # make sure chunking is correct
+ for texture, chunk_index, data_slice in ta:
+ assert ta.buffer[chunk_index] is texture
+ chunk_row, chunk_col = chunk_index
+
+ data_row_start_index = chunk_row * MAX_TEXTURE_SIZE
+ data_col_start_index = chunk_col * MAX_TEXTURE_SIZE
+
+ data_row_stop_index = min(
+ data.shape[0], data_row_start_index + MAX_TEXTURE_SIZE
+ )
+ data_col_stop_index = min(
+ data.shape[1], data_col_start_index + MAX_TEXTURE_SIZE
+ )
+
+ row_slice = slice(data_row_start_index, data_row_stop_index)
+ col_slice = slice(data_col_start_index, data_col_stop_index)
+
+ assert data_slice == (row_slice, col_slice)
+
+
+def check_set_slice(data, ta, row_slice, col_slice):
+ ta[row_slice, col_slice] = 1
+ npt.assert_almost_equal(ta[row_slice, col_slice], 1)
+
+ # make sure other vals unchanged
+ npt.assert_almost_equal(ta[: row_slice.start], data[: row_slice.start])
+ npt.assert_almost_equal(ta[row_slice.stop :], data[row_slice.stop :])
+ npt.assert_almost_equal(ta[:, : col_slice.start], data[:, : col_slice.start])
+ npt.assert_almost_equal(ta[:, col_slice.stop :], data[:, col_slice.stop :])
+
+
+def make_image_graphic(data) -> fpl.ImageGraphic:
+ fig = fpl.Figure()
+ return fig[0, 0].add_image(data)
+
+
+def check_image_graphic(texture_array, graphic):
+ # make sure each ImageTile has the right texture
+ for (texture, chunk_index, data_slice), img in zip(
+ texture_array, graphic.world_object.children
+ ):
+ assert isinstance(img, _ImageTile)
+ assert img.geometry.grid is texture
+ assert img.world.x == data_slice[1].start
+ assert img.world.y == data_slice[0].start
+
+
+@pytest.mark.parametrize("test_graphic", [False, True])
+def test_small_texture(test_graphic):
+ # tests TextureArray with dims that requires only 1 texture
+ data = make_data(500, 500)
+
+ if test_graphic:
+ graphic = make_image_graphic(data)
+ ta = graphic.data
+ else:
+ ta = TextureArray(data)
+
+ check_texture_array(
+ data=data,
+ ta=ta,
+ buffer_size=1,
+ buffer_shape=(1, 1),
+ row_indices_size=1,
+ col_indices_size=1,
+ row_indices_values=np.array([0]),
+ col_indices_values=np.array([0]),
+ )
+
+ if test_graphic:
+ check_image_graphic(ta, graphic)
+
+ check_set_slice(data, ta, slice(50, 200), slice(200, 400))
+
+
+@pytest.mark.parametrize("test_graphic", [False, True])
+def test_texture_at_limit(test_graphic):
+ # tests TextureArray with data that is 1024 x 1024
+ data = make_data(MAX_TEXTURE_SIZE, MAX_TEXTURE_SIZE)
+
+ if test_graphic:
+ graphic = make_image_graphic(data)
+ ta = graphic.data
+ else:
+ ta = TextureArray(data)
+
+ check_texture_array(
+ data,
+ ta=ta,
+ buffer_size=1,
+ buffer_shape=(1, 1),
+ row_indices_size=1,
+ col_indices_size=1,
+ row_indices_values=np.array([0]),
+ col_indices_values=np.array([0]),
+ )
+
+ if test_graphic:
+ check_image_graphic(ta, graphic)
+
+ check_set_slice(data, ta, slice(500, 800), slice(200, 300))
+
+
+@pytest.mark.parametrize("test_graphic", [False, True])
+def test_wide(test_graphic):
+ data = make_data(1_200, 2_200)
+
+ if test_graphic:
+ graphic = make_image_graphic(data)
+ ta = graphic.data
+ else:
+ ta = TextureArray(data)
+
+ check_texture_array(
+ data,
+ ta=ta,
+ buffer_size=6,
+ buffer_shape=(2, 3),
+ row_indices_size=2,
+ col_indices_size=3,
+ row_indices_values=np.array([0, MAX_TEXTURE_SIZE]),
+ col_indices_values=np.array([0, MAX_TEXTURE_SIZE, 2 * MAX_TEXTURE_SIZE]),
+ )
+
+ if test_graphic:
+ check_image_graphic(ta, graphic)
+
+ check_set_slice(data, ta, slice(600, 1_100), slice(100, 2_100))
+
+
+@pytest.mark.parametrize("test_graphic", [False, True])
+def test_tall(test_graphic):
+ data = make_data(2_200, 1_200)
+
+ if test_graphic:
+ graphic = make_image_graphic(data)
+ ta = graphic.data
+ else:
+ ta = TextureArray(data)
+
+ check_texture_array(
+ data,
+ ta=ta,
+ buffer_size=6,
+ buffer_shape=(3, 2),
+ row_indices_size=3,
+ col_indices_size=2,
+ row_indices_values=np.array([0, MAX_TEXTURE_SIZE, 2 * MAX_TEXTURE_SIZE]),
+ col_indices_values=np.array([0, MAX_TEXTURE_SIZE]),
+ )
+
+ if test_graphic:
+ check_image_graphic(ta, graphic)
+
+ check_set_slice(data, ta, slice(100, 2_100), slice(600, 1_100))
+
+
+@pytest.mark.parametrize("test_graphic", [False, True])
+def test_square(test_graphic):
+ data = make_data(2_200, 2_200)
+
+ if test_graphic:
+ graphic = make_image_graphic(data)
+ ta = graphic.data
+ else:
+ ta = TextureArray(data)
+
+ check_texture_array(
+ data,
+ ta=ta,
+ buffer_size=9,
+ buffer_shape=(3, 3),
+ row_indices_size=3,
+ col_indices_size=3,
+ row_indices_values=np.array([0, MAX_TEXTURE_SIZE, 2 * MAX_TEXTURE_SIZE]),
+ col_indices_values=np.array([0, MAX_TEXTURE_SIZE, 2 * MAX_TEXTURE_SIZE]),
+ )
+
+ if test_graphic:
+ check_image_graphic(ta, graphic)
+
+ check_set_slice(data, ta, slice(100, 2_100), slice(100, 2_100))
diff --git a/tests/utils.py b/tests/utils.py
new file mode 100644
index 000000000..bc9a092c8
--- /dev/null
+++ b/tests/utils.py
@@ -0,0 +1,174 @@
+import numpy as np
+
+import pygfx
+
+
+def generate_slice_indices(kind: int):
+ n_elements = 10
+ a = np.arange(n_elements)
+
+ match kind:
+ case 0:
+ # simplest, just int
+ s = 2
+ indices = [2]
+
+ case 1:
+ # everything, [:]
+ s = slice(None, None, None)
+ indices = list(range(10))
+
+ case 2:
+ # positive continuous range, [1:5]
+ s = slice(1, 5, None)
+ indices = [1, 2, 3, 4]
+
+ case 3:
+ # positive stepped range, [2:8:2]
+ s = slice(2, 8, 2)
+ indices = [2, 4, 6]
+
+ case 4:
+ # negative continuous range, [-5:]
+ s = slice(-5, None, None)
+ indices = [5, 6, 7, 8, 9]
+
+ case 5:
+ # negative backwards, [-5::-1]
+ s = slice(-5, None, -1)
+ indices = [5, 4, 3, 2, 1, 0]
+
+ case 5:
+ # negative backwards stepped, [-5::-2]
+ s = slice(-5, None, -2)
+ indices = [5, 3, 1]
+
+ case 6:
+ # negative stepped forward[-5::2]
+ s = slice(-5, None, 2)
+ indices = [5, 7, 9]
+
+ case 7:
+ # both negative, [-8:-2]
+ s = slice(-8, -2, None)
+ indices = [2, 3, 4, 5, 6, 7]
+
+ case 8:
+ # both negative and stepped, [-8:2:2]
+ s = slice(-8, -2, 2)
+ indices = [2, 4, 6]
+
+ case 9:
+ # positive, negative, negative, [8:-9:-2]
+ s = slice(8, -9, -2)
+ indices = [8, 6, 4, 2]
+
+ case 10:
+ # only stepped forward, [::2]
+ s = slice(None, None, 2)
+ indices = [0, 2, 4, 6, 8]
+
+ case 11:
+ # only stepped backward, [::-3]
+ s = slice(None, None, -3)
+ indices = [9, 6, 3, 0]
+
+ case 12:
+ # list indices
+ s = [2, 5, 9]
+ indices = [2, 5, 9]
+
+ case 13:
+ # bool indices
+ s = a > 5
+ indices = [6, 7, 8, 9]
+
+ case 14:
+ # list indices with negatives
+ s = [1, 4, -2]
+ indices = [1, 4, 8]
+
+ case 15:
+ # array indices
+ s = np.array([1, 4, -7, 9])
+ indices = [1, 4, 3, 9]
+
+ others = [i for i in a if i not in indices]
+
+ offset, size = (min(indices), np.ptp(indices) + 1)
+
+ return {
+ "slice": s,
+ "indices": indices,
+ "others": others,
+ "offset": offset,
+ "size": size,
+ }
+
+
+def generate_positions_spiral_data(inputs: str) -> np.ndarray:
+ """
+ Generates a spiral/spring
+
+ Only 10 points so a very pointy spiral but easier to spot changes :D
+ """
+ xs = np.linspace(0, 10 * np.pi, 10)
+ ys = np.sin(xs)
+ zs = np.cos(xs)
+
+ match inputs:
+ case "y":
+ data = ys
+
+ case "xy":
+ data = np.column_stack([xs, ys])
+
+ case "xyz":
+ data = np.column_stack([xs, ys, zs])
+
+ return data.astype(np.float32)
+
+
+def generate_color_inputs(
+ name: str,
+) -> list[str, np.ndarray, list, tuple] | list[str, np.ndarray]:
+ if name == "multi":
+ s = [
+ "r",
+ "g",
+ "b",
+ "cyan",
+ "magenta",
+ "green",
+ "yellow",
+ "white",
+ "purple",
+ "orange",
+ ]
+ array = np.vstack([pygfx.Color(c) for c in s])
+ return [s, array]
+
+ color = pygfx.Color(name)
+
+ s = name
+ a = np.array(color)
+ l = list(color)
+ t = tuple(color)
+
+ return [s, a, l, t]
+
+
+MULTI_COLORS_TRUTH = np.array(
+ [
+ [1.0, 0.0, 0.0, 1.0],
+ [0.0, 1.0, 0.0, 1.0],
+ [0.0, 0.0, 1.0, 1.0],
+ [0.0, 1.0, 1.0, 1.0],
+ [1.0, 0.0, 1.0, 1.0],
+ [0.0, 0.501960813999176, 0.0, 1.0],
+ [1.0, 1.0, 0.0, 1.0],
+ [1.0, 1.0, 1.0, 1.0],
+ [0.501960813999176, 0.0, 0.501960813999176, 1.0],
+ [1.0, 0.6470588445663452, 0.0, 1.0],
+ ]
+)
pFad - Phonifier reborn
Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.
Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.
Alternative Proxies:
Alternative Proxy
pFad Proxy
pFad v3 Proxy
pFad v4 Proxy
