DOC: Update numpy refs (that require :obj: rst ref)

Author: ryder-davidson

examples/02_stack_mesh_mixin/p01_points.py

@@ -1,10 +1,13 @@
 """
-Plotting Points
-===============
+Plotting Points and Splines
+============================
 
-This example demonstrates :meth:`~pyvisual.core.mixins.StackMeshMixin.add_point`
-and :meth:`~pyvisual.core.mixins.StackMeshMixin.add_points` — the methods for
-rendering individual points and point clouds from spherical coordinate arrays.
+This example demonstrates :meth:`~pyvisual.core.mixins.StackMeshMixin.add_point`,
+:meth:`~pyvisual.core.mixins.StackMeshMixin.add_points`,
+:meth:`~pyvisual.core.mixins.StackMeshMixin.add_spline`, and
+:meth:`~pyvisual.core.mixins.StackMeshMixin.add_splines` — the methods for
+rendering individual points, point clouds, single polyline paths, and bundles
+of splines from spherical coordinate arrays.
 """
 
 import numpy as np
@@ -45,3 +48,48 @@
 plotter.add_sun()
 plotter.add_points(r, t, p, r, point_size=5)
 plotter.show()
+
+# %%
+# Single Spline
+# -------------
+#
+# :meth:`~pyvisual.core.mixins.StackMeshMixin.add_spline` draws a single
+# line through a sequence of :math:`(r, \theta, \phi)` points.  The example
+# below traces an equatorial Archimedean spiral: the longitude :math:`\phi`
+# increases uniformly as the radial distance :math:`r` grows from
+# :math:`1\,R_\odot` to :math:`30\,R_\odot`, approximating a Parker spiral
+# in the ecliptic plane.  The spline is colored by :math:`r`.
+
+r = np.linspace(1, 30, 100)
+t = np.repeat(np.pi / 2, 100)
+p = np.linspace(0, 2 * np.pi, 100)
+
+plotter = Plot3d()
+plotter.show_axes()
+plotter.add_sun()
+plotter.add_spline(r, t, p, r, line_width=5)
+plotter.show()
+
+# %%
+# Bundle of Splines
+# -----------------
+#
+# :meth:`~pyvisual.core.mixins.StackMeshMixin.add_splines` renders multiple
+# splines from N-D coordinate arrays.  Here, 10 meridional arcs connect the
+# north and south poles at evenly spaced longitudes, tracing the surface of a
+# sphere of radius :math:`5\sin\theta\,R_\odot`.  The coordinate arrays have
+# shape ``(10, 100)``; ``axis=1`` declares that axis 1 (length 100) traces
+# each individual spline path and axis 0 (length 10) enumerates the distinct
+# meridians.  Each spline is colored by its index.
+
+n_lines, n_pts = 10, 100
+r = np.tile(5 * np.sin(np.linspace(0, np.pi, n_pts)), (n_lines, 1))
+t = np.tile(np.linspace(0, np.pi, n_pts), (n_lines, 1))
+p = np.tile(np.linspace(0, 2 * np.pi, n_lines)[:, None], (1, n_pts))
+data = np.arange(n_lines)
+
+plotter = Plot3d()
+plotter.show_axes()
+plotter.add_sun()
+plotter.add_splines(r, t, p, data, axis=1, show_scalar_bar=False)
+plotter.show()

examples/02_stack_mesh_mixin/p02_splines.py

@@ -6,7 +6,7 @@
 :class:`~pyvisual.core.mesh3d.CartesianMesh`) inherit a full arithmetic suite
 from :class:`~pyvisual.core.mesh3d._BaseFrameMesh`.  Standard Python
 operators (``+``, ``-``, ``*``, ``/``, ``**``, etc.) and NumPy ufuncs such as
-:func:`numpy.log10` and :func:`numpy.sqrt` operate element-wise on the active
+:obj:`numpy.log10` and :obj:`numpy.sqrt` operate element-wise on the active
 scalar field and return a new mesh of the same type with the result as the
 active scalar.  The coordinate arrays are never modified — only the data
 changes.
@@ -52,7 +52,7 @@
 #
 # The :meth:`~pyvisual.core.mesh3d._BaseFrameMesh.__array_ufunc__` hook lets
 # any single-output NumPy ufunc act directly on the mesh.
-# :func:`numpy.log10` applied to :math:`B_r r^2` converts the field to a
+# :obj:`numpy.log10` applied to :math:`B_r r^2` converts the field to a
 # logarithmic scale.
 #
 # To account for the sign of :math:`B_r r^2`, we take the absolute value before applying

…mples/02_stack_mesh_mixin/p03_surface.py …mples/02_stack_mesh_mixin/p02_surface.pyexamples/02_stack_mesh_mixin/p03_surface.py renamed to examples/02_stack_mesh_mixin/p02_surface.py examples/02_stack_mesh_mixin/p03_surface.py renamed to examples/02_stack_mesh_mixin/p02_surface.py

@@ -107,8 +107,8 @@
 # points via :meth:`pyvista.DataObjectFilters.sample`.
 #
 # The second :meth:`~pyvista.Plotter.add_mesh` call projects the colored trajectory
-# onto the plane :math:`r = 2` using
-# :meth:`pyvista.PolyData.project_points_to_plane`, producing a "shadow" projection
+# onto the plane :math:`r = 2 R_\odot` using
+# :meth:`~pyvista.PolyDataFilters.project_points_to_plane`, producing a "shadow" projection
 # for spatial context.
 
 trajectory = spacecraft_trajectory('psp', '2024-03-28', '2024-04-01')
@@ -130,7 +130,7 @@
 # Two points on the trajectory (indices 0 and 50) are converted to Cartesian
 # coordinates via :func:`~pyvisual.utils.geometry.spherical_to_cartesian`.  Their
 # cross product defines the normal to the orbital plane, which is used to orient a
-# :class:`pyvista.Disc` spanning 30 :math:`R_\odot`.
+# :class:`~pyvista.PolyData` disc spanning 30 :math:`R_\odot`.
 # :meth:`~pyvisual.core.mesh3d.SphericalMeshFilters.spherical_to_cartesian` converts
 # the :class:`pyvista.RectilinearGrid` to a Cartesian
 # :class:`pyvista.StructuredGrid`, and :meth:`pyvista.DataObjectFilters.sample` then

…es/02_stack_mesh_mixin/p04_fieldlines.py …es/02_stack_mesh_mixin/p03_fieldlines.pyexamples/02_stack_mesh_mixin/p04_fieldlines.py renamed to examples/02_stack_mesh_mixin/p03_fieldlines.py examples/02_stack_mesh_mixin/p04_fieldlines.py renamed to examples/02_stack_mesh_mixin/p03_fieldlines.py

@@ -6,7 +6,7 @@
 :class:`~pyvisual.core.mesh3d.SphericalMesh`) inherit a full arithmetic suite
 from :class:`~pyvisual.core.mesh3d._BaseFrameMesh`.  Standard Python operators
 (``+``, ``-``, ``*``, ``/``, ``**``, etc.) and NumPy ufuncs such as
-:func:`numpy.log10` and :func:`numpy.sqrt` operate element-wise on the active
+:obj:`numpy.log10` and :obj:`numpy.sqrt` operate element-wise on the active
 scalar field and return a new mesh of the same type with the result as the
 active scalar.  The coordinate arrays are never modified — only the data
 changes.
@@ -60,7 +60,7 @@
 #
 # The :meth:`~pyvisual.core.mesh3d._BaseFrameMesh.__array_ufunc__` hook lets
 # any single-output NumPy ufunc act directly on the mesh.
-# :func:`numpy.log10` applied to the normalised distance converts the field to
+# :obj:`numpy.log10` applied to the normalised distance converts the field to
 # a logarithmic scale that compresses the large dynamic range near the outer
 # boundary and reveals structure close to the origin.  Points at or below zero
 # (here, the grid corner where :math:`r = 0`) are masked by the log.

examples/06_spherical_grid_class/p02_arithmetic.py

@@ -19,7 +19,7 @@
 :func:`~mapflpy.scripts.run_fwdbwd_tracing` as ``launch_points`` without
 any intermediate coordinate conversion.
 
-See also :ref:`sphx_glr_gallery_02_stack_mesh_mixin_p04_fieldlines.py` for a
+See also :ref:`sphx_glr_gallery_02_stack_mesh_mixin_p03_fieldlines.py` for a
 general introduction to fieldline rendering, and
 :ref:`sphx_glr_gallery_99_advanced_plots_p01_combining_multiple_elements.py` for a
 broader scene that layers slices, contours, and fieldlines.