Anti aliasing - always a boolean (#51)

gselzer · Copilot · web-flow · commit d821224d36ce · 2026-03-02T13:51:25.000-06:00
* Change Points.antialias to boolean

VisPy uses an int and pygfx uses a boolean. Until someone wants that int
for VisPy let's just use a boolean for simplicity.

* Add line antialiasing

* Remove example cruft

* Pygfx lines: pass aa in ctor

* Text antialiasing

* Break up adaptor line tests into multiple

* Add an antialiasing example

* Update tests/adaptors/_vispy/test_line.py

Co-authored-by: Copilot &lt;175728472+Copilot@users.noreply.github.com&gt;

---------

Co-authored-by: Copilot &lt;175728472+Copilot@users.noreply.github.com&gt;
diff --git a/examples/antialiasing.py b/examples/antialiasing.py
@@ -0,0 +1,73 @@
+"""Demonstrates antialiasing for Lines, Points, and Text.
+
+Three nodes are shown — a diagonal line, a disc point, and a text label —
+each supporting the ``antialias`` property.
+
+**Interaction**
+- Left-click anywhere in the view to toggle antialiasing on all nodes.
+  The status text updates to reflect the current state.
+
+Antialiasing is most noticeable on the diagonal line (jagged stairstepping
+appears on its edges without AA) and on the curved edge of the disc.
+"""
+
+import cmap
+import numpy as np
+
+import scenex as snx
+from scenex.app.events import Event, MousePressEvent
+from scenex.utils import projections
+
+# --- Diagonal line on the left side ---
+# A steep diagonal makes aliasing (stairstepping) clearly visible.
+line = snx.Line(
+    vertices=np.array([[-0.7, -0.5, 0], [0.1, 0.6, 0]], dtype=np.float32),
+    color=snx.UniformColor(color=cmap.Color("white")),
+    width=2.0,
+    antialias=True,
+)
+
+# --- Single disc point on the right side ---
+point = snx.Points(
+    vertices=np.array([[0.65, 0.0, 0]], dtype=np.float32),
+    size=30,
+    scaling="fixed",
+    face_color=snx.UniformColor(color=cmap.Color("orange")),
+    edge_color=snx.UniformColor(color=cmap.Color("white")),
+    edge_width=2.0,
+    antialias=True,
+)
+
+# --- Status label at the bottom ---
+status_text = snx.Text(
+    text="Antialiasing: ON  (click to toggle)",
+    color=cmap.Color("yellow"),
+    size=14,
+    antialias=True,
+    transform=snx.Transform().translated((0, -0.8, 0)),
+)
+
+view = snx.View(
+    scene=snx.Scene(children=[line, point, status_text]),
+    camera=snx.Camera(),
+)
+
+
+def _toggle_antialias(event: Event) -> bool:
+    if isinstance(event, MousePressEvent):
+        # Toggle the antialiasing state for all nodes and update the status text.
+        new_aa = not line.antialias
+        line.antialias = new_aa
+        point.antialias = new_aa
+        status_text.antialias = new_aa
+        state = "ON" if new_aa else "OFF"
+        status_text.text = f"Antialiasing: {state}  (click to toggle)"
+        return True
+    return False
+
+
+view.set_event_filter(_toggle_antialias)
+
+snx.show(view)
+view.camera.projection = projections.orthographic(2, 2, 1e5)
+snx.run()
diff --git a/examples/basic_line.py b/examples/basic_line.py
@@ -60,7 +60,7 @@ def _view_event_filter(event: Event) -> bool:
     elif isinstance(event, MousePressEvent):
         if event.buttons & MouseButton.LEFT:
             if intersections := event.world_ray.intersections(view.scene):
-                # Find mesh intersection
+                # Find line intersection
                 for node, _distance in intersections:
                     if isinstance(node, snx.Line):
                         pressed = True
diff --git a/examples/basic_points.py b/examples/basic_points.py
@@ -84,9 +84,6 @@ def _on_view_event(event: Event) -> bool:
 
 view.set_event_filter(_on_view_event)
 
-snx.use("pygfx")
-# snx.use("vispy")
-
 # Show and position camera
 snx.show(view)
 view.camera.projection = projections.orthographic(2, 2, 1e5)
diff --git a/src/scenex/adaptors/_base.py b/src/scenex/adaptors/_base.py
@@ -162,7 +162,7 @@ def _snx_set_symbol(self, arg: str, /) -> None: ...
     @abstractmethod
     def _snx_set_scaling(self, arg: model.ScalingMode, /) -> None: ...
     @abstractmethod
-    def _snx_set_antialias(self, arg: float, /) -> None: ...
+    def _snx_set_antialias(self, arg: bool, /) -> None: ...
 
 
 class MeshAdaptor(NodeAdaptor[TMesh, TNative]):
@@ -185,6 +185,8 @@ def _snx_set_vertices(self, arg: NDArray) -> None: ...
     def _snx_set_color(self, arg: model.ColorModel, /) -> None: ...
     @abstractmethod
     def _snx_set_width(self, arg: float, /) -> None: ...
+    @abstractmethod
+    def _snx_set_antialias(self, arg: bool, /) -> None: ...
 
 
 class TextAdaptor(NodeAdaptor[TText, TNative]):
@@ -196,6 +198,8 @@ def _snx_set_text(self, arg: str, /) -> None: ...
     def _snx_set_color(self, arg: model.Color, /) -> None: ...
     @abstractmethod
     def _snx_set_size(self, arg: int, /) -> None: ...
+    @abstractmethod
+    def _snx_set_antialias(self, arg: bool, /) -> None: ...
 
 
 class CanvasAdaptor(SupportsVisibility[TCanvas, TNative]):
diff --git a/src/scenex/adaptors/_pygfx/_line.py b/src/scenex/adaptors/_pygfx/_line.py
@@ -26,6 +26,7 @@ def __init__(self, line: model.Line, **backend_kwargs: Any) -> None:
         self._model = line
         self._material = pygfx.LineMaterial(
             thickness=line.width,
+            aa=line.antialias,
             # This value has model render order win for coplanar objects
             depth_compare="<=",
         )
@@ -65,3 +66,6 @@ def _snx_set_color(self, arg: ColorModel) -> None:
 
     def _snx_set_width(self, arg: float) -> None:
         self._material.thickness = arg
+
+    def _snx_set_antialias(self, arg: bool) -> None:
+        self._material.aa = arg
diff --git a/src/scenex/adaptors/_pygfx/_points.py b/src/scenex/adaptors/_pygfx/_points.py
@@ -37,7 +37,7 @@ def __init__(self, points: model.Points, **backend_kwargs: Any) -> None:
         self._material = pygfx.PointsMarkerMaterial(
             size=points.size,  # pyright: ignore[reportArgumentType]
             size_space=SPACE_MAP[points.scaling],
-            aa=points.antialias > 0,
+            aa=points.antialias,
             edge_width=points.edge_width,
             opacity=points.opacity,
             # This value has model render order win for coplanar objects
@@ -102,8 +102,8 @@ def _snx_set_symbol(self, symbol: str) -> None: ...
     def _snx_set_scaling(self, scaling: model.ScalingMode) -> None:
         self._material.size_space = SPACE_MAP[scaling]
 
-    def _snx_set_antialias(self, antialias: float) -> None:
-        self._material.aa = antialias > 0
+    def _snx_set_antialias(self, antialias: bool) -> None:
+        self._material.aa = antialias
 
     def _snx_set_opacity(self, arg: float) -> None:
         self._material.opacity = arg
diff --git a/src/scenex/adaptors/_pygfx/_text.py b/src/scenex/adaptors/_pygfx/_text.py
@@ -28,6 +28,7 @@ def __init__(self, text: TextModel, **backend_kwargs: Any) -> None:
             color=text.color.hex,
             # This value has model render order win for coplanar objects
             depth_compare="<=",
+            aa=text.antialias,
         )
         # create a pygfx Text visual
         self._pygfx_node = pygfx.Text(
@@ -45,3 +46,6 @@ def _snx_set_color(self, arg: cmap.Color) -> None:
 
     def _snx_set_size(self, arg: int) -> None:
         self._pygfx_node.font_size = arg
+
+    def _snx_set_antialias(self, arg: bool) -> None:
+        self._material.aa = arg
diff --git a/src/scenex/adaptors/_vispy/_line.py b/src/scenex/adaptors/_vispy/_line.py
@@ -30,7 +30,7 @@ def __init__(self, line: model.Line, **backend_kwargs: Any) -> None:
         self._vispy_node = vispy.scene.Line(
             pos=np.asarray(line.vertices, dtype=np.float32),
             width=int(line.width),
-            antialias=line.antialias > 0,
+            antialias=line.antialias,
         )
         self._snx_set_color(line.color)
 
@@ -45,3 +45,6 @@ def _snx_set_color(self, arg: snx.ColorModel) -> None:
 
     def _snx_set_width(self, arg: float) -> None:
         self._vispy_node.set_data(width=arg)
+
+    def _snx_set_antialias(self, arg: bool) -> None:
+        self._vispy_node.antialias = arg
diff --git a/src/scenex/adaptors/_vispy/_points.py b/src/scenex/adaptors/_vispy/_points.py
@@ -56,8 +56,8 @@ def _snx_set_scaling(self, scaling: model.ScalingMode) -> None:
         self._vispy_node.scaling = scaling
         self._update_vispy_data()
 
-    def _snx_set_antialias(self, antialias: float) -> None:
-        self._vispy_node.antialias = antialias
+    def _snx_set_antialias(self, antialias: bool) -> None:
+        self._vispy_node.antialias = 1.0 if antialias else 0.0
 
     def _snx_set_opacity(self, arg: float) -> None:
         self._vispy_node.alpha = arg
diff --git a/src/scenex/adaptors/_vispy/_text.py b/src/scenex/adaptors/_vispy/_text.py
@@ -49,6 +49,14 @@ def _snx_set_size(self, arg: int) -> None:
         if self._vispy_node.font_size != font_size:
             self._vispy_node.font_size = font_size
 
+    def _snx_set_antialias(self, arg: bool) -> None:
+        # vispy's TextVisual uses SDF-based rendering and cannot be tuned; antialiasing
+        # is always applied internally.
+        # TODO: Consider logging something here? There are bigger questions around how
+        # scenex should handle something that a backend doesn't support. For now let's
+        # be quiet.
+        pass
+
     def _snx_set_blending(self, arg: BlendMode) -> None:
         # Blending text makes it look very blocky
         pass
diff --git a/src/scenex/model/_nodes/line.py b/src/scenex/model/_nodes/line.py
@@ -66,8 +66,8 @@ class Line(Node):
     )
     # TODO: Support scaling modes like points do
     width: float = Field(default=1.0, ge=0.0, description="Width of the line in pixels")
-    antialias: float = Field(
-        default=1.0, description="Anti-aliasing amount (pixels) for rendering"
+    antialias: bool = Field(
+        default=True, description="Whether to apply anti-aliasing to line rendering"
     )
 
     @property  # TODO: Cache?
diff --git a/src/scenex/model/_nodes/points.py b/src/scenex/model/_nodes/points.py
@@ -115,8 +115,14 @@ class Points(Node):
         ),
     )
 
-    antialias: float = Field(
-        default=1, description="Anti-aliasing amount (pixels) for symbol rendering"
+    # e.g. VisPy supports an integer antialias property that "blurs" the edge as the
+    # value increases. pygfx supports a boolean property.
+    antialias: bool = Field(
+        default=True,
+        description=(
+            "Whether to apply anti-aliasing to symbol rendering. The anti-aliasing"
+            " implementation, when enabled, is left to the backend."
+        ),
     )
 
     @property  # TODO: Cache?
diff --git a/src/scenex/model/_nodes/text.py b/src/scenex/model/_nodes/text.py
@@ -34,6 +34,13 @@ class Text(Node):
     size: int = Field(
         default=12, ge=0, description="Font size in pixels, must be non-negative"
     )
+    antialias: bool = Field(
+        default=True,
+        description=(
+            "Whether to apply anti-aliasing to text rendering. The anti-aliasing"
+            " implementation, when enabled, is left to the backend."
+        ),
+    )
 
     @property
     def bounding_box(self) -> AABB:
diff --git a/tests/adaptors/_pygfx/test_line.py b/tests/adaptors/_pygfx/test_line.py
@@ -2,6 +2,7 @@
 
 import cmap
 import numpy as np
+import pygfx
 import pytest
 
 import scenex as snx
@@ -23,6 +24,7 @@ def line() -> snx.Line:
         vertices=vertices,
         color=snx.UniformColor(color=cmap.Color("red")),
         width=1,
+        antialias=False,
     )
 
 
@@ -33,37 +35,59 @@ def adaptor(line: snx.Line) -> adaptors.Line:
     return adaptor
 
 
-def test_data(line: snx.Line, adaptor: adaptors.Line) -> None:
-    """Tests that changing the model changes the view (the PyGfx node)."""
+def test_line_data(line: snx.Line, adaptor: adaptors.Line) -> None:
+    """Tests that changing the model vertices updates the PyGfx node."""
     geom = adaptor._pygfx_node.geometry
-    mat = adaptor._pygfx_node.material
     assert geom is not None
-    assert mat is not None
 
     assert np.array_equal(line.vertices, geom.positions.data)
     line.vertices = line.vertices * 100
     assert np.array_equal(line.vertices, geom.positions.data)
 
-    assert line.width == mat.thickness  # pyright: ignore
+
+def test_line_width(line: snx.Line, adaptor: adaptors.Line) -> None:
+    mat = adaptor._pygfx_node.material
+    assert isinstance(mat, pygfx.LineMaterial)
+
+    assert line.width == mat.thickness
     line.width = 5
-    assert line.width == mat.thickness  # pyright: ignore
+    assert mat.thickness == 5
+
+
+def test_line_color(line: snx.Line, adaptor: adaptors.Line) -> None:
+    mat = adaptor._pygfx_node.material
+    assert isinstance(mat, pygfx.LineMaterial)
+    geom = adaptor._pygfx_node.geometry
 
-    assert line.color is not None
+    # initial uniform color
     assert np.array_equal(line.color.color.rgba, mat.color.rgba)  # type: ignore
+
+    # change uniform color
     line.color = snx.UniformColor(color=cmap.Color("blue"))
-    assert np.array_equal(
-        line.color.color.rgba,
-        adaptor._pygfx_node.material.color.rgba,  # pyright: ignore
-    )
-    line.color = snx.VertexColors(
-        color=[
-            cmap.Color("green"),
-            cmap.Color("yellow"),
-            cmap.Color("blue"),
-            cmap.Color("red"),
-        ],
-    )
+    assert np.array_equal(line.color.color.rgba, mat.color.rgba)
+
+    # change to vertex colors
+    colors = [
+        cmap.Color("green"),
+        cmap.Color("yellow"),
+        cmap.Color("blue"),
+        cmap.Color("red"),
+    ]
+    line.color = snx.VertexColors(color=colors)
     assert np.array_equal(
         np.asarray([c.rgba for c in line.color.color], dtype=np.float32),
-        adaptor._pygfx_node.geometry.colors.data,  # pyright: ignore
+        geom.colors.data,  # pyright: ignore
     )
+
+
+def test_line_antialias(line: snx.Line, adaptor: adaptors.Line) -> None:
+    node = adaptor._pygfx_node
+    mat = node.material
+    assert isinstance(mat, pygfx.LineMaterial)
+
+    # Initial state
+    assert not line.antialias
+    assert mat.aa == line.antialias
+    # Change antialias
+    line.antialias = True
+    assert mat.aa
diff --git a/tests/adaptors/_pygfx/test_points.py b/tests/adaptors/_pygfx/test_points.py
@@ -21,7 +21,7 @@ def points() -> snx.Points:
         edge_width=1.0,
         symbol="disc",
         scaling="fixed",
-        antialias=0,
+        antialias=False,
     )
 
 
@@ -73,9 +73,12 @@ def test_points_antialias(points: snx.Points, adaptor: adaptors.Points) -> None:
     mat = node.material
     assert isinstance(mat, pygfx.PointsMaterial)
 
-    assert mat.aa == (points.antialias > 0)
-    points.antialias = 1
-    assert mat.aa is True
+    # Initial state
+    assert not points.antialias
+    assert mat.aa == points.antialias
+    # Change antialias
+    points.antialias = True
+    assert mat.aa
 
 
 def test_points_scaling(points: snx.Points, adaptor: adaptors.Points) -> None:
diff --git a/tests/adaptors/_pygfx/test_text.py b/tests/adaptors/_pygfx/test_text.py
diff --git a/tests/adaptors/_vispy/test_line.py b/tests/adaptors/_vispy/test_line.py
diff --git a/tests/adaptors/_vispy/test_points.py b/tests/adaptors/_vispy/test_points.py
diff --git a/tests/adaptors/_vispy/test_text.py b/tests/adaptors/_vispy/test_text.py
