rgrid-python 4.5.3.post4__py3-none-any.whl → 4.5.3.post5__py3-none-any.whl

grid_py/__init__.py

@@ -6,7 +6,7 @@ units, viewports, grobs (graphical objects), layouts, and rendering via
 Cairo (pycairo).
 """
 
-__version__ = "4.5.3.post4"
+__version__ = "4.5.3.post5"
 
 # --- Utilities ---
 from grid_py._utils import depth, explode, grid_pretty, n2mfrow

grid_py/_colour.py

@@ -761,8 +761,15 @@ def parse_r_colour(c: Any) -> Tuple[float, float, float, float]:
         s = c.strip()
         low = s.lower()
 
-        # Transparent / NA
-        if low in ("transparent", "na", "none", ""):
+        # R's ``col2rgb("transparent", alpha=TRUE)`` returns (255, 255, 255, 0)
+        # — by R convention the RGB channels are white even though α=0
+        # makes the colour invisible.  Mirror exactly so hex round-trips
+        # and downstream tooling that compares against R's encoding agree.
+        if low == "transparent":
+            return (1.0, 1.0, 1.0, 0.0)
+        # NA / none / "" are Python-port-specific transparent sentinels not
+        # defined as parseable colours in R (``col2rgb('NA')`` errors).
+        if low in ("na", "none", ""):
             return (0.0, 0.0, 0.0, 0.0)
 
         # Hex colour

grid_py/_draw.py

@@ -25,6 +25,7 @@ from ._state import get_state
 from ._display_list import DisplayList, DLDrawGrob
 from ._units import Unit
 from ._utils import grid_pretty as _grid_pretty
+from ._primitives import valid_pch
 
 __all__ = [
     "grid_draw",
@@ -307,8 +308,16 @@ def _render_grob(
 
     # ---- rect -----------------------------------------------------------
     if cls == "rect":
-        xs = renderer.resolve_x_array(getattr(grob, "x", [0.0]), gp=gp)
-        ys = renderer.resolve_y_array(getattr(grob, "y", [0.0]), gp=gp)
+        # Use paired resolve_loc_array so that under a rotated viewport
+        # each rect's anchor (x_i, y_i) is mapped through the full 2-D
+        # CTM together, not via two independent 1-D projections (which
+        # silently drop the rotation contribution from the orthogonal
+        # axis — see _renderer_base.resolve_x_array docstring).
+        xs, ys = renderer.resolve_loc_array(
+            getattr(grob, "x", [0.0]),
+            getattr(grob, "y", [0.0]),
+            gp=gp,
+        )
         ws = renderer.resolve_w_array(getattr(grob, "width", [1.0]), gp=gp)
         hs = renderer.resolve_h_array(getattr(grob, "height", [1.0]), gp=gp)
         hj, vj = _resolve_just(grob)
@@ -331,9 +340,11 @@ def _render_grob(
 
     # ---- roundrect ------------------------------------------------------
     elif cls == "roundrect":
+        ax, ay = renderer.resolve_loc(
+            getattr(grob, "x", 0.0), getattr(grob, "y", 0.0), gp=gp,
+        )
         renderer.draw_roundrect(
-            x=renderer.resolve_x(getattr(grob, "x", 0.0), gp=gp),
-            y=renderer.resolve_y(getattr(grob, "y", 0.0), gp=gp),
+            x=ax, y=ay,
             w=renderer.resolve_w(getattr(grob, "width", 1.0), gp=gp),
             h=renderer.resolve_h(getattr(grob, "height", 1.0), gp=gp),
             r=renderer.resolve_w(getattr(grob, "r", 0.0), gp=gp),
@@ -344,17 +355,22 @@ def _render_grob(
 
     # ---- circle ---------------------------------------------------------
     elif cls == "circle":
+        cx, cy = renderer.resolve_loc(
+            getattr(grob, "x", 0.5), getattr(grob, "y", 0.5), gp=gp,
+        )
         renderer.draw_circle(
-            x=renderer.resolve_x(getattr(grob, "x", 0.5), gp=gp),
-            y=renderer.resolve_y(getattr(grob, "y", 0.5), gp=gp),
+            x=cx, y=cy,
             r=renderer.resolve_w(getattr(grob, "r", 0.5), gp=gp),
             gp=gp,
         )
 
     # ---- lines / polyline ------------------------------------------------
     elif cls in ("lines", "polyline"):
-        x = renderer.resolve_x_array(getattr(grob, "x", [0.0, 1.0]), gp=gp)
-        y = renderer.resolve_y_array(getattr(grob, "y", [0.0, 1.0]), gp=gp)
+        x, y = renderer.resolve_loc_array(
+            getattr(grob, "x", [0.0, 1.0]),
+            getattr(grob, "y", [0.0, 1.0]),
+            gp=gp,
+        )
         id_ = getattr(grob, "id", None)
         id_lengths = getattr(grob, "id_lengths", None)
         # R polylineGrob supports either `id` (per-point group) or
@@ -368,12 +384,36 @@ def _render_grob(
             id_ = np.atleast_1d(np.asarray(id_, dtype=int))
         renderer.draw_polyline(x, y, id_=id_, gp=gp)
 
+        # R linesGrob / polylineGrob carry an optional ``arrow=`` (port
+        # of src/grid.c::L_lines / L_polyline arrowhead emission).  The
+        # earlier code consumed it for ``segmentsGrob`` only, silently
+        # dropping it on lines / polyline — symptom: an arrow= argument
+        # produced a bare line.  Apply ``_draw_arrow_heads`` per
+        # polyline (each unique id) here, with the same reference-point
+        # convention segments uses.
+        arr = getattr(grob, "arrow", None)
+        if arr is not None:
+            if id_ is not None:
+                for uid in np.unique(id_):
+                    mask = id_ == uid
+                    if int(np.sum(mask)) >= 2:
+                        _draw_arrow_heads(
+                            np.asarray(x)[mask], np.asarray(y)[mask],
+                            arr, renderer, gp,
+                        )
+            elif len(x) >= 2:
+                _draw_arrow_heads(
+                    np.asarray(x), np.asarray(y), arr, renderer, gp,
+                )
+
     # ---- segments --------------------------------------------------------
     elif cls == "segments":
-        x0 = renderer.resolve_x_array(getattr(grob, "x0", []), gp=gp)
-        y0 = renderer.resolve_y_array(getattr(grob, "y0", []), gp=gp)
-        x1 = renderer.resolve_x_array(getattr(grob, "x1", []), gp=gp)
-        y1 = renderer.resolve_y_array(getattr(grob, "y1", []), gp=gp)
+        x0, y0 = renderer.resolve_loc_array(
+            getattr(grob, "x0", []), getattr(grob, "y0", []), gp=gp,
+        )
+        x1, y1 = renderer.resolve_loc_array(
+            getattr(grob, "x1", []), getattr(grob, "y1", []), gp=gp,
+        )
         renderer.draw_segments(x0=x0, y0=y0, x1=x1, y1=y1, gp=gp)
 
         # Each segment may carry its own arrowhead (``arrow=`` parameter on
@@ -392,8 +432,11 @@ def _render_grob(
     elif cls == "xspline":
         from ._curve import _calc_xspline_points  # lazy to avoid import cycle
 
-        x = renderer.resolve_x_array(getattr(grob, "x", [0.0, 1.0]), gp=gp)
-        y = renderer.resolve_y_array(getattr(grob, "y", [0.0, 1.0]), gp=gp)
+        x, y = renderer.resolve_loc_array(
+            getattr(grob, "x", [0.0, 1.0]),
+            getattr(grob, "y", [0.0, 1.0]),
+            gp=gp,
+        )
         shape_raw = getattr(grob, "shape", 0.0)
         open_ = bool(getattr(grob, "open_", True))
         rep_ends = bool(getattr(grob, "repEnds", True))
@@ -474,8 +517,9 @@ def _render_grob(
 
     # ---- polygon ---------------------------------------------------------
     elif cls == "polygon":
-        px = renderer.resolve_x_array(getattr(grob, "x", []), gp=gp)
-        py = renderer.resolve_y_array(getattr(grob, "y", []), gp=gp)
+        px, py = renderer.resolve_loc_array(
+            getattr(grob, "x", []), getattr(grob, "y", []), gp=gp,
+        )
         pid = getattr(grob, "id", None)
         if pid is not None:
             # R semantics: polygonGrob(id=...) draws separate polygons
@@ -509,9 +553,8 @@ def _render_grob(
         else:
             labels = [str(label_raw)]
 
-        # Resolve x/y to arrays
-        xx = renderer.resolve_x_array(x_unit, gp=gp)
-        yy = renderer.resolve_y_array(y_unit, gp=gp)
+        # Resolve x/y as pairs so rotation contribution is preserved.
+        xx, yy = renderer.resolve_loc_array(x_unit, y_unit, gp=gp)
 
         # Normalise rot to array
         if isinstance(rot_raw, (list, tuple, np.ndarray)):
@@ -553,16 +596,20 @@ def _render_grob(
     # ---- points ----------------------------------------------------------
     elif cls == "points":
         pch_raw = getattr(grob, "pch", 19)
-        # pch may be a scalar or per-point array — pass through as-is
-        if isinstance(pch_raw, (np.ndarray, list, tuple)):
-            pch_val = np.asarray(pch_raw, dtype=int)
-        elif isinstance(pch_raw, (int, float, np.integer, np.floating)):
-            pch_val = int(pch_raw)
-        else:
-            pch_val = 19
+        # pch may be a scalar (int or single character such as "."/"A")
+        # or a per-point array (possibly MIXED int/str, e.g.
+        # [".", 19, "A"]).  R keeps character pch as character and
+        # coerces numeric pch to int (grid:::valid.pch).  Normalise via
+        # the same helper and pass the result through *unchanged* — the
+        # renderer dispatches symbol-vs-glyph per point.  Do NOT force
+        # ``dtype=int`` (that crashes on "."), and do NOT substitute a
+        # silent default for non-numeric scalars (that masks bugs).
+        pch_val = valid_pch(pch_raw)
+        pts_x, pts_y = renderer.resolve_loc_array(
+            getattr(grob, "x", []), getattr(grob, "y", []), gp=gp,
+        )
         renderer.draw_points(
-            x=renderer.resolve_x_array(getattr(grob, "x", []), gp=gp),
-            y=renderer.resolve_y_array(getattr(grob, "y", []), gp=gp),
+            x=pts_x, y=pts_y,
             size=renderer.resolve_w(getattr(grob, "size", 1.0), gp=gp),
             pch=pch_val,
             gp=gp,
@@ -570,18 +617,63 @@ def _render_grob(
 
     # ---- pathgrob --------------------------------------------------------
     elif cls == "pathgrob":
-        x = renderer.resolve_x_array(getattr(grob, "x", []), gp=gp)
-        y = renderer.resolve_y_array(getattr(grob, "y", []), gp=gp)
-        path_id = getattr(grob, "pathId", None)
+        x, y = renderer.resolve_loc_array(
+            getattr(grob, "x", []), getattr(grob, "y", []), gp=gp,
+        )
+        # R ``pathGrob`` carries two grouping levels (src/grid.c::L_path):
+        #
+        #   - id / id_lengths : per-point SUB-PATH identifier — each
+        #     unique value is one closed Cairo sub-path.
+        #   - path_id / path_id_lengths : per-sub-path COMPOUND grouping
+        #     — each compound is filled+stroked independently with its
+        #     own fill rule application.
+        #
+        # The earlier port read ``grob.pathId`` (camelCase, never stored
+        # by path_grob) and ignored ``grob.id`` entirely, so every path
+        # collapsed into a single 8-vertex sub-path that connected the
+        # two rectangles into a bow-tie.  Read both attributes properly
+        # here and pass the per-point sub-path identifier through to
+        # ``draw_path`` (which iterates unique values).
+        sub_id = getattr(grob, "id", None)
+        sub_id_lengths = getattr(grob, "id_lengths", None)
+        if sub_id is None and sub_id_lengths is not None:
+            lengths = np.atleast_1d(np.asarray(sub_id_lengths, dtype=int))
+            sub_id = np.repeat(np.arange(1, len(lengths) + 1), lengths)
+        if sub_id is None:
+            sub_id = np.ones(len(x), dtype=int)
+        else:
+            sub_id = np.atleast_1d(np.asarray(sub_id, dtype=int))
+
+        # Optional second-level compound grouping.  R fills each
+        # compound separately with its own fill-rule application.  Most
+        # uses (and every current test) have a single compound; we
+        # iterate when more are supplied.
+        path_id = getattr(grob, "path_id", None)
+        path_id_lengths = getattr(grob, "path_id_lengths", None)
+        if path_id is None and path_id_lengths is not None:
+            lengths = np.atleast_1d(np.asarray(path_id_lengths, dtype=int))
+            path_id = np.repeat(np.arange(1, len(lengths) + 1), lengths)
+        rule = getattr(grob, "rule", "winding")
+
         if path_id is None:
-            path_id = np.ones(len(x), dtype=int)
+            renderer.draw_path(
+                x=x, y=y, path_id=sub_id, rule=rule, gp=gp,
+            )
         else:
-            path_id = np.atleast_1d(np.asarray(path_id, dtype=int))
-        renderer.draw_path(
-            x=x, y=y, path_id=path_id,
-            rule=getattr(grob, "rule", "winding"),
-            gp=gp,
-        )
+            # Map per-point compound id from per-sub-path path_id.
+            path_id_arr = np.atleast_1d(np.asarray(path_id, dtype=int))
+            unique_subs = np.unique(sub_id)
+            sub_to_compound = {int(s): int(path_id_arr[k % len(path_id_arr)])
+                               for k, s in enumerate(unique_subs)}
+            point_compound = np.asarray(
+                [sub_to_compound[int(s)] for s in sub_id], dtype=int,
+            )
+            for ck in np.unique(point_compound):
+                mask = point_compound == ck
+                renderer.draw_path(
+                    x=x[mask], y=y[mask], path_id=sub_id[mask],
+                    rule=rule, gp=gp,
+                )
 
     # ---- rastergrob ------------------------------------------------------
     elif cls == "rastergrob":
@@ -590,8 +682,9 @@ def _render_grob(
             image = getattr(grob, "image", None)
         if image is not None:
             hj, vj = _resolve_just(grob)
-            raw_x = renderer.resolve_x(getattr(grob, "x", 0.0), gp=gp)
-            raw_y = renderer.resolve_y(getattr(grob, "y", 0.0), gp=gp)
+            raw_x, raw_y = renderer.resolve_loc(
+                getattr(grob, "x", 0.0), getattr(grob, "y", 0.0), gp=gp,
+            )
             raw_w = renderer.resolve_w(getattr(grob, "width", 1.0), gp=gp)
             raw_h = renderer.resolve_h(getattr(grob, "height", 1.0), gp=gp)
             # `renderer.draw_raster` expects the *top-left* corner in y-down

grid_py/_primitives.py

@@ -56,6 +56,7 @@ __all__ = [
     "arrows_grob",
     "grid_arrows",
     # points
+    "valid_pch",
     "points_grob",
     "grid_points",
     # rect
@@ -706,6 +707,70 @@ def grid_arrows(
 # ===================================================================== #
 
 
+def valid_pch(pch: Any) -> Any:
+    """Validate / normalise a plotting character (``pch``).
+
+    Faithful port of R's ``grid:::valid.pch`` (primitives.R:1504-1512)::
+
+        valid.pch <- function(pch) {
+          if (length(pch) == 0L) stop("zero-length 'pch'")
+          if (is.null(pch))      pch <- 1L
+          else if (!is.character(pch)) pch <- as.integer(pch)
+          pch
+        }
+
+    Semantics, verified against grid 4.5.3:
+
+    * **Zero-length** input (e.g. ``[]``, ``np.array([])``) → ``ValueError``.
+      (In R ``length(NULL) == 0`` so ``NULL`` also hits this branch and
+      errors; the ``is.null`` arm is effectively unreachable.  We keep a
+      ``None`` → ``1`` arm for ergonomics, matching the *written* R source
+      rather than its dead-code quirk, since ``None`` is the natural
+      Python sentinel for "use the default".)
+    * **Character** ``pch`` is kept *as character* (e.g. ``"."`` stays
+      ``"."``; the engine later draws it as a glyph / tiny point).
+    * **Any other (numeric)** ``pch`` is coerced to ``int`` (truncating
+      floats, mirroring ``as.integer``).
+    * **Mixed** sequences containing any character element are kept as an
+      object array of per-point values (R's ``c(".", 19, "A")`` coerces
+      to the character vector ``c(".", "19", "A")``; we preserve each
+      element so the per-point dispatch can decide glyph-vs-symbol).
+
+    Returns the normalised ``pch``: an ``int``, a ``str``, or a numpy
+    array of per-point values (int dtype if all-numeric, else object).
+    """
+    if pch is None:
+        return 1
+
+    if isinstance(pch, str):
+        return pch
+
+    if isinstance(pch, (int, np.integer)):
+        return int(pch)
+    if isinstance(pch, (float, np.floating)):
+        return int(pch)  # as.integer truncates toward zero
+
+    if isinstance(pch, (list, tuple, np.ndarray)):
+        arr = np.atleast_1d(np.asarray(pch, dtype=object))
+        if arr.size == 0:
+            raise ValueError("zero-length 'pch'")
+        # If any element is a (non-numeric) string, R coerces the whole
+        # vector to character.  We keep per-element values in an object
+        # array so the renderer can dispatch each point individually.
+        has_char = any(isinstance(v, (str, bytes, np.str_)) for v in arr)
+        if has_char:
+            return np.asarray(
+                [v if isinstance(v, (str, bytes, np.str_)) else str(v)
+                 for v in arr],
+                dtype=object,
+            )
+        # All numeric → integer array (as.integer).
+        return np.asarray([int(v) for v in arr], dtype=int)
+
+    # Fallback for any other scalar numeric-like (e.g. numpy bool):
+    return int(pch)
+
+
 def points_grob(
     x: Any = None,
     y: Any = None,
@@ -770,6 +835,8 @@ def points_grob(
         size = Unit(1, "char")
     else:
         size = _ensure_unit(size, default_units)
+    # R: validDetails.points -> x$pch <- valid.pch(x$pch)
+    pch = valid_pch(pch)
     return Grob(
         x=x, y=y, pch=pch, size=size,
         name=name, gp=gp, vp=vp, _grid_class="points",

grid_py/_renderer_base.py

@@ -91,7 +91,17 @@ class GridRenderer(ABC):
         # containing width_cm, height_cm, rotation_angle, 3×3 transform matrix,
         # and ViewportContext (xscale/yscale).
         # The root entry represents the device itself.
-        root_vtr = calc_root_transform(self._device_width_cm, self._device_height_cm)
+        # ``y_down`` is True for raster surfaces (PNG / ImageSurface),
+        # False for vector surfaces (PDF / SVG / PS) — matches R's
+        # per-device behaviour in src/viewport.c:initVP.  We probe the
+        # subclass via ``_surface_type`` (CairoRenderer's flag); raster
+        # is the default when the subclass has not declared one.
+        _surface_type = getattr(self, "_surface_type", "image")
+        root_vtr = calc_root_transform(
+            self._device_width_cm, self._device_height_cm,
+            dev_units_per_inch=self._dev_units_per_inch,
+            y_down=(_surface_type == "image"),
+        )
         self._vp_transform_stack: List[ViewportTransformResult] = [root_vtr]
 
         # Keep a parallel list of viewport objects for attribute access
@@ -216,7 +226,14 @@ class GridRenderer(ABC):
         # layout (for its children).  In R, layout_pos determines the
         # viewport's own size/position first, then the layout applies
         # within that region.
-        if layout_pos_row is not None and layout_pos_col is not None:
+        #
+        # Per R src/layout.c:617-633 ``calcViewportLocationFromLayout``:
+        # exactly ONE of layoutPosRow / layoutPosCol may be NULL — that
+        # is interpreted as "occupy all rows/cols".  We mirror the
+        # behaviour here so e.g. ``viewport(layout_pos_col=i)`` in a
+        # 1-row layout correctly spans the whole row instead of
+        # collapsing back to centre.
+        if layout_pos_row is not None or layout_pos_col is not None:
             if self._layout_stack:
                 grid = self._layout_stack[-1]
                 col_starts = grid["col_starts"]
@@ -224,11 +241,19 @@ class GridRenderer(ABC):
                 row_starts = grid["row_starts"]
                 row_heights = grid["row_heights"]
 
-                if isinstance(layout_pos_row, (list, tuple)):
+                if layout_pos_row is None:
+                    # NULL → span all rows (R layout.c:621-624).
+                    t = 0
+                    b = len(row_heights) - 1
+                elif isinstance(layout_pos_row, (list, tuple)):
                     t, b = int(layout_pos_row[0]) - 1, int(layout_pos_row[1]) - 1
                 else:
                     t = b = int(layout_pos_row) - 1
-                if isinstance(layout_pos_col, (list, tuple)):
+                if layout_pos_col is None:
+                    # NULL → span all cols (R layout.c:628-631).
+                    l = 0
+                    r = len(col_widths) - 1
+                elif isinstance(layout_pos_col, (list, tuple)):
                     l, r = int(layout_pos_col[0]) - 1, int(layout_pos_col[1]) - 1
                 else:
                     l = r = int(layout_pos_col) - 1
@@ -857,18 +882,24 @@ class GridRenderer(ABC):
         h_in = _details_inches(height_details, "y")
 
         # hjust / vjust control which corner of the box is anchored at (x, y).
-        def _just_to_float(v: Any, default: float) -> float:
-            if v is None:
-                return default
-            if isinstance(v, (int, float)):
-                return float(v)
-            _H = {"left": 0.0, "right": 1.0, "centre": 0.5, "center": 0.5}
-            _V = {"bottom": 0.0, "top": 1.0, "centre": 0.5, "center": 0.5}
-            s = str(v).lower()
-            return _H.get(s, _V.get(s, default))
-
-        hjust = _just_to_float(getattr(grob, "hjust", 0.5), 0.5)
-        vjust = _just_to_float(getattr(grob, "vjust", 0.5), 0.5)
+        #
+        # Per R/just.R (4.5.3) ``resolveHJust`` / ``resolveVJust``:
+        # when ``hjust`` / ``vjust`` is NULL the value is derived from
+        # ``just`` (which may be a string like ``"left"`` or a 2-element
+        # vector).  Previously this code looked at ``grob.hjust`` and
+        # ``grob.vjust`` only, so a grob built with
+        # ``rect_grob(just="left")`` (which stores ``hjust=None``,
+        # ``just="left"``) fell back to centre.  Going through the
+        # shared ``resolve_hjust`` / ``resolve_vjust`` helpers brings
+        # the bbox computation in line with R for every just-string
+        # form (single string, tuple of strings, numeric, mixed).
+        from ._just import resolve_hjust, resolve_vjust
+
+        just = getattr(grob, "just", None)
+        if just is None:
+            just = "centre"
+        hjust = float(resolve_hjust(just, getattr(grob, "hjust", None)))
+        vjust = float(resolve_vjust(just, getattr(grob, "vjust", None)))
 
         # Centre of the bounding box in inches.
         cx = x_inches + (0.5 - hjust) * w_in
@@ -1090,7 +1121,16 @@ class GridRenderer(ABC):
         return self.inches_to_dev_h(inches)
 
     def resolve_x_array(self, val: Any, gp: Optional[Any] = None) -> "np.ndarray":
-        """Resolve *val* to an array of device x-coordinates."""
+        """Resolve *val* to an array of device x-coordinates.
+
+        WARNING: this method evaluates each ``x_i`` against a hard-coded
+        ``y=0``.  That is exact for an unrotated viewport, but for a
+        viewport with non-zero ``angle`` the rotation component of the
+        2-D CTM mixes the x and y axes — the y=0 stub then drops part
+        of the answer.  ``resolve_loc_array`` (below) does the
+        rotation-correct pairing and is what every drawing site
+        should use whenever an associated ``y`` array exists.
+        """
         from ._units import Unit
         if isinstance(val, Unit):
             out = np.empty(len(val), dtype=float)
@@ -1103,8 +1143,90 @@ class GridRenderer(ABC):
             return np.asarray([self.resolve_x(v, gp) for v in val], dtype=float)
         return np.atleast_1d(np.asarray(val, dtype=float))
 
+    def resolve_loc(
+        self,
+        x_val: Any,
+        y_val: Any,
+        gp: Optional[Any] = None,
+    ) -> Tuple[float, float]:
+        """Resolve an ``(x, y)`` location pair to device coordinates.
+
+        Port of R's ``transformLocn`` (src/unit.c) one-shot pairing —
+        the inches values for both axes are passed through the
+        viewport's 3×3 transform together so that rotation correctly
+        mixes them.
+
+        Unlike ``resolve_x(val) + resolve_y(val)``, which each call
+        ``transform_loc_to_device`` with the orthogonal coord forced to
+        0 and so cannot represent the rotation contribution, this
+        helper preserves both inputs and matches ``device_loc``'s
+        algorithm.
+
+        Every grob-drawing site with a genuine 2-D anchor (rect,
+        circle, text, roundrect, raster, ...) should use this in
+        preference to the single-axis helpers.
+        """
+        x_in = self._resolve_to_inches(x_val, axis="x", is_dim=False, gp=gp)
+        y_in = self._resolve_to_inches(y_val, axis="y", is_dim=False, gp=gp)
+        return self.transform_loc_to_device(x_in, y_in)
+
+    def resolve_loc_array(
+        self,
+        x_vals: Any,
+        y_vals: Any,
+        gp: Optional[Any] = None,
+    ) -> Tuple["np.ndarray", "np.ndarray"]:
+        """Resolve parallel ``x`` / ``y`` arrays to device coord pairs.
+
+        Each ``(x_i, y_i)`` pair is mapped through the full 2-D vp
+        transform via ``transform_loc_to_device``, so polygon / lines /
+        segments / points vertices stay self-consistent under
+        rotation.  Length follows R's recycling rule — the longer of
+        ``len(x_vals)`` and ``len(y_vals)``.
+        """
+        from ._units import Unit
+
+        def _length(v: Any) -> int:
+            return len(v) if hasattr(v, "__len__") and not isinstance(v, str) else 1
+
+        nx = _length(x_vals)
+        ny = _length(y_vals)
+        n = max(nx, ny)
+
+        out_x = np.empty(n, dtype=float)
+        out_y = np.empty(n, dtype=float)
+
+        for i in range(n):
+            # x_i in inches (viewport-local frame)
+            if isinstance(x_vals, Unit):
+                x_in = self._resolve_to_inches_idx(x_vals, i % nx, "x", False, gp)
+            elif isinstance(x_vals, (list, tuple, np.ndarray)):
+                x_in = self._resolve_to_inches(
+                    x_vals[i % nx], axis="x", is_dim=False, gp=gp,
+                )
+            else:
+                x_in = self._resolve_to_inches(x_vals, axis="x", is_dim=False, gp=gp)
+            # y_i in inches
+            if isinstance(y_vals, Unit):
+                y_in = self._resolve_to_inches_idx(y_vals, i % ny, "y", False, gp)
+            elif isinstance(y_vals, (list, tuple, np.ndarray)):
+                y_in = self._resolve_to_inches(
+                    y_vals[i % ny], axis="y", is_dim=False, gp=gp,
+                )
+            else:
+                y_in = self._resolve_to_inches(y_vals, axis="y", is_dim=False, gp=gp)
+
+            out_x[i], out_y[i] = self.transform_loc_to_device(x_in, y_in)
+
+        return out_x, out_y
+
     def resolve_y_array(self, val: Any, gp: Optional[Any] = None) -> "np.ndarray":
-        """Resolve *val* to an array of device y-coordinates."""
+        """Resolve *val* to an array of device y-coordinates.
+
+        Like ``resolve_x_array`` this loses the rotation contribution
+        from the orthogonal axis (x is forced to 0).  Prefer
+        ``resolve_loc_array`` whenever a paired x is available.
+        """
         from ._units import Unit
         if isinstance(val, Unit):
             out = np.empty(len(val), dtype=float)

grid_py/_state.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 
 import copy
 from collections import deque
+from types import SimpleNamespace
 from typing import Any, Deque, Dict, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
@@ -50,15 +51,31 @@ def _make_root_viewport() -> Any:
     dict
         A mapping that quacks like a viewport for bootstrap purposes.
     """
-    return {
-        "name": "ROOT",
-        "parent": None,
-        "children": [],
-        "layout_pos": None,
-        "gpar": Gpar(),
-        "rotation": 0.0,
-        "transform": np.eye(3, dtype=np.float64),
-    }
+    # Default xscale/yscale = (0, 1).  At ``init_device`` time these get
+    # overwritten with (0, dev_w_px) / (0, dev_h_px) to mirror R's
+    # ``initVP`` (src/viewport.c:399-406):
+    #   REAL(xscale)[0] = dd->dev->left;
+    #   REAL(xscale)[1] = dd->dev->right;
+    #   REAL(yscale)[0] = dd->dev->bottom;
+    #   REAL(yscale)[1] = dd->dev->top;
+    # which is what makes ``unit(..., "native")`` resolve to device pixels
+    # at the root viewport.
+    #
+    # We expose the root as a ``SimpleNamespace`` so callers can use the
+    # R-style ``vp.xscale`` / ``vp.yscale`` attribute access (mirroring
+    # ``current.viewport()$xscale`` in R) while still keeping the duck-
+    # typed dict-style ``_vp_attr`` helper.
+    return SimpleNamespace(
+        name="ROOT",
+        parent=None,
+        children=[],
+        layout_pos=None,
+        gpar=Gpar(),
+        rotation=0.0,
+        transform=np.eye(3, dtype=np.float64),
+        xscale=(0.0, 1.0),
+        yscale=(0.0, 1.0),
+    )
 
 
 def _vp_attr(vp: Any, attr: str, default: Any = None) -> Any:
@@ -508,10 +525,25 @@ class GridState:
         float
             The sum of ``rotation`` attributes from root to current viewport.
         """
+        # R always treats a missing or NULL rotation as 0 (src/viewport.c:
+        # initVP / addRotation paths default angle=0).  Mirror that here
+        # without try/except.
+        #
+        # Two attribute names coexist in grid_py for historical reasons:
+        # ``Viewport`` instances expose the user-supplied angle as
+        # ``vp.angle`` (matching R's ``viewport(angle=)`` argument), while
+        # the root SimpleNamespace + pushedvp metadata uses ``rotation``.
+        # Both designate the same quantity — this viewport's own rotation
+        # contribution — so we read whichever is present, preferring
+        # ``angle`` for Viewport / R parity.  R itself walks the vp stack
+        # summing each vp's ``angle`` slot, which is what we mirror.
         total: float = 0.0
         vp: Any = self._current_vp
         while vp is not None:
-            total += float(_vp_attr(vp, "rotation", 0.0))
+            rot = _vp_attr(vp, "angle", None)
+            if rot is None:
+                rot = _vp_attr(vp, "rotation", 0.0)
+            total += float(rot if rot is not None else 0.0)
             vp = _vp_parent(vp)
         return total
 
@@ -686,6 +718,32 @@ class GridState:
         self._device_width_cm = float(width_cm)
         self._device_height_cm = float(height_cm)
 
+        # Mirror R src/viewport.c:initVP — set the ROOT viewport's
+        # xscale/yscale to the device coord range.  The orientation
+        # follows the device convention:
+        #   raster (PNG, CairoImage): pixel coords, y INCREASES DOWN
+        #     → xscale=(0, w_px), yscale=(h_px, 0)
+        #   vector (PDF, SVG, PS):    point coords, y INCREASES UP
+        #     → xscale=(0, w_pt), yscale=(0, h_pt)
+        # The renderer's ``_surface_type`` ("image" vs anything else)
+        # tells us which axis convention to use.  This keeps the dict-
+        # accessible xscale/yscale in sync with the transform stack's
+        # ``vpc`` (set by ``calc_root_transform`` in _vp_calc.py).
+        dpi = float(getattr(renderer, "dpi", 0.0) or 0.0)
+        if dpi > 0:
+            surface_type = getattr(renderer, "_surface_type", "image")
+            if surface_type == "image":
+                dev_w = self._device_width_cm / 2.54 * dpi
+                dev_h = self._device_height_cm / 2.54 * dpi
+                _vp_set_attr(self._vp_tree, "xscale", (0.0, dev_w))
+                _vp_set_attr(self._vp_tree, "yscale", (dev_h, 0.0))
+            else:
+                # Vector surface: 72 user units per inch, y-up.
+                dev_w = self._device_width_cm / 2.54 * 72.0
+                dev_h = self._device_height_cm / 2.54 * 72.0
+                _vp_set_attr(self._vp_tree, "xscale", (0.0, dev_w))
+                _vp_set_attr(self._vp_tree, "yscale", (0.0, dev_h))
+
     def get_renderer(self) -> Any:
         """Return the current rendering backend.
 

grid_py/_vp_calc.py

@@ -955,16 +955,58 @@ def calc_viewport_transform(
 def calc_root_transform(
     device_width_cm: float,
     device_height_cm: float,
+    dev_units_per_inch: Optional[float] = None,
+    y_down: bool = True,
 ) -> ViewportTransformResult:
     """Compute the root (device-level) viewport transform.
 
-    Port of ``viewport.c:233-260``: when the parent is NULL (top-level
-    viewport), the parent is the device itself.
+    Port of ``viewport.c:initVP`` (src/viewport.c:384-420 in R 4.5.3).
+    After the R-level ``grid.top.level.vp()`` constructs a default
+    viewport (xscale=c(0,1), yscale=c(0,1)), R immediately overrides
+    those scales with the device coordinate range::
+
+        REAL(xscale)[0] = dd->dev->left;
+        REAL(xscale)[1] = dd->dev->right;
+        REAL(yscale)[0] = dd->dev->bottom;
+        REAL(yscale)[1] = dd->dev->top;
+
+    For a raster device the range is in pixels; for a vector device it
+    is in points (1/72 inch).  In grid_py the unit-per-inch is encoded
+    by *dev_units_per_inch*: ``dpi`` for raster surfaces, ``72`` for
+    vector.  When that argument is omitted we fall back to (0, 1) —
+    the historical behaviour — purely to avoid breaking callers that
+    don't yet thread dpi through; new code should pass it.
+
+    Parameters
+    ----------
+    device_width_cm, device_height_cm
+        Physical canvas size in centimetres.
+    dev_units_per_inch
+        Device units per inch (``dpi`` for raster, ``72`` for vector).
+        When supplied, ``xscale=(0, dev_w_px)`` and
+        ``yscale=(0, dev_h_px)`` so that ``unit(v, "native")`` at the
+        root viewport resolves to device pixels exactly as in R.
     """
+    if dev_units_per_inch is not None and dev_units_per_inch > 0:
+        dev_w_px = (device_width_cm / 2.54) * dev_units_per_inch
+        dev_h_px = (device_height_cm / 2.54) * dev_units_per_inch
+        xscale = (0.0, float(dev_w_px))
+        # R's PNG / raster devices have ``dev->bottom = h_px`` and
+        # ``dev->top = 0`` (pixel y increases downward), so initVP
+        # produces ``yscale = (h_px, 0)``.  Vector devices (PDF, PS)
+        # are bottom-up: ``yscale = (0, h_pt)``.  Mirror both.
+        if y_down:
+            yscale = (float(dev_h_px), 0.0)
+        else:
+            yscale = (0.0, float(dev_h_px))
+    else:
+        xscale = (0.0, 1.0)
+        yscale = (0.0, 1.0)
+
     return ViewportTransformResult(
         width_cm=device_width_cm,
         height_cm=device_height_cm,
         rotation_angle=0.0,
         transform=identity(),
-        vpc=ViewportContext(xscale=(0.0, 1.0), yscale=(0.0, 1.0)),
+        vpc=ViewportContext(xscale=xscale, yscale=yscale),
     )

grid_py/renderer.py

@@ -274,7 +274,11 @@ class CairoRenderer(GridRenderer):
         from ._vp_calc import calc_root_transform
         mask_w_in = float(dw) / self.dpi
         mask_h_in = float(dh) / self.dpi
-        root_vtr = calc_root_transform(mask_w_in * 2.54, mask_h_in * 2.54)
+        # Mask surfaces are raster (Cairo IMAGE) → use dpi as device units/in.
+        root_vtr = calc_root_transform(
+            mask_w_in * 2.54, mask_h_in * 2.54,
+            dev_units_per_inch=self.dpi,
+        )
         mask_renderer._vp_transform_stack = [root_vtr]
         mask_renderer._vp_obj_stack = [None]
         mask_renderer._layout_stack = []
@@ -353,28 +357,48 @@ class CairoRenderer(GridRenderer):
 
     # ---- gpar application --------------------------------------------------
 
-    def _lwd_to_user(self, lwd_pt: float) -> float:
-        """Convert R-grid lwd (points) to a Cairo user-space line width.
-
-        R's grid measures ``lwd`` in 1/72 inch (points) regardless of the
-        active viewport scale — a value of 1 should always produce a stroke
-        1pt wide on the output medium.  Cairo's ``set_line_width`` takes a
-        user-space distance, so we have to:
-
-        1. Map points → device units.  Raster ``ImageSurface`` has 1 user
-           unit = 1 pixel, so device units per point = ``dpi/72``.  Vector
-           surfaces (PDF/SVG/PS) have 1 user unit = 1 pt, so the conversion
-           factor is 1.0.  Equivalently, use ``_dev_units_per_inch / 72``.
-        2. Undo any active CTM scaling via ``device_to_user_distance`` so
-           that nested viewports (which scale the CTM) do not also scale
-           the stroke.
-
-        This is the analogue of the font-size handling in ``_set_font``.
+    # R-grid lwd unit conversion factor.
+    # ----------------------------------------------------------------
+    # R's gpar() lwd argument is in **1/96 inch** (per ?gpar in R 3.0+).
+    # Internally R's Cairo device (src/library/grDevices/src/cairoFns.c)
+    # converts lwd to cairo user-space (= points) using
+    #     cairo_user = lwd * 72.27 / 96
+    # — the 72.27 is the TeX big-point per inch constant R inherits
+    # from its PostScript ancestry, retained for backward parity with
+    # R's vector devices.  Reproducing the same constant here keeps
+    # stroke widths bit-for-bit identical with R Cairo across raster
+    # and vector surfaces.
+    _LWD_BIGPOINT_PER_96TH_INCH: float = 72.27 / 96.0
+
+    def _lwd_to_user(self, lwd: float) -> float:
+        """Convert R-grid lwd (units of 1/96 inch) to a Cairo user-space
+        line width.
+
+        Earlier this method treated ``lwd`` as if it were in points
+        (1/72 inch).  Empirical R-vs-grid_py measurement shows every
+        stroke is then 96/72 = 1.333× wider than R's — a port bug
+        affecting *all* primitives that stroke (rect / circle /
+        polygon / lines / segments / points-pch / arrow).  R's actual
+        convention is lwd = 1/96 inch, mirrored here via
+        ``_LWD_BIGPOINT_PER_96TH_INCH``.
+
+        Pipeline:
+
+        1. Convert ``lwd × (72.27/96)`` (TeX points) to device units —
+           raster surfaces use ``dpi/72``; vector surfaces keep the
+           value in points.
+        2. Run the result through ``device_to_user_distance`` so any
+           CTM scaling (rotated/scaled viewport) does not also scale
+           the stroke.  This matches R's behaviour: ``lwd`` is a
+           device-level width, independent of viewport coordinate
+           changes.
         """
+        # 1/96 inch → TeX big-points (the unit R hands to Cairo)
+        lwd_bp = lwd * self._LWD_BIGPOINT_PER_96TH_INCH
         if self._surface_type == "image":
-            lw_dev = lwd_pt * self.dpi / 72.0
+            lw_dev = lwd_bp * self.dpi / 72.0
         else:
-            lw_dev = lwd_pt
+            lw_dev = lwd_bp
         try:
             ux, uy = self._ctx.device_to_user_distance(lw_dev, lw_dev)
             return max(abs(ux), abs(uy))
@@ -840,10 +864,46 @@ class CairoRenderer(GridRenderer):
         vjust: float = 0.5,
         gp: Optional[Gpar] = None,
     ) -> None:
-        """Draw a rectangle.  x, y, w, h are in device coordinates."""
+        """Draw a rectangle.
+
+        Parameters
+        ----------
+        x, y : float
+            Anchor point in **device coords** (already mapped through
+            the viewport CTM, including rotation, by
+            ``resolve_loc_array``).
+        w, h : float
+            Width / height in device units of the viewport-local
+            (i.e. unrotated) frame.
+        hjust, vjust : float
+            Justification of the rect relative to ``(x, y)``.
+        gp : Gpar, optional
+            Graphical parameters.
+
+        Implementation note
+        -------------------
+        ``(x, y)`` is the *rotated* anchor and ``(w, h)`` are the
+        *unrotated* dimensions, so we still have to orient the box.
+        We rotate the Cairo CTM around the anchor by the cumulative
+        viewport rotation; the axis-aligned ``ctx.rectangle`` then
+        becomes the rotated rect in device space.  This matches R's
+        grid C engine which applies the device CTM (including
+        rotation) at draw time — see ``src/grid.c``'s ``L_rect``
+        + the LTransform machinery in ``viewport.c``.
+        """
+        from ._state import get_state
+
         ctx = self._ctx
         ctx.save()
 
+        rotation_deg = float(get_state().current_rotation())
+        if abs(rotation_deg) > 1e-9:
+            # Cairo's y axis grows downward, R-grid's grows upward —
+            # invert sign so a positive R angle visually matches.
+            ctx.translate(x, y)
+            ctx.rotate(-math.radians(rotation_deg))
+            ctx.translate(-x, -y)
+
         # x,y is the anchor point; apply justification to get top-left
         dx = x - w * hjust
         dy = y - h * (1.0 - vjust)  # device y increases downward
@@ -1366,6 +1426,85 @@ class CairoRenderer(GridRenderer):
 
         ctx.restore()
 
+    def _draw_pch_dot(
+        self,
+        ctx: Any,
+        cx: float,
+        cy: float,
+        r: float,
+        col_rgba: Tuple[float, float, float, float],
+        cex: float = 1.0,
+    ) -> None:
+        """Draw R's ``pch="."`` — a *tiny* filled point.
+
+        R's engine (``GESymbol``) draws ``'.'`` as a small filled
+        **rectangle** whose side is an engine constant (~0.01 inch)
+        scaled by ``cex``, **independent of the symbol size**.  Verified
+        against grid 4.5.3: at 72 dpi the dot is ~1px regardless of the
+        points-grob ``size``, growing only with large ``cex``.  We
+        mirror that by drawing a small filled square (a circle would
+        antialias away at sub-pixel radius), so it reads as a single
+        dot rather than a full symbol-19 disc or a full-size glyph.
+
+        ``r`` (the resolved symbol radius) is intentionally unused for the
+        dot's *size* — kept in the signature for call-site symmetry.
+        """
+        # ~0.01 inch side at cex=1, in device units.  For image surfaces
+        # device units are pixels (dpi-scaled); for vector surfaces they
+        # are points (72 per inch).  Floor at 1 device unit so the dot is
+        # always a solidly-visible pixel (matching R, whose '.' never
+        # vanishes), exactly as R's GERect renders a minimum dot.
+        if self._surface_type == "image":
+            side = 0.01 * self.dpi * cex
+        else:
+            side = 0.01 * 72.0 * cex
+        side = max(side, 1.0)
+        half = side / 2.0
+        if col_rgba[3] > 0:
+            ctx.save()
+            ctx.new_path()
+            ctx.rectangle(cx - half, cy - half, side, side)
+            ctx.set_source_rgba(*col_rgba)
+            ctx.fill()
+            ctx.restore()
+
+    def _draw_pch_glyph(
+        self,
+        ctx: Any,
+        ch: str,
+        cx: float,
+        cy: float,
+        r: float,
+        col_rgba: Tuple[float, float, float, float],
+        gp: Optional[Gpar] = None,
+    ) -> None:
+        """Draw a single-character pch (e.g. ``"A"``) as a glyph.
+
+        R's engine renders a non-``'.'`` character pch as that glyph,
+        horizontally and vertically centred on the point, sized by the
+        font (``cex * fontsize``).  We reuse the renderer's font setup
+        and centre the glyph on ``(cx, cy)`` via its ink extents — the
+        same centring R uses for symbol text.
+        """
+        if not ch or col_rgba[3] <= 0:
+            return
+        ctx.save()
+        self._set_font(gp)
+        ext = ctx.text_extents(ch)
+        # Centre the glyph's ink box on (cx, cy).  text_extents gives
+        # x_bearing/y_bearing relative to the pen origin; centring the
+        # ink box requires offsetting by bearing + half-extent.
+        off_x = -(ext.x_bearing + ext.width / 2.0)
+        off_y = -(ext.y_bearing + ext.height / 2.0)
+        ctx.set_source_rgba(*col_rgba)
+        ctx.move_to(cx + off_x, cy + off_y)
+        if self._path_collecting:
+            ctx.text_path(ch)
+            ctx.fill()
+        else:
+            ctx.show_text(ch)
+        ctx.restore()
+
     def draw_points(
         self,
         x: np.ndarray,
@@ -1397,24 +1536,61 @@ class CairoRenderer(GridRenderer):
             return
 
         # --- per-point pch array ---
+        # ``pch`` may be a numeric symbol code (0-25), a single
+        # character (a glyph such as "A", or "." for R's tiny point),
+        # or a MIXED per-point sequence (e.g. [".", 19, "A"]).  R keeps
+        # character pch as character and coerces numerics to int
+        # (grid:::valid.pch), so the value reaching us is already
+        # normalised — we must NOT force ``dtype=int`` (it crashes on
+        # "."), only preserve each element as int-or-str in an object
+        # array and dispatch per point below.
         if isinstance(pch, (list, tuple, np.ndarray)):
-            pch_arr = np.asarray(pch, dtype=int)
+            pch_arr = np.atleast_1d(np.asarray(pch, dtype=object))
         else:
-            pch_arr = np.full(n, int(pch), dtype=int)
+            pch_arr = np.array([pch], dtype=object)
+        # Coerce numeric-looking scalars to int once, leave strings as-is.
+        pch_arr = np.array(
+            [int(p) if isinstance(p, (int, float, np.integer, np.floating))
+             else p for p in pch_arr],
+            dtype=object,
+        )
         if len(pch_arr) < n:
             pch_arr = np.resize(pch_arr, n)
 
-        # --- per-point sizes from gpar.fontsize (R: cex * fontsize) ---
+        # --- per-point sizes ---------------------------------------
+        # Two paths, distinguished by where the size originated:
+        #
+        #   (1) ``gp.fontsize`` is set → ``size_arr`` is in points
+        #       (R: cex * fontsize), so we convert pt → device pixels
+        #       via ``dpi/72`` and halve to get a radius.
+        #
+        #   (2) ``gp.fontsize`` is absent → ``size`` is what _draw.py
+        #       resolved from ``grob.size`` via ``renderer.resolve_w``,
+        #       which already returns DEVICE PIXELS.  In that case the
+        #       previous code re-applied the dpi/72 scaling, producing
+        #       symbols ~``dpi/72``× too large (e.g. at 150 dpi the
+        #       diameter came out ~2× R).  Mirror R's points.c which
+        #       uses the size unit-resolved value directly as the
+        #       symbol diameter, so radius = size / 2.
+        size_from_fontsize: bool
         fs = gp.get("fontsize", None) if gp else None
         if isinstance(fs, (list, tuple, np.ndarray)):
             size_arr = np.asarray(fs, dtype=float)
+            size_from_fontsize = True
         elif fs is not None:
             size_arr = np.full(n, float(fs))
+            size_from_fontsize = True
         else:
             size_arr = np.full(n, float(size))
+            size_from_fontsize = False
 
-        # Radius conversion: fontsize (pt) → device pixels
-        scale = self.dpi / 72.0 * 0.5 if self._surface_type == "image" else 0.5
+        if size_from_fontsize:
+            # fontsize is in points → convert to device-pixel radius.
+            scale = (self.dpi / 72.0 * 0.5
+                     if self._surface_type == "image" else 0.5)
+        else:
+            # ``size`` already in device pixels (diameter) → radius=size/2.
+            scale = 0.5
 
         # --- per-point colours (col) ---
         col_raw = gp.get("col", None) if gp else None
@@ -1445,17 +1621,49 @@ class CairoRenderer(GridRenderer):
         else:
             lwd_arr = np.full(n, 1.0)
 
+        # --- per-point cex (used only for the pch="." dot size) ---
+        cex_raw = gp.get("cex", None) if gp else None
+        if isinstance(cex_raw, (list, tuple, np.ndarray)):
+            cex_arr = np.asarray(cex_raw, dtype=float)
+        elif cex_raw is not None:
+            cex_arr = np.full(n, float(cex_raw))
+        else:
+            cex_arr = np.full(n, 1.0)
+
         for i in range(n):
             cx = x[i]
             cy = y[i]
             r = size_arr[i] * scale if i < len(size_arr) else size * scale
             lwd_i = float(lwd_arr[i % len(lwd_arr)])
-            self._draw_pch_shape(
-                ctx, int(pch_arr[i]), cx, cy, r,
-                col_rgba=col_list[i],
-                fill_rgba=fill_list[i],
-                lwd=lwd_i,
-            )
+            pch_i = pch_arr[i]
+            if isinstance(pch_i, (str, bytes, np.str_)):
+                # Character pch.  R's engine takes only the FIRST
+                # character of the string for a per-point glyph.
+                ch = str(pch_i)
+                if ch == ".":
+                    # R's pch="." draws a tiny filled point (a small
+                    # engine-constant rect, scaled by cex).  Render a
+                    # tiny filled circle so it reads as a single pixel-
+                    # scale dot rather than the symbol-19 disc or a
+                    # full-size glyph.  ``r`` is the symbol radius; the
+                    # dot is a small fraction of it (matching R's "."
+                    # which is visually ~1px at default cex).
+                    self._draw_pch_dot(
+                        ctx, cx, cy, r, col_rgba=col_list[i],
+                        cex=float(cex_arr[i % len(cex_arr)]),
+                    )
+                else:
+                    self._draw_pch_glyph(
+                        ctx, ch[:1], cx, cy, r,
+                        col_rgba=col_list[i], gp=gp,
+                    )
+            else:
+                self._draw_pch_shape(
+                    ctx, int(pch_i), cx, cy, r,
+                    col_rgba=col_list[i],
+                    fill_rgba=fill_list[i],
+                    lwd=lwd_i,
+                )
 
         ctx.restore()
 
@@ -1476,6 +1684,18 @@ class CairoRenderer(GridRenderer):
         # Handle colour string arrays (e.g. from colourbar raster)
         # Convert colour strings to uint8 RGBA
         if img_array.dtype.kind in ("U", "S", "O"):
+            # A colour-string raster must be 2-D (rows × cols of colours).
+            # A 1-D vector here means an upstream bug fed a flat colour
+            # vector instead of a matrix.  Fail loud rather than silently
+            # coercing it to a 1-row strip (that would mask the caller's
+            # error and produce wrong output).
+            if img_array.ndim != 2:
+                ctx.restore()
+                raise ValueError(
+                    "raster image must be 2-D (got shape "
+                    f"{img_array.shape}); a colour-string raster needs "
+                    "rows × columns of colours, not a flat vector"
+                )
             h_img, w_img = img_array.shape[:2]
             rgba = np.zeros((h_img, w_img, 4), dtype=np.uint8)
             for r in range(h_img):
@@ -1554,10 +1774,21 @@ class CairoRenderer(GridRenderer):
         vjust: float = 0.5,
         gp: Optional[Gpar] = None,
     ) -> None:
-        """Draw a rounded rectangle.  All coords in device units."""
+        """Draw a rounded rectangle.  Anchor in device units; (w, h)
+        in the viewport-local (unrotated) frame.  CTM rotation applied
+        around the anchor for the same reason as ``draw_rect``.
+        """
+        from ._state import get_state
+
         ctx = self._ctx
         ctx.save()
 
+        rotation_deg = float(get_state().current_rotation())
+        if abs(rotation_deg) > 1e-9:
+            ctx.translate(x, y)
+            ctx.rotate(-math.radians(rotation_deg))
+            ctx.translate(-x, -y)
+
         dx = x - w * hjust
         dy = y - h * (1.0 - vjust)
         dr = min(r, w / 2, h / 2)

grid_py/renderer_web.py

@@ -759,7 +759,13 @@ class WebRenderer(GridRenderer):
         self._node_stack = [self._scene_root]
         # Re-init base class viewport stack
         from ._vp_calc import calc_root_transform
-        root_vtr = calc_root_transform(self.width_in * 2.54, self.height_in * 2.54)
+        # Web renderer emits SVG → device units are CSS px = 1/96 inch.
+        # Use that so unit("native", ...) at root matches R's pixel-based
+        # convention for raster-like surfaces.
+        root_vtr = calc_root_transform(
+            self.width_in * 2.54, self.height_in * 2.54,
+            dev_units_per_inch=96.0,
+        )
         self._vp_transform_stack = [root_vtr]
         self._vp_obj_stack = [None]
         self._layout_stack = []

{rgrid_python-4.5.3.post4.dist-info → rgrid_python-4.5.3.post5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rgrid-python
-Version: 4.5.3.post4
+Version: 4.5.3.post5
 Summary: Python port of the R grid package (tracks R grid 4.5.3)
 Project-URL: Homepage, https://github.com/Bio-Babel/grid_py
 Project-URL: Repository, https://github.com/Bio-Babel/grid_py

{rgrid_python-4.5.3.post4.dist-info → rgrid_python-4.5.3.post5.dist-info}/RECORD

@@ -1,11 +1,11 @@
-grid_py/__init__.py,sha256=K_SAUQUXVz-7mYQEYPWR9_5aWLPJjUdhu1nVSunpk_I,10520
+grid_py/__init__.py,sha256=CE6FeESr4RXg2kI4HbTA_d7vxOBwkcjxyMQ8kpz1J8Q,10520
 grid_py/_arrow.py,sha256=pgn4OCgF6TZY2yXl7ML-kt08DbwqlvT1ulApDcmRz4k,10867
 grid_py/_clippath.py,sha256=p6fUAkcEc5Bg8chv-lIZwaOjEUbLK57duwjtIpDjAkw,4015
-grid_py/_colour.py,sha256=WqaxGop-SM1LYZG4uMPmMX3Zjh6Y_ip0HcanP5wEij8,22872
+grid_py/_colour.py,sha256=JOfUC5GPHIccVfmGwmK5DJEb-klPIbr9HzKra30K9UM,23353
 grid_py/_coords.py,sha256=9cDD3MWHmw9TnT1I8QKHQA96SCG06OxRXNqYGFZsfwg,47210
 grid_py/_curve.py,sha256=QnUkh9lWLd0OSm7h7QwS78JjzBAu9WHmRY4ZpZhccpY,54989
 grid_py/_display_list.py,sha256=uMFAupSJaCgUCbLMv2-RDBQ-YLxCkAldypRqc7CnF3w,13622
-grid_py/_draw.py,sha256=YR2JYfOspg3MRb-vR47ebhBJq3pKJZ7QMarkcVNHkNA,51150
+grid_py/_draw.py,sha256=2vYdD9DqOUPtMtLazCN-n4jLlE3hZYDbTUNLRMfzUkY,55218
 grid_py/_edit.py,sha256=vQDZGBTTYy6DmlW33l94s1KJLrzPNym21NR4Od4qIFw,22263
 grid_py/_font_metrics.py,sha256=XC_dgIN3eB72VPXIRFU-tynnS3wJl3bPugGHrwVzyeo,11086
 grid_py/_gpar.py,sha256=Bsq5oevTOf-ISb6T1K4cqPcA7UKX0XHbg-AddMomWzQ,21302
@@ -20,24 +20,24 @@ grid_py/_lty.py,sha256=ciQKy_P_QmJbmYTsSeQY8cGxXvnrowJbBS-Zzf4birE,7762
 grid_py/_mask.py,sha256=d2Wm2z-RJnfEKHdAHcjteL7VubimcaK1_f9Us9MfrUk,4902
 grid_py/_path.py,sha256=Tr5bNNcGwPpOsxWKqEp65MRri-KV8IqplUh2Z90sxnk,11421
 grid_py/_patterns.py,sha256=t6IkayYPaupEbF9bFZQmS0iXZhB9TWrvN2xRZzR7baA,33302
-grid_py/_primitives.py,sha256=Aq0fCdsy-eJ57v_X9JeFlsmm62jEZMlEOuK3u3v6YEg,59522
-grid_py/_renderer_base.py,sha256=wECYIgNR2UNXXneWoaJspbBkclBTxTbM3in5Hva7nNY,59011
+grid_py/_primitives.py,sha256=YptgRYJxTbXgycUH21Ek_ZD3sK9x_Ys46KRdDPNpoBc,62302
+grid_py/_renderer_base.py,sha256=SU-Hl0pxmnzm9DasodDiTA0pQQkkWUlq3Z3mtiWU4TQ,64497
 grid_py/_scene_graph.py,sha256=mKhNEMkUolbWt4_CFgGhrGUudrYenxFNXaBp6GLN9_Y,7412
 grid_py/_size.py,sha256=q9yYdhO7dcp-RtQzJIIsXssFH5oFbsm5_P6UxZlFKjg,43312
-grid_py/_state.py,sha256=SsEzcicTmxWaGExDeLLNNVXT-G38aUFtgSuZTJEYBbw,22800
+grid_py/_state.py,sha256=3JWGYOAUjmuqsYGG93v7vcX4ZM3k1uXOepxlAkb690w,25978
 grid_py/_transforms.py,sha256=mQvs_Qm6icti66peLXTsjgmSmvIUCCphf_-D-tiE1O4,11675
 grid_py/_typeset.py,sha256=J_PJ5YcOAOnnFkBfo8IW86utJdkdsrnGZi3MvnHc8io,11516
 grid_py/_units.py,sha256=bGrHV23Vr2A6lO15LJvcP7Qs1Yx_uQJLmyQ6bRB3yjc,61893
 grid_py/_utils.py,sha256=QaWNkCF3BbPHyrqPPRxN7Ji2vB5ethNwVT3SJ1ad9Lc,8335
 grid_py/_viewport.py,sha256=qscv8eRKt0vHH0osxZUkbwM9PfgZwTKXi8n7L8921DE,49490
-grid_py/_vp_calc.py,sha256=v0MJc-YmWohO5t7LHFopk5ogH-Sink_A_zNFV_1769w,32935
+grid_py/_vp_calc.py,sha256=zW_nmO5KKdy2oW2H6tk34G4JAnEtmBsBkZr0fESIIUg,34805
 grid_py/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-grid_py/renderer.py,sha256=DlzC7srfqZ0JRpEUddjwX39Kw4PUg9-FDH57-sI1RcQ,65093
-grid_py/renderer_web.py,sha256=ntbLwcvTJNz_S0xRNGweiZmrkThUfW1AvCCCDSn2vSY,29461
+grid_py/renderer.py,sha256=-A4SsBtJW4hds2caG_t_ewnsVmx_WdKoUs0cRTvCUJQ,75269
+grid_py/renderer_web.py,sha256=hgABfks1K6oWyNDN5wPpxKP4HpPsYCXxagG_oO1QWpY,29716
 grid_py/resources/d3.v7.min.js,sha256=8glLv2FBs1lyLE_kVOtsSw8OQswQzHr5IfwVj864ZTk,279706
 grid_py/resources/gridpy.css,sha256=tR5LF2rLvi_bGRWuH9CnmLQk-aG2f-jlZjQZqS7_4uY,1351
 grid_py/resources/gridpy.js,sha256=ekbmsIMCJU9ZqIU0WC1c-Y-LBEinGIL8UftFEVF9pC4,28555
-rgrid_python-4.5.3.post4.dist-info/METADATA,sha256=3sNILdeJwNGhe9zFPrssIt90C_csOUrrrd7Ad6Uw3IY,19910
-rgrid_python-4.5.3.post4.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-rgrid_python-4.5.3.post4.dist-info/licenses/LICENSE,sha256=8zNQKZlkc4JOaW7br_a8aALg4baZwZkLKLTQx3kuHkc,48
-rgrid_python-4.5.3.post4.dist-info/RECORD,,
+rgrid_python-4.5.3.post5.dist-info/METADATA,sha256=sNw4AKkaHb203t8SaZJvY_qcRcD1WCvF5fciDQJbhhw,19910
+rgrid_python-4.5.3.post5.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+rgrid_python-4.5.3.post5.dist-info/licenses/LICENSE,sha256=8zNQKZlkc4JOaW7br_a8aALg4baZwZkLKLTQx3kuHkc,48
+rgrid_python-4.5.3.post5.dist-info/RECORD,,

{rgrid_python-4.5.3.post4.dist-info → rgrid_python-4.5.3.post5.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.29.0
+Generator: hatchling 1.30.1
 Root-Is-Purelib: true
 Tag: py3-none-any