rgrid-python 4.5.3.post4__tar.gz → 4.5.3.post5__tar.gz

{rgrid_python-4.5.3.post4 → rgrid_python-4.5.3.post5}/PKG-INFO

@@ -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 → rgrid_python-4.5.3.post5}/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

{rgrid_python-4.5.3.post4 → rgrid_python-4.5.3.post5}/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

{rgrid_python-4.5.3.post4 → rgrid_python-4.5.3.post5}/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

{rgrid_python-4.5.3.post4 → rgrid_python-4.5.3.post5}/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",

{rgrid_python-4.5.3.post4 → rgrid_python-4.5.3.post5}/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)