qmlmathplot 0.4.1__py3-none-any.whl → 0.4.3__py3-none-any.whl

qmlmathplot/__init__.py

@@ -54,6 +54,7 @@ from .camera import HOME_SIZE, HOME_VIEW, Camera, nice_ticks
 from .curve import Curve, CurveListModel, ImplicitCurve
 from .figure import Axes, Figure
 from .input import ViewInput
+from .overlay import Annotation, Guide
 from .plot import Plot
 from .qsb import cache_dir, cache_info, clear_cache, prune_cache
 from .view import QML_MAJOR, QML_MINOR, QML_URI, qml_component_path, register_qml_types
@@ -63,6 +64,7 @@ if TYPE_CHECKING:  # only for type checkers; at runtime the module-level __getat
     from .widget import MathPlotWidget
 
 __all__ = [
+    "Annotation",
     "Axes",
     "cache_dir",
     "cache_info",
@@ -72,6 +74,7 @@ __all__ = [
     "CurveListModel",
     "Figure",
     "FigureCanvasQt",
+    "Guide",
     "HOME_SIZE",
     "HOME_VIEW",
     "ImplicitCurve",

qmlmathplot/curve.py

@@ -431,6 +431,7 @@ class CurveListModel(QAbstractListModel):
     VisibleRole = CurveRole + 4
     VertexShaderRole = CurveRole + 5
     FragmentShaderRole = CurveRole + 6
+    LabelRole = CurveRole + 7
 
     _ROLES = {
         CurveRole: b"curve",
@@ -440,6 +441,7 @@ class CurveListModel(QAbstractListModel):
         VisibleRole: b"visible",
         VertexShaderRole: b"vertexShader",
         FragmentShaderRole: b"fragmentShader",
+        LabelRole: b"label",
     }
 
     def __init__(
@@ -478,6 +480,8 @@ class CurveListModel(QAbstractListModel):
             return curve.vertexShader
         if role == self.FragmentShaderRole:
             return curve.fragmentShader
+        if role == self.LabelRole:
+            return curve.label
         return None
 
     def _notify(self, curve: Curve, roles: tuple[int, ...]) -> None:
@@ -498,6 +502,7 @@ class CurveListModel(QAbstractListModel):
             lambda c=curve: self._notify(c, (self.ColorRole, self.LineWidthRole))
         )
         curve.visibleChanged.connect(lambda c=curve: self._notify(c, (self.VisibleRole,)))
+        curve.labelChanged.connect(lambda c=curve: self._notify(c, (self.LabelRole,)))
 
     # ---------------------------------------------------------------- public
     def _defaults(self, color: object, line_width: object) -> tuple[QColor, float]:

qmlmathplot/export.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 from collections.abc import Sequence
 from typing import TYPE_CHECKING
 
-from PySide6.QtCore import QSize, Qt, QUrl
+from PySide6.QtCore import QCoreApplication, QSize, Qt, QUrl
 from PySide6.QtGui import QColor, QImage
 
 if TYPE_CHECKING:  # pragma: no cover - typing only; the real imports stay lazy
@@ -155,6 +155,10 @@ def render(
 
         camera.set_viewport(logical[0], logical[1])
         camera.set_view(centre[0], centre[1], scale[0], scale[1])
+        # Let QML's Canvas-based furniture (grid, guides) handle its queued paint before the
+        # synchronous readback; the scene-graph items are already ready, Canvas is not.
+        for _ in range(3):
+            QCoreApplication.processEvents()
         image = widget.grabFramebuffer()
     finally:
         # Restore before the event loop runs again, so no live view repaints the export state.

qmlmathplot/figure.py

@@ -213,7 +213,13 @@ class Axes:
 
     # -------------------------------------------------------------- dressing
     def grid(self, visible: bool | None = True, **kwargs: object) -> None:
-        self.model.grid = True if visible is None else bool(visible)
+        axis = str(kwargs.pop("axis", "both")).lower()
+        enabled = True if visible is None else bool(visible)
+        self.model.grid = enabled
+        if axis in ("x", "both"):
+            self.model.grid_x = enabled
+        if axis in ("y", "both"):
+            self.model.grid_y = enabled
         if "color" in kwargs:
             self.model.grid_color = kwargs["color"]  # type: ignore[assignment]
         width = kwargs.get("linewidth", kwargs.get("lw"))
@@ -255,11 +261,19 @@ class Axes:
     def clear(self) -> None:
         self._figure.clf()
 
-    # ------------------------------------------------------ explicitly absent
+    # ------------------------------------------------------- text and annotation
     def legend(self, *args: object, **kwargs: object) -> None:
-        raise _unsupported(
-            "legend()", "chrome belongs to the host: use Curve.label and a PlotView.overlay"
-        )
+        if args and args[0] in (False, None):
+            self.model.legend = False
+            return None
+        loc = kwargs.get("loc", kwargs.get("location"))
+        if loc is not None:
+            text = str(loc).replace("_", " ").lower()
+            if text not in self.model._LEGEND_POSITIONS:
+                raise ValueError(f"unsupported legend location {loc!r}")
+            self.model.legend_position = text
+        self.model.legend = True
+        return None
 
     def set_xscale(self, value: object, **kwargs: object) -> None:
         raise _unsupported("log axes", "the shader mapping is linear today")
@@ -267,17 +281,77 @@ class Axes:
     def set_yscale(self, value: object, **kwargs: object) -> None:
         raise _unsupported("log axes", "the shader mapping is linear today")
 
-    def annotate(self, *args: object, **kwargs: object) -> None:
-        raise _unsupported("annotate()", "annotations are not implemented")
-
-    def text(self, *args: object, **kwargs: object) -> None:
-        raise _unsupported("text()", "annotations are not implemented")
+    def annotate(
+        self,
+        text: object,
+        xy: object,
+        xytext: object = (24, -18),
+        arrowprops: dict[str, object] | None = None,
+        **kwargs: object,
+    ):
+        color = kwargs.pop("color", None)
+        fontsize = kwargs.pop("fontsize", kwargs.pop("size", None))
+        if arrowprops and "color" in arrowprops:
+            color = arrowprops["color"]
+        return self.model.add_annotation(
+            "" if text is None else str(text),
+            xy,
+            xytext,
+            arrowprops is not None,
+            color,
+            None if fontsize is None else float(fontsize),  # type: ignore[arg-type]
+        )
 
-    def set_xticks(self, *args: object, **kwargs: object) -> None:
-        raise _unsupported("set_xticks()", "ticks are automatic nice numbers today")
+    def text(self, x: float, y: float, s: object, fontdict: object = None, **kwargs: object):
+        color = kwargs.pop("color", None)
+        size = kwargs.pop("fontsize", kwargs.pop("size", None))
+        return self.model.add_text(x, y, "" if s is None else str(s), color=color,
+                                   font_size=None if size is None else float(size))
+
+    def set_xticks(self, ticks: object, labels: object = None, **kwargs: object) -> None:
+        self.model.set_xticks(ticks, labels)
+
+    def set_yticks(self, ticks: object, labels: object = None, **kwargs: object) -> None:
+        self.model.set_yticks(ticks, labels)
+
+    def tick_params(self, axis: str = "both", **kwargs: object) -> None:
+        axis = str(axis).lower()
+        if "length" in kwargs:
+            self.model.tick_length = float(kwargs["length"])  # type: ignore[arg-type]
+        if "width" in kwargs:
+            self.model.tick_width = float(kwargs["width"])  # type: ignore[arg-type]
+        if "pad" in kwargs:
+            self.model.tick_pad = float(kwargs["pad"])  # type: ignore[arg-type]
+        if "labelsize" in kwargs:
+            self.model.tick_font_size = float(kwargs["labelsize"])  # type: ignore[arg-type]
+        colors = kwargs.get("colors", kwargs.get("color"))
+        if colors is not None:
+            self.model.tick_color = colors  # type: ignore[assignment]
+        labelcolor = kwargs.get("labelcolor")
+        if labelcolor is not None:
+            self.model.text_color = labelcolor  # type: ignore[assignment]
+        if "top" in kwargs and axis in ("x", "both"):
+            self.model.ticks_top = bool(kwargs["top"])
+        if "right" in kwargs and axis in ("y", "both"):
+            self.model.ticks_right = bool(kwargs["right"])
+        if str(kwargs.get("which", "")).lower() == "minor":
+            self.model.minor_ticks = True
+
+    def axhline(self, y: float = 0.0, **kwargs: object):
+        return self.model.add_hline(
+            y,
+            color=kwargs.get("color", kwargs.get("c")),
+            width=float(kwargs.get("linewidth", kwargs.get("lw", 1.0))),  # type: ignore[arg-type]
+            style=str(kwargs.get("linestyle", kwargs.get("ls", "--"))),
+        )
 
-    def set_yticks(self, *args: object, **kwargs: object) -> None:
-        raise _unsupported("set_yticks()", "ticks are automatic nice numbers today")
+    def axvline(self, x: float = 0.0, **kwargs: object):
+        return self.model.add_vline(
+            x,
+            color=kwargs.get("color", kwargs.get("c")),
+            width=float(kwargs.get("linewidth", kwargs.get("lw", 1.0))),  # type: ignore[arg-type]
+            style=str(kwargs.get("linestyle", kwargs.get("ls", "--"))),
+        )
 
 
 class Figure:

qmlmathplot/model.py

@@ -440,21 +440,43 @@ void main() {
     float y_bot = camera.y - 0.5 * spany;
 
 #if USE_INTERVAL
+    // Conservative reject: every sample/segment used below lies within ±2 columns, so the
+    // interval over that window bounds the curve's y values there. A pixel farther than the
+    // stroke radius from that range cannot be painted; skip the 14 F evaluations and the
+    // column/stroke-footprint intervals. This is the cheap analogue of a column cache: one
+    // interval evaluation instead of the whole per-pixel sample loop. Whole/infinite columns
+    // do not reject (the envelope may fill the viewport); empty columns have no curve at all.
+    IVal wide = FI(x - 2.0 * dx, x + 2.0 * dx);
+    if (wide.kind == IK_EMPTY) {
+        fragColor = vec4(0.0);
+        return;
+    }
+    if (wide.kind == IK_CONNECTED && wide.lo > -IINF && wide.hi < IINF) {
+        float pad = R * camera.w;
+        if (y < wide.lo - pad || y > wide.hi + pad) {
+            fragColor = vec4(0.0);
+            return;
+        }
+    }
+
     IVal own = FI(x - 0.5 * dx, x + 0.5 * dx);
-    bool own_empty = own.kind == IK_EMPTY;
     IVal col = own;
-    IVal gate = FI(x - R * dx, x + R * dx);
-    if (col.kind == IK_EMPTY && gate.kind != IK_EMPTY) {
-        // The stroke's outer half may cross the domain boundary by up to one radius.
-        col = gate;
+    if (col.kind == IK_EMPTY) {
+        // The stroke's outer half may cross the domain boundary by up to one radius. Only a
+        // column with no in-domain value needs this wider footprint; skipping it for every
+        // other pixel removes one interval evaluation from the common path.
+        IVal gate = FI(x - R * dx, x + R * dx);
+        if (gate.kind != IK_EMPTY) {
+            col = gate;
+        }
     }
 
     // ---- fixed-x sub-pixel polyline (GeoGebra's sampled polyline, on the GPU) ----
-    // 16 samples over ±2 columns (0.25-column spacing) cover the perpendicular foot even at
+    // 14 samples over ±2 columns (0.286-column spacing) cover the perpendicular foot even at
     // 89°: a ±1-column window lost 42 % of the width at 84°. Joining the samples gives a
     // polyline whose segments are diagonal, so the stroke is smooth at any zoom. The interval
     // band stays separate (below); it no longer has to be inferred from this window.
-    const int NS = 16;
+    const int NS = 14;
     float smp[NS];
     float smpx[NS];
     bool ok[NS];
@@ -1265,8 +1287,14 @@ void main() {
     // such as x² + y² = 0 is not left to the projection alone.
     // GGB measures the singular cell in *world* derivative units (|Fx| + |Fy| < 0.001);
     // the per-pixel gradient of an ordinary circle is ~0.01 and must not qualify.
+    // The distance gate is essential for a scaled expression: (x+y)/(x*y) has |F| < 0.05 and
+    // |Fx|+|Fy| < 0.001 over huge regions around ±50, although the level set is far away. A
+    // singular point must also be *on* the set to the first order: |F| ~ R*|grad F|. The
+    // ratio is scale-invariant, unlike the two absolute thresholds above.
     float gw_s = abs(FX(x, y)) + abs(FY(x, y));
-    if (dom && (f == f) && (abs(f) < 1e30) && gw_s < 1e-3 && abs(f) < 0.05) {
+    float gnorm_s = max(sqrt(gx * gx + gy * gy), 1e-9);
+    if (dom && (f == f) && (abs(f) < 1e30) && gw_s < 1e-3 && abs(f) < 0.05
+            && abs(f) < R * gnorm_s) {
         march_cov = 1.0;
     }
 

qmlmathplot/mpl.py

@@ -149,31 +149,92 @@ def figure_for(
         axes.spines["bottom"].set_position("zero")
         axes.spines["top"].set_visible(False)
         axes.spines["right"].set_visible(False)
+    elif plot.axes_position == "box":
+        for side, visible in (
+            ("top", plot.spine_top), ("bottom", plot.spine_bottom),
+            ("left", plot.spine_left), ("right", plot.spine_right),
+        ):
+            axes.spines[side].set_visible(visible)
     for spine in axes.spines.values():
         spine.set_color(plot.axis_color.name())
         spine.set_linewidth(plot.axis_width * PX_TO_PT)
 
+    if plot.xticks:
+        axes.set_xticks([float(value) for value, _label in plot.xticks],
+                        labels=[label for _value, label in plot.xticks])
+    if plot.yticks:
+        axes.set_yticks([float(value) for value, _label in plot.yticks],
+                        labels=[label for _value, label in plot.yticks])
+
     axes.set_axisbelow(True)                      # the Qt view paints its grid below the curves
+    grid_kwargs = {
+        "color": plot.grid_color.name(),
+        "linewidth": plot.grid_width * PX_TO_PT,
+        "alpha": plot.grid_alpha,
+        "linestyle": plot.grid_style,
+    }
     if plot.grid:
-        axes.grid(True, color=plot.grid_color.name(),
-                  linewidth=plot.grid_width * PX_TO_PT, alpha=plot.grid_alpha,
-                  linestyle=plot.grid_style)
+        axes.grid(False)
+        if plot.grid_x:
+            axes.xaxis.grid(True, **grid_kwargs)
+        if plot.grid_y:
+            axes.yaxis.grid(True, **grid_kwargs)
     else:
-        # Passing line properties together with `False` makes matplotlib *enable* the grid.
         axes.grid(False)
-    axes.tick_params(colors=plot.tick_color.name(), labelcolor=plot.text_color.name(),
-                     labelsize=plot.tick_font_size * PX_TO_PT)
+    axes.tick_params(
+        colors=plot.tick_color.name(),
+        labelcolor=plot.text_color.name(),
+        labelsize=plot.tick_font_size * PX_TO_PT,
+        width=plot.tick_width * PX_TO_PT,
+        pad=plot.tick_pad * PX_TO_PT,
+        top=plot.ticks_top,
+        right=plot.ticks_right,
+    )
+    if plot.minor_ticks:
+        axes.minorticks_on()
     axes.xaxis.label.set_fontsize(plot.font_size * PX_TO_PT)
     axes.yaxis.label.set_fontsize(plot.font_size * PX_TO_PT)
+    if plot.xlabel:
+        axes.set_xlabel(plot.xlabel, color=plot.text_color.name())
+    if plot.ylabel:
+        axes.set_ylabel(plot.ylabel, color=plot.text_color.name())
     if plot.title:
         axes.set_title(plot.title, color=plot.title_color.name(),
                        fontsize=plot.title_font_size * PX_TO_PT,
                        fontweight="bold" if plot.title_bold else "normal")
 
+    for index in range(plot.annotations.rowCount()):
+        annotation = plot.annotations.at(index)
+        if not annotation.visible:
+            continue
+        options: dict[str, object] = {
+            "xycoords": "data",
+            "textcoords": "offset points",
+            "xytext": (annotation.xytext.x(), annotation.xytext.y()),
+            "color": annotation.color.name(),
+            "fontsize": annotation.fontSize * PX_TO_PT,
+        }
+        if annotation.arrow:
+            options["arrowprops"] = {"arrowstyle": "->", "color": annotation.color.name()}
+        axes.annotate(annotation.text, (annotation.xy.x(), annotation.xy.y()), **options)
+
+    for index in range(plot.guides.rowCount()):
+        guide = plot.guides.at(index)
+        if not guide.visible:
+            continue
+        if guide.kind == "h":
+            axes.axhline(guide.value, color=guide.color.name(),
+                         linewidth=guide.width * PX_TO_PT, linestyle=guide.style)
+        else:
+            axes.axvline(guide.value, color=guide.color.name(),
+                         linewidth=guide.width * PX_TO_PT, linestyle=guide.style)
+
     for curve in _visible_curves(plot):
         xs, ys = _sample(curve, x_range[0], x_range[1], samples)
         axes.plot(xs, ys, color=curve.color.name(), linewidth=curve.lineWidth * PX_TO_PT,
                   label=curve.label or curve.expression)
+    if plot.legend and any(curve.label for curve in _visible_curves(plot)):
+        axes.legend(loc=plot.legend_position)
     return figure