"
@@ -1052,7 +1096,7 @@
{
"data": {
"application/vnd.jupyter.widget-view+json": {
- "model_id": "cc57fd6c0807411bbde07b968fe7deef",
+ "model_id": "c138433d6890443faeab644cc5521b0d",
"version_major": 2,
"version_minor": 0
},
@@ -1060,7 +1104,7 @@
"JupyterWgpuCanvas()"
]
},
- "execution_count": 26,
+ "execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
@@ -1111,7 +1155,7 @@
},
{
"cell_type": "code",
- "execution_count": 27,
+ "execution_count": 31,
"id": "8fa46ec0-8680-44f5-894c-559de3145932",
"metadata": {},
"outputs": [],
@@ -1122,7 +1166,7 @@
},
{
"cell_type": "code",
- "execution_count": 28,
+ "execution_count": 32,
"id": "e4dc71e4-5144-436f-a464-f2a29eee8f0b",
"metadata": {},
"outputs": [],
@@ -1133,7 +1177,7 @@
},
{
"cell_type": "code",
- "execution_count": 29,
+ "execution_count": 33,
"id": "5b637a29-cd5e-4011-ab81-3f91490d9ecd",
"metadata": {},
"outputs": [],
@@ -1144,7 +1188,7 @@
},
{
"cell_type": "code",
- "execution_count": 30,
+ "execution_count": 34,
"id": "a4084fce-78a2-48b3-9a0d-7b57c165c3c1",
"metadata": {},
"outputs": [],
@@ -1155,7 +1199,7 @@
},
{
"cell_type": "code",
- "execution_count": 31,
+ "execution_count": 35,
"id": "f486083e-7c58-4255-ae1a-3fe5d9bfaeed",
"metadata": {},
"outputs": [],
@@ -1176,19 +1220,19 @@
},
{
"cell_type": "code",
- "execution_count": 32,
+ "execution_count": 36,
"id": "f404a5ea-633b-43f5-87d1-237017bbca2a",
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
- "model_id": "62aa7a1eb8794301912c4f2da74abb25",
+ "model_id": "38cd7d8eacf3493c9bddd01ee3ec40f4",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
- "VBox(children=(HBox(children=(JupyterWgpuCanvas(frame_feedback={'index': 2402, 'timestamp': 1671971185.3935852…"
+ "VBox(children=(HBox(children=(JupyterWgpuCanvas(frame_feedback={'index': 123, 'timestamp': 1671994226.4736164,…"
]
},
"metadata": {},
diff --git a/fastplotlib/graphics/_base.py b/fastplotlib/graphics/_base.py
index a1a2633b9..3cf358451 100644
--- a/fastplotlib/graphics/_base.py
+++ b/fastplotlib/graphics/_base.py
@@ -1,63 +1,33 @@
from typing import *
-import pygfx
+from pygfx import WorldObject
+from pygfx.linalg import Vector3
-from ..utils import get_colors
-from .features import GraphicFeature, DataFeature, ColorFeature, PresentFeature
+from .features import GraphicFeature, PresentFeature
-class Graphic:
+class BaseGraphic:
+ def __init_subclass__(cls, **kwargs):
+ """set the type of the graphic in lower case like "image", "line_collection", etc."""
+ cls.type = cls.__name__.lower().replace("graphic", "").replace("collection", "_collection")
+ super().__init_subclass__(**kwargs)
+
+
+class Graphic(BaseGraphic):
def __init__(
self,
- data,
- colors: Any = False,
- n_colors: int = None,
- cmap: str = None,
- alpha: float = 1.0,
name: str = None
):
"""
Parameters
----------
- data: array-like
- data to show in the graphic, must be float32.
- Automatically converted to float32 for numpy arrays.
- Tensorflow Tensors also work but this is not fully
- tested and might not be supported in the future.
-
- colors: Any
- if ``False``, no color generation is performed, cmap is also ignored.
-
- n_colors
-
- cmap: str
- name of colormap to use
-
- alpha: float, optional
- alpha value for the colors
-
name: str, optional
name this graphic, makes it indexable within plots
"""
- # self.data = data.astype(np.float32)
- self.data = DataFeature(parent=self, data=data, graphic_name=self.__class__.__name__)
- self.colors = None
self.name = name
-
- if n_colors is None:
- n_colors = self.data.feature_data.shape[0]
-
- if cmap is not None and colors is not False:
- colors = get_colors(n_colors=n_colors, cmap=cmap, alpha=alpha)
-
- if colors is not False:
- self.colors = ColorFeature(parent=self, colors=colors, n_colors=n_colors, alpha=alpha)
-
- # different from visible, toggles the Graphic presence in the Scene
- # useful for bbox calculations to ignore these Graphics
self.present = PresentFeature(parent=self)
valid_features = ["visible"]
@@ -69,9 +39,14 @@ def __init__(
self._valid_features = tuple(valid_features)
@property
- def world_object(self) -> pygfx.WorldObject:
+ def world_object(self) -> WorldObject:
return self._world_object
+ @property
+ def position(self) -> Vector3:
+ """The position of the graphic"""
+ return self.world_object.position
+
@property
def interact_features(self) -> Tuple[str]:
"""The features for this ``Graphic`` that support interaction."""
@@ -87,7 +62,7 @@ def visible(self, v):
self.world_object.visible = v
@property
- def children(self) -> pygfx.WorldObject:
+ def children(self) -> WorldObject:
return self.world_object.children
def __setattr__(self, key, value):
diff --git a/fastplotlib/graphics/features/__init__.py b/fastplotlib/graphics/features/__init__.py
index 2c489c94f..1fcb71246 100644
--- a/fastplotlib/graphics/features/__init__.py
+++ b/fastplotlib/graphics/features/__init__.py
@@ -1,4 +1,4 @@
-from ._colors import ColorFeature
-from ._data import DataFeature
+from ._colors import ColorFeature, CmapFeature, ImageCmapFeature
+from ._data import PointsDataFeature, ImageDataFeature
from ._present import PresentFeature
from ._base import GraphicFeature
diff --git a/fastplotlib/graphics/features/_base.py b/fastplotlib/graphics/features/_base.py
index 9292f4944..519bf40d0 100644
--- a/fastplotlib/graphics/features/_base.py
+++ b/fastplotlib/graphics/features/_base.py
@@ -90,6 +90,22 @@ def _call_event_handlers(self, event_data: FeatureEvent):
def cleanup_slice(key: Union[int, slice], upper_bound) -> Union[slice, int]:
+ """
+
+ If the key in an `int`, it just returns it. Otherwise,
+ it parses it and removes the `None` vals and replaces
+ them with corresponding values that can be used to
+ create a `range`, get `len` etc.
+
+ Parameters
+ ----------
+ key
+ upper_bound
+
+ Returns
+ -------
+
+ """
if isinstance(key, int):
return key
@@ -157,7 +173,7 @@ def _upper_bound(self) -> int:
return self.feature_data.shape[0]
def _update_range_indices(self, key):
- """Currently used by colors and data"""
+ """Currently used by colors and positions data"""
key = cleanup_slice(key, self._upper_bound)
if isinstance(key, int):
@@ -178,5 +194,3 @@ def _update_range_indices(self, key):
self._buffer.update_range(ix, size=1)
else:
raise TypeError("must pass int or slice to update range")
-
-
diff --git a/fastplotlib/graphics/features/_colors.py b/fastplotlib/graphics/features/_colors.py
index f45f99040..afb0d85a8 100644
--- a/fastplotlib/graphics/features/_colors.py
+++ b/fastplotlib/graphics/features/_colors.py
@@ -1,6 +1,7 @@
import numpy as np
-from ._base import GraphicFeatureIndexable, cleanup_slice, FeatureEvent
+from ._base import GraphicFeature, GraphicFeatureIndexable, cleanup_slice, FeatureEvent
+from ...utils import get_colors, get_cmap_texture
from pygfx import Color
@@ -15,7 +16,7 @@ def __getitem__(self, item):
def __repr__(self):
return repr(self._buffer.data)
- def __init__(self, parent, colors, n_colors, alpha: float = 1.0):
+ def __init__(self, parent, colors, n_colors: int, alpha: float = 1.0):
"""
ColorFeature
@@ -27,7 +28,12 @@ def __init__(self, parent, colors, n_colors, alpha: float = 1.0):
specify colors as a single human readable string, RGBA array,
or an iterable of strings or RGBA arrays
- n_colors: number of colors to hold, if passing in a single str or single RGBA array
+ n_colors: int
+ number of colors to hold, if passing in a single str or single RGBA array
+
+ alpha: float
+ alpha value for the colors
+
"""
# if provided as a numpy array of str
if isinstance(colors, np.ndarray):
@@ -185,3 +191,55 @@ def _feature_changed(self, key, new_data):
event_data = FeatureEvent(type="color-changed", pick_info=pick_info)
self._call_event_handlers(event_data)
+
+
+class CmapFeature(ColorFeature):
+ """
+ Indexable colormap feature, mostly wraps colors and just provides a way to set colormaps.
+ """
+ def __init__(self, parent, colors):
+ super(ColorFeature, self).__init__(parent, colors)
+
+ def __setitem__(self, key, value):
+ key = cleanup_slice(key, self._upper_bound)
+ if not isinstance(key, slice):
+ raise TypeError("Cannot set cmap on single indices, must pass a slice object or "
+ "set it on the entire data.")
+
+ n_colors = len(range(key.start, key.stop, key.step))
+
+ colors = get_colors(n_colors, cmap=value)
+ super(CmapFeature, self).__setitem__(key, colors)
+
+
+class ImageCmapFeature(GraphicFeature):
+ """
+ Colormap for ImageGraphic
+ """
+ def __init__(self, parent, cmap: str):
+ cmap_texture_view = get_cmap_texture(cmap)
+ super(ImageCmapFeature, self).__init__(parent, cmap_texture_view)
+ self.name = cmap
+
+ def _set(self, cmap_name: str):
+ self._parent.world_object.material.map.texture.data[:] = get_colors(256, cmap_name)
+ self._parent.world_object.material.map.texture.update_range((0, 0, 0), size=(256, 1, 1))
+ self.name = cmap_name
+
+ self._feature_changed(key=None, new_data=self.name)
+
+ def __repr__(self):
+ return repr(self.name)
+
+ def _feature_changed(self, key, new_data):
+ # this is a non-indexable feature so key=None
+
+ pick_info = {
+ "index": None,
+ "world_object": self._parent.world_object,
+ "new_data": new_data
+ }
+
+ event_data = FeatureEvent(type="cmap-changed", pick_info=pick_info)
+
+ self._call_event_handlers(event_data)
diff --git a/fastplotlib/graphics/features/_data.py b/fastplotlib/graphics/features/_data.py
index 6e1feac2a..1839bd9a1 100644
--- a/fastplotlib/graphics/features/_data.py
+++ b/fastplotlib/graphics/features/_data.py
@@ -1,32 +1,30 @@
-from ._base import GraphicFeatureIndexable, cleanup_slice, FeatureEvent
-from pygfx import Buffer
from typing import *
-from ...utils import fix_data, to_float32
+
+import numpy as np
+from pygfx import Buffer, Texture
+
+from ._base import GraphicFeatureIndexable, cleanup_slice, FeatureEvent
-class DataFeature(GraphicFeatureIndexable):
+def to_float32(array):
+ if isinstance(array, np.ndarray):
+ return array.astype(np.float32, copy=False)
+
+ return array
+
+
+class PointsDataFeature(GraphicFeatureIndexable):
"""
- Access to the buffer data being shown in the graphic.
- Supports fancy indexing if the data array also does.
+ Access to the vertex buffer data shown in the graphic.
+ Supports fancy indexing if the data array also supports it.
"""
- # the correct data buffer is search for in this order
- data_buffer_names = ["grid", "positions"]
-
- def __init__(self, parent, data: Any, graphic_name):
- data = fix_data(data, graphic_name=graphic_name)
- self.graphic_name = graphic_name
- super(DataFeature, self).__init__(parent, data)
+ def __init__(self, parent, data: Any):
+ data = self._fix_data(data, parent)
+ super(PointsDataFeature, self).__init__(parent, data)
@property
def _buffer(self) -> Buffer:
- buffer = getattr(self._parent.world_object.geometry, self._buffer_name)
- return buffer
-
- @property
- def _buffer_name(self) -> str:
- for buffer_name in self.data_buffer_names:
- if hasattr(self._parent.world_object.geometry, buffer_name):
- return buffer_name
+ return self._parent.world_object.geometry.positions
def __repr__(self):
return repr(self._buffer.data)
@@ -34,31 +32,103 @@ def __repr__(self):
def __getitem__(self, item):
return self._buffer.data[item]
+ def _fix_data(self, data, parent):
+ graphic_type = parent.__class__.__name__
+
+ if data.ndim == 1:
+ # for scatter if we receive just 3 points in a 1d array, treat it as just a single datapoint
+ # this is different from fix_data for LineGraphic since there we assume that a 1d array
+ # is just y-values
+ if graphic_type == "ScatterGraphic":
+ data = np.array([data])
+ elif graphic_type == "LineGraphic":
+ data = np.dstack([np.arange(data.size), data])[0].astype(np.float32)
+
+ if data.shape[1] != 3:
+ if data.shape[1] != 2:
+ raise ValueError(f"Must pass 1D, 2D or 3D data to {graphic_type}")
+
+ # zeros for z
+ zs = np.zeros(data.shape[0], dtype=np.float32)
+
+ data = np.dstack([data[:, 0], data[:, 1], zs])[0]
+
+ return data
+
def __setitem__(self, key, value):
+ # put data into right shape if they're only indexing datapoints
if isinstance(key, (slice, int)):
- # data must be provided in the right shape
- value = fix_data(value, graphic_name=self.graphic_name)
- else:
- # otherwise just make sure float32
- value = to_float32(value)
+ value = self._fix_data(value, self._parent)
+ # otherwise assume that they have the right shape
+ # numpy will throw errors if it can't broadcast
+
self._buffer.data[key] = value
self._update_range(key)
+ # avoid creating dicts constantly if there are no events to handle
+ if len(self._event_handlers) > 0:
+ self._feature_changed(key, value)
def _update_range(self, key):
- if self._buffer_name == "grid":
- self._update_range_grid(key)
- self._feature_changed(key=None, new_data=None)
- elif self._buffer_name == "positions":
- self._update_range_indices(key)
- self._feature_changed(key=key, new_data=None)
+ self._update_range_indices(key)
+
+ def _feature_changed(self, key, new_data):
+ if key is not None:
+ key = cleanup_slice(key, self._upper_bound)
+ if isinstance(key, int):
+ indices = [key]
+ elif isinstance(key, slice):
+ indices = range(key.start, key.stop, key.step)
+ elif key is None:
+ indices = None
+
+ pick_info = {
+ "index": indices,
+ "world_object": self._parent.world_object,
+ "new_data": new_data
+ }
+
+ event_data = FeatureEvent(type="data-changed", pick_info=pick_info)
+
+ self._call_event_handlers(event_data)
- def _update_range_grid(self, key):
- # image data
- self._buffer.update_range((0, 0, 0), self._buffer.size)
+
+class ImageDataFeature(GraphicFeatureIndexable):
+ """
+ Access to the TextureView buffer shown in an ImageGraphic.
+ """
+
+ def __init__(self, parent, data: Any):
+ if data.ndim != 2:
+ raise ValueError("`data.ndim !=2`, you must pass only a 2D array to an Image graphic")
+
+ data = to_float32(data)
+ super(ImageDataFeature, self).__init__(parent, data)
+
+ @property
+ def _buffer(self) -> Texture:
+ return self._parent.world_object.geometry.grid.texture
+
+ def __repr__(self):
+ return repr(self._buffer.data)
+
+ def __getitem__(self, item):
+ return self._buffer.data[item]
+
+ def __setitem__(self, key, value):
+ # make sure float32
+ value = to_float32(value)
+
+ self._buffer.data[key] = value
+ self._update_range(key)
+
+ # avoid creating dicts constantly if there are no events to handle
+ if len(self._event_handlers) > 0:
+ self._feature_changed(key, value)
+
+ def _update_range(self, key):
+ self._buffer.update_range((0, 0, 0), size=self._buffer.size)
def _feature_changed(self, key, new_data):
- # for now if key=None that means all data changed, i.e. ImageGraphic
- # also for now new data isn't stored for DataFeature
if key is not None:
key = cleanup_slice(key, self._upper_bound)
if isinstance(key, int):
diff --git a/fastplotlib/graphics/image.py b/fastplotlib/graphics/image.py
index 77c531c8a..48459c63e 100644
--- a/fastplotlib/graphics/image.py
+++ b/fastplotlib/graphics/image.py
@@ -1,10 +1,10 @@
from typing import *
-import numpy as np
import pygfx
from ._base import Graphic
-from ..utils import quick_min_max, get_cmap_texture
+from .features import ImageCmapFeature, ImageDataFeature
+from ..utils import quick_min_max
class ImageGraphic(Graphic):
@@ -14,6 +14,7 @@ def __init__(
vmin: int = None,
vmax: int = None,
cmap: str = 'plasma',
+ filter: str = "nearest",
*args,
**kwargs
):
@@ -32,10 +33,15 @@ def __init__(
vmax: int, optional
maximum value for color scaling, calculated from data if not provided
- cmap: str, optional
+ cmap: str, optional, default "nearest"
colormap to use to display the image data, default is ``"plasma"``
+
+ filter: str, optional, default "nearest"
+ interpolation filter, one of "nearest" or "linear"
+
args:
additional arguments passed to Graphic
+
kwargs:
additional keyword arguments passed to Graphic
@@ -59,23 +65,41 @@ def __init__(
plot.show()
"""
- if data.ndim != 2:
- raise ValueError("`data.ndim !=2`, you must pass only a 2D array to `data`")
- super().__init__(data, cmap=cmap, *args, **kwargs)
+ super().__init__(*args, **kwargs)
+
+ self.data = ImageDataFeature(self, data)
if (vmin is None) or (vmax is None):
vmin, vmax = quick_min_max(data)
+ self.cmap = ImageCmapFeature(self, cmap)
+
+ texture_view = pygfx.Texture(self.data.feature_data, dim=2).get_view(filter=filter)
+
self._world_object: pygfx.Image = pygfx.Image(
- pygfx.Geometry(grid=pygfx.Texture(self.data.feature_data, dim=2)),
- pygfx.ImageBasicMaterial(clim=(vmin, vmax), map=get_cmap_texture(cmap))
+ pygfx.Geometry(grid=texture_view),
+ pygfx.ImageBasicMaterial(clim=(vmin, vmax), map=self.cmap.feature_data)
)
@property
- def clim(self) -> Tuple[float, float]:
- return self.world_object.material.clim
+ def vmin(self) -> float:
+ return self.world_object.material.clim[0]
+
+ @vmin.setter
+ def vmin(self, value: float):
+ self.world_object.material.clim = (
+ value,
+ self.world_object.material.clim[1]
+ )
- @clim.setter
- def clim(self, levels: Tuple[float, float]):
- self.world_object.material.clim = levels
+ @property
+ def vmax(self) -> float:
+ return self.world_object.material.clim[1]
+
+ @vmax.setter
+ def vmax(self, value: float):
+ self.world_object.material.clim = (
+ self.world_object.material.clim[0],
+ value
+ )
diff --git a/fastplotlib/graphics/line.py b/fastplotlib/graphics/line.py
index edf99e43c..e53eb9203 100644
--- a/fastplotlib/graphics/line.py
+++ b/fastplotlib/graphics/line.py
@@ -3,16 +3,19 @@
import pygfx
from ._base import Graphic
+from .features import PointsDataFeature, ColorFeature, CmapFeature
+from ..utils import get_colors
class LineGraphic(Graphic):
def __init__(
self,
data: Any,
- z_position: float = 0.0,
size: float = 2.0,
colors: Union[str, np.ndarray, Iterable] = "w",
+ alpha: float = 1.0,
cmap: str = None,
+ z_position: float = 0.0,
*args,
**kwargs
):
@@ -24,34 +27,46 @@ def __init__(
data: array-like
Line data to plot, 2D must be of shape [n_points, 2], 3D must be of shape [n_points, 3]
- z_position: float, optional
- z-axis position for placing the graphic
-
- size: float, optional
+ size: float, optional, default 2.0
thickness of the line
- colors: str, array, or iterable
+ colors: str, array, or iterable, default "w"
specify colors as a single human readable string, a single RGBA array,
or an iterable of strings or RGBA arrays
cmap: str, optional
- apply a colormap to the line instead of assigning colors manually
+ apply a colormap to the line instead of assigning colors manually, this
+ overrides any argument passed to "colors"
+
+ alpha: float, optional, default 1.0
+ alpha value for the colors
+
+ z_position: float, optional
+ z-axis position for placing the graphic
args
passed to Graphic
+
kwargs
passed to Graphic
+
"""
- super(LineGraphic, self).__init__(data, colors=colors, cmap=cmap, *args, **kwargs)
+ self.data = PointsDataFeature(self, data)
+
+ if cmap is not None:
+ colors = get_colors(n_colors=self.data.feature_data.shape[0], cmap=cmap, alpha=alpha)
+
+ self.colors = ColorFeature(self, colors, n_colors=self.data.feature_data.shape[0], alpha=alpha)
+ self.cmap = CmapFeature(self, self.colors.feature_data)
+
+ super(LineGraphic, self).__init__(*args, **kwargs)
if size < 1.1:
material = pygfx.LineThinMaterial
else:
material = pygfx.LineMaterial
- # self.data = np.ascontiguousarray(self.data)
-
self._world_object: pygfx.Line = pygfx.Line(
# self.data.feature_data because data is a Buffer
geometry=pygfx.Geometry(positions=self.data.feature_data, colors=self.colors.feature_data),
diff --git a/fastplotlib/graphics/linecollection.py b/fastplotlib/graphics/linecollection.py
index ec4b1e4dd..cfdf5389f 100644
--- a/fastplotlib/graphics/linecollection.py
+++ b/fastplotlib/graphics/linecollection.py
@@ -1,11 +1,12 @@
import numpy as np
import pygfx
from typing import Union
+from ._base import BaseGraphic
from .line import LineGraphic
from typing import *
-class LineCollection():
+class LineCollection(BaseGraphic):
def __init__(self, data: List[np.ndarray], z_position: Union[List[float], float] = None, size: Union[float, List[float]] = 2.0, colors: Union[List[np.ndarray], np.ndarray] = None,
cmap: Union[List[str], str] = None, *args, **kwargs):
diff --git a/fastplotlib/graphics/scatter.py b/fastplotlib/graphics/scatter.py
index 0ea5a8831..a1083d132 100644
--- a/fastplotlib/graphics/scatter.py
+++ b/fastplotlib/graphics/scatter.py
@@ -4,11 +4,61 @@
import pygfx
from ._base import Graphic
+from .features import PointsDataFeature, ColorFeature, CmapFeature
+from ..utils import get_colors
class ScatterGraphic(Graphic):
- def __init__(self, data: np.ndarray, z_position: float = 0.0, sizes: Union[int, np.ndarray, list] = 1, colors: np.ndarray = "w", cmap: str = None, *args, **kwargs):
- super(ScatterGraphic, self).__init__(data, colors=colors, cmap=cmap, *args, **kwargs)
+ def __init__(
+ self,
+ data: np.ndarray,
+ sizes: Union[int, np.ndarray, list] = 1,
+ colors: np.ndarray = "w",
+ alpha: float = 1.0,
+ cmap: str = None,
+ z_position: float = 0.0,
+ *args,
+ **kwargs
+ ):
+ """
+ Create a Scatter Graphic, 2d or 3d
+
+ Parameters
+ ----------
+ data: array-like
+ Scatter data to plot, 2D must be of shape [n_points, 2], 3D must be of shape [n_points, 3]
+
+ sizes: float or iterable of float, optional, default 1.0
+ size of the scatter points
+
+ colors: str, array, or iterable, default "w"
+ specify colors as a single human readable string, a single RGBA array,
+ or an iterable of strings or RGBA arrays
+
+ cmap: str, optional
+ apply a colormap to the scatter instead of assigning colors manually, this
+ overrides any argument passed to "colors"
+
+ alpha: float, optional, default 1.0
+ alpha value for the colors
+
+ z_position: float, optional
+ z-axis position for placing the graphic
+
+ args
+ passed to Graphic
+
+ kwargs
+ passed to Graphic
+
+ """
+ self.data = PointsDataFeature(self, data)
+
+ if cmap is not None:
+ colors = get_colors(n_colors=self.data.feature_data.shape[0], cmap=cmap, alpha=alpha)
+
+ self.colors = ColorFeature(self, colors, n_colors=self.data.feature_data.shape[0], alpha=alpha)
+ self.cmap = CmapFeature(self, self.colors.feature_data)
if isinstance(sizes, int):
sizes = np.full(self.data.feature_data.shape[0], sizes, dtype=np.float32)
@@ -20,6 +70,8 @@ def __init__(self, data: np.ndarray, z_position: float = 0.0, sizes: Union[int,
if len(sizes) != self.data.feature_data.shape[0]:
raise ValueError("list of `sizes` must have the same length as the number of datapoints")
+ super(ScatterGraphic, self).__init__(*args, **kwargs)
+
self._world_object: pygfx.Points = pygfx.Points(
pygfx.Geometry(positions=self.data.feature_data, sizes=sizes, colors=self.colors.feature_data),
material=pygfx.PointsMaterial(vertex_colors=True, vertex_sizes=True)
diff --git a/fastplotlib/graphics/text.py b/fastplotlib/graphics/text.py
index ed47bd270..0096e102c 100644
--- a/fastplotlib/graphics/text.py
+++ b/fastplotlib/graphics/text.py
@@ -2,8 +2,10 @@
import pygfx
import numpy as np
+from ._base import BaseGraphic
-class TextGraphic:
+
+class TextGraphic(BaseGraphic):
def __init__(
self,
text: str,
diff --git a/fastplotlib/layouts/_subplot.py b/fastplotlib/layouts/_subplot.py
index c8e8d2b23..7a0e923de 100644
--- a/fastplotlib/layouts/_subplot.py
+++ b/fastplotlib/layouts/_subplot.py
@@ -6,7 +6,7 @@
from warnings import warn
from pygfx import Scene, OrthographicCamera, PanZoomController, OrbitOrthoController, \
- AxesHelper, GridHelper, WgpuRenderer, Background, BackgroundMaterial
+ AxesHelper, GridHelper, WgpuRenderer
from wgpu.gui.auto import WgpuCanvas
from ._base import PlotArea
@@ -82,8 +82,8 @@ def __init__(
pfunc.__signature__ = signature(cls)
pfunc.__doc__ = cls.__init__.__doc__
- graphic_cls_name = graphic_cls_name.lower().replace("graphic", "").replace("collection", "_collection")
- setattr(self, f"add_{graphic_cls_name}", pfunc)
+ # cls.type is defined in Graphic.__init_subclass__
+ setattr(self, f"add_{cls.type}", pfunc)
self._title_graphic: TextGraphic = None
if self.name is not None:
@@ -130,13 +130,13 @@ def get_rect(self):
x_pos = ((width_canvas / self.ncols) + ((col_ix - 1) * (width_canvas / self.ncols))) + self.spacing
y_pos = ((height_canvas / self.nrows) + ((row_ix - 1) * (height_canvas / self.nrows))) + self.spacing
width_subplot = (width_canvas / self.ncols) - self.spacing
- height_suplot = (height_canvas / self.nrows) - self.spacing
+ height_subplot = (height_canvas / self.nrows) - self.spacing
rect = np.array([
x_pos,
y_pos,
width_subplot,
- height_suplot
+ height_subplot
])
for dv in self.docked_viewports.values():
@@ -221,6 +221,7 @@ def remove_animation(self, func):
self._animate_funcs_post.remove(func)
def add_graphic(self, graphic, center: bool = True):
+ graphic.world_object.position.z = len(self._graphics)
super(Subplot, self).add_graphic(graphic, center)
if isinstance(graphic, graphics.HeatmapGraphic):
diff --git a/fastplotlib/utils/functions.py b/fastplotlib/utils/functions.py
index 4df784b6e..698d20113 100644
--- a/fastplotlib/utils/functions.py
+++ b/fastplotlib/utils/functions.py
@@ -88,36 +88,3 @@ def quick_min_max(data: np.ndarray) -> Tuple[float, float]:
data = data[tuple(sl)]
return float(np.nanmin(data)), float(np.nanmax(data))
-
-
-def to_float32(array):
- if isinstance(array, np.ndarray):
- return array.astype(np.float32, copy=False)
-
- return array
-
-
-def fix_data(array, graphic_name: str) -> np.ndarray:
- """1d or 2d to 3d, cleanup data passed from user before instantiating any Graphic class"""
- if graphic_name == "ImageGraphic":
- return to_float32(array)
-
- if array.ndim == 1:
- # for scatter if we receive just 3 points in a 1d array, treat it as just a single datapoint
- # this is different from fix_data for LineGraphic since there we assume that a 1d array
- # is just y-values
- if graphic_name == "ScatterGraphic":
- array = np.array([array])
- elif graphic_name == "LineGraphic":
- array = np.dstack([np.arange(array.size), array])[0].astype(np.float32)
-
- if array.shape[1] != 3:
- if array.shape[1] != 2:
- raise ValueError(f"Must pass 1D, 2D or 3D data to {graphic_name}")
-
- # zeros for z
- zs = np.zeros(array.shape[0], dtype=np.float32)
-
- array = np.dstack([array[:, 0], array[:, 1], zs])[0]
-
- return array
diff --git a/fastplotlib/widgets/image.py b/fastplotlib/widgets/image.py
index 5fba44d56..f8dc6c73f 100644
--- a/fastplotlib/widgets/image.py
+++ b/fastplotlib/widgets/image.py
@@ -472,8 +472,8 @@ def __init__(
max=minmax[1] + data_range_30p,
step=data_range / 150,
description=f"min-max",
- readout = True,
- readout_format = '.3f',
+ readout=True,
+ readout_format='.3f',
)
minmax_slider.observe(
@@ -779,7 +779,9 @@ def _vmin_vmax_slider_changed(
data_ix: int,
change: dict
):
- self.image_graphics[data_ix].clim = change["new"]
+ vmin, vmax = change["new"]
+ self.image_graphics[data_ix].vmin = vmin
+ self.image_graphics[data_ix].vmax = vmax
def _set_slider_layout(self, *args):
w, h = self.plot.renderer.logical_size
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
