rgrid-python 4.5.3.post2__py3-none-any.whl → 4.5.3.post3__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.post2"
+__version__ = "4.5.3.post3"
 
 # --- Utilities ---
 from grid_py._utils import depth, explode, grid_pretty, n2mfrow

grid_py/_curve.py

@@ -1383,6 +1383,8 @@ def grid_curve(
 def xspline_grob(
     x: Optional[Any] = None,
     y: Optional[Any] = None,
+    id: Optional[Any] = None,
+    id_lengths: Optional[Any] = None,
     default_units: str = "npc",
     shape: Union[float, Sequence[float]] = 0.0,
     open_: bool = True,
@@ -1402,6 +1404,15 @@ def xspline_grob(
     x, y : Unit, numeric, sequence, or None
         Control-point coordinates.  Defaults to ``Unit([0, 1], "npc")``
         when ``None``.
+    id : array-like of int or None
+        Group label for each control point.  Points sharing an ``id`` are
+        rendered as one X-spline; the grob therefore renders one spline
+        per unique ``id`` value.  Mirrors R ``xsplineGrob(id=...)``.
+        Mutually meaningful with ``id_lengths``: pass at most one.
+    id_lengths : array-like of int or None
+        Run-length encoding of ``id``: the n-th entry is the number of
+        consecutive control points belonging to spline n.  Mirrors R's
+        ``xsplineGrob(id.lengths=...)``.
     default_units : str
         Unit type for bare numerics.
     shape : float or sequence of float
@@ -1439,9 +1450,16 @@ def xspline_grob(
     if np.any((shape_arr < -1) | (shape_arr > 1)):
         raise ValueError("all 'shape' values must be between -1 and 1")
 
+    id_arr = None if id is None else np.asarray(id, dtype=np.int64)
+    id_lengths_arr = (
+        None if id_lengths is None else np.asarray(id_lengths, dtype=np.int64)
+    )
+
     return Grob(
         x=x,
         y=y,
+        id=id_arr,
+        id_lengths=id_lengths_arr,
         shape=shape_arr,
         open_=bool(open_),
         arrow=arrow,
@@ -1456,6 +1474,8 @@ def xspline_grob(
 def grid_xspline(
     x: Optional[Any] = None,
     y: Optional[Any] = None,
+    id: Optional[Any] = None,
+    id_lengths: Optional[Any] = None,
     default_units: str = "npc",
     shape: Union[float, Sequence[float]] = 0.0,
     open_: bool = True,
@@ -1497,7 +1517,8 @@ def grid_xspline(
         The xspline grob.
     """
     grob = xspline_grob(
-        x=x, y=y, default_units=default_units,
+        x=x, y=y, id=id, id_lengths=id_lengths,
+        default_units=default_units,
         shape=shape, open_=open_, arrow=arrow,
         repEnds=repEnds, name=name, gp=gp, vp=vp,
     )

grid_py/_draw.py

@@ -412,7 +412,15 @@ def _render_grob(
             xs, ys = _calc_xspline_points(
                 x, y, shape=shape_arr, open_=open_, repEnds=rep_ends,
             )
-            renderer.draw_polyline(xs, ys, id_=None, gp=gp)
+            # R's ``xsplineGrob(open=FALSE)`` is a *filled closed* shape, not
+            # a stroked path; route through ``draw_polygon`` so ``gp$fill``
+            # actually paints (R/grid: drawDetails.xspline → C_xspline,
+            # filled when ``open == FALSE``).  ``open=TRUE`` stays a stroked
+            # polyline.
+            if open_:
+                renderer.draw_polyline(xs, ys, id_=None, gp=gp)
+            else:
+                renderer.draw_polygon(xs, ys, gp=gp)
             if arr is not None and len(xs) >= 2:
                 _draw_arrow_heads(xs, ys, arr, renderer, gp)
         else:
@@ -436,12 +444,24 @@ def _render_grob(
                 out_id += 1
                 per_group.append((xs_g, ys_g))
             if all_xs:
-                renderer.draw_polyline(
-                    np.asarray(all_xs, dtype=float),
-                    np.asarray(all_ys, dtype=float),
-                    id_=np.asarray(all_ids, dtype=int),
-                    gp=gp,
-                )
+                # Multi-id closed splines render as N separate filled
+                # subpolygons (R: xsplineGrob(id=..., open=FALSE)); use
+                # ``draw_path`` with the path_id array.  Open splines stay
+                # multi-stroke polylines.
+                if open_:
+                    renderer.draw_polyline(
+                        np.asarray(all_xs, dtype=float),
+                        np.asarray(all_ys, dtype=float),
+                        id_=np.asarray(all_ids, dtype=int),
+                        gp=gp,
+                    )
+                else:
+                    renderer.draw_path(
+                        np.asarray(all_xs, dtype=float),
+                        np.asarray(all_ys, dtype=float),
+                        path_id=np.asarray(all_ids, dtype=int),
+                        gp=gp,
+                    )
                 if arr is not None:
                     for xs_g, ys_g in per_group:
                         if len(xs_g) >= 2:
@@ -564,15 +584,18 @@ def _render_grob(
         if image is None:
             image = getattr(grob, "image", None)
         if image is not None:
-            # Apply justification (same as rect_grob)
             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_w = renderer.resolve_w(getattr(grob, "width", 1.0), gp=gp)
             raw_h = renderer.resolve_h(getattr(grob, "height", 1.0), gp=gp)
-            # Compute bottom-left corner from anchor + justification
+            # `renderer.draw_raster` expects the *top-left* corner in y-down
+            # device pixels. `resolve_y` already returns y-down coords, so the
+            # y component of justification must be flipped relative to R's
+            # `justifyY(y, h, vjust) = y - h*vjust` (which assumes y-up NPC).
+            # Same correction `draw_rect` applies (renderer.py:815).
             x0 = raw_x - raw_w * hj
-            y0 = raw_y - raw_h * vj
+            y0 = raw_y - raw_h * (1.0 - vj)
             renderer.draw_raster(
                 image=image,
                 x=x0,

grid_py/_renderer_base.py

@@ -425,8 +425,15 @@ class GridRenderer(ABC):
         from ._layout import _calc_layout_sizes, GridLayout
 
         if isinstance(layout, GridLayout):
+            # Use device-units-per-inch (= dpi for raster ImageSurface, 72 for
+            # vector PDF/SVG/PS surfaces) so that absolute units (cm/mm/in/pt
+            # …) get converted to the SAME unit as ``parent_w``/``parent_h``.
+            # Passing ``self.dpi`` blindly would, for vector surfaces, scale
+            # absolute widths by dpi while the parent is measured in points,
+            # over-allocating fixed cells by ``dpi/72`` and shrinking the
+            # null-unit panel by the same factor.
             col_widths, row_heights = _calc_layout_sizes(
-                layout, parent_w, parent_h, self.dpi,
+                layout, parent_w, parent_h, self._dev_units_per_inch,
             )
         else:
             nrow = getattr(layout, "nrow", 1)

grid_py/renderer.py

@@ -141,6 +141,17 @@ class CairoRenderer(GridRenderer):
             if filename is None:
                 raise ValueError("filename is required for SVG surface")
             self._surface = cairo.SVGSurface(filename, width_pt, height_pt)
+            # Cairo's SVGSurface measures user-space in points; emit explicit
+            # ``pt`` units in the resulting <svg width="...pt" height="...pt">
+            # so SVG renderers (browsers, cairosvg, Inkscape) interpret the
+            # canvas at the intended physical size instead of treating the
+            # raw numbers as user-units (= pixels by SVG default).
+            try:
+                self._surface.set_document_unit(cairo.SVG_UNIT_PT)
+            except (AttributeError, TypeError):
+                # Older pycairo / cairo without set_document_unit — file is
+                # still well-formed, just unit-less.
+                pass
         elif surface_type == "ps":
             if filename is None:
                 raise ValueError("filename is required for PS surface")
@@ -322,6 +333,34 @@ 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``.
+        """
+        if self._surface_type == "image":
+            lw_dev = lwd_pt * self.dpi / 72.0
+        else:
+            lw_dev = lwd_pt
+        try:
+            ux, uy = self._ctx.device_to_user_distance(lw_dev, lw_dev)
+            return max(abs(ux), abs(uy))
+        except Exception:
+            return lw_dev
+
     def _apply_stroke(self, gp: Optional[Gpar]) -> Tuple[float, float, float, float]:
         """Set stroke colour, line width, dash, caps, joins from Gpar.
 
@@ -331,7 +370,7 @@ class CairoRenderer(GridRenderer):
         ctx = self._ctx
         if gp is None:
             ctx.set_source_rgba(0, 0, 0, 1)
-            ctx.set_line_width(1.0)
+            ctx.set_line_width(self._lwd_to_user(1.0))
             return (0.0, 0.0, 0.0, 1.0)
 
         col = gp.get("col", None)
@@ -367,24 +406,7 @@ class CairoRenderer(GridRenderer):
         # R semantics: lwd=0 means invisible line
         if lw <= 0:
             return (0.0, 0.0, 0.0, 0.0)
-        # R grid semantics: ``lwd`` is always in **points** (1/72 inch)
-        # regardless of the current viewport's scale.  Cairo's
-        # ``set_line_width`` takes a user-space distance, which the
-        # viewport CTM has scaled down to NPC-like units — so a value
-        # of 0.5 user-space becomes sub-pixel after ``scale(w, h)``.
-        # Convert ``lw`` from points → device pixels using the
-        # renderer's DPI, then back to user-space via
-        # ``device_to_user_distance`` so the stroke width stays at
-        # 0.5pt on the output device no matter how deep the
-        # viewport stack is (matches R grid's device-unit lwd).
-        dpi = getattr(self, "dpi", None) or getattr(self, "_dpi", 72.0) or 72.0
-        lw_px = lw * dpi / 72.0
-        try:
-            ux, uy = ctx.device_to_user_distance(lw_px, lw_px)
-            lw_user = max(abs(ux), abs(uy))
-        except Exception:
-            lw_user = lw
-        ctx.set_line_width(lw_user)
+        ctx.set_line_width(self._lwd_to_user(lw))
 
         lty = gp.get("lty", None)
         if lty is not None:
@@ -1197,7 +1219,7 @@ class CairoRenderer(GridRenderer):
         """
         ctx.save()
         ctx.new_path()  # clear any residual path from prior draws
-        ctx.set_line_width(lwd)
+        ctx.set_line_width(self._lwd_to_user(lwd))
 
         if pch_val <= 14:
             # --- Group 0-14: stroke-only (use col for outline, no fill) ---

{rgrid_python-4.5.3.post2.dist-info → rgrid_python-4.5.3.post3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rgrid-python
-Version: 4.5.3.post2
+Version: 4.5.3.post3
 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.post2.dist-info → rgrid_python-4.5.3.post3.dist-info}/RECORD

@@ -1,11 +1,11 @@
-grid_py/__init__.py,sha256=UWOAMmQkCKI5H7Kx1yPSwFvI6pLQRci2jVDURr8d6H8,10520
+grid_py/__init__.py,sha256=tSRqBr3SxkmX3f3x0tT6G-kMFeApA6cjrhD1CGiKWNs,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/_coords.py,sha256=9cDD3MWHmw9TnT1I8QKHQA96SCG06OxRXNqYGFZsfwg,47210
-grid_py/_curve.py,sha256=MV7hl1MR-4FZfKBKEm4MCSvHgJLYP9UaWLp8eHXPhv0,54041
+grid_py/_curve.py,sha256=QnUkh9lWLd0OSm7h7QwS78JjzBAu9WHmRY4ZpZhccpY,54989
 grid_py/_display_list.py,sha256=uMFAupSJaCgUCbLMv2-RDBQ-YLxCkAldypRqc7CnF3w,13622
-grid_py/_draw.py,sha256=seDvNzkxz3PYcWLeI6MXQ80elWaY18HgfyKshr2cMl0,49662
+grid_py/_draw.py,sha256=WcbxIX9GPEZBf5L8KRZpYiFNWyHVttGBrroKO4m6LUY,50953
 grid_py/_edit.py,sha256=vQDZGBTTYy6DmlW33l94s1KJLrzPNym21NR4Od4qIFw,22263
 grid_py/_font_metrics.py,sha256=XC_dgIN3eB72VPXIRFU-tynnS3wJl3bPugGHrwVzyeo,11086
 grid_py/_gpar.py,sha256=AW3PNlD7UWOozzZvY5Y3f7ZGTWCTRnOs2YqOvlFD1_A,19757
@@ -20,7 +20,7 @@ grid_py/_mask.py,sha256=d2Wm2z-RJnfEKHdAHcjteL7VubimcaK1_f9Us9MfrUk,4902
 grid_py/_path.py,sha256=Tr5bNNcGwPpOsxWKqEp65MRri-KV8IqplUh2Z90sxnk,11421
 grid_py/_patterns.py,sha256=PBwV2b3oJkbueTLCku6cxeZ1PThREjiPcA6lmrwH3pE,32691
 grid_py/_primitives.py,sha256=dpX5_q5CS8p1vhuVzTa77MVbtaxigGBA5mmUzfFfHks,58861
-grid_py/_renderer_base.py,sha256=-wZYsKXaetQw1wPDsjUJoJffIDmjEVZN6P_lj5xOPT4,54239
+grid_py/_renderer_base.py,sha256=UD24cRzJlknMSSs2sl27XaDZ1e7XdIuhRDVhDxjiW-o,54770
 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
@@ -31,12 +31,12 @@ grid_py/_utils.py,sha256=QaWNkCF3BbPHyrqPPRxN7Ji2vB5ethNwVT3SJ1ad9Lc,8335
 grid_py/_viewport.py,sha256=AOrYmv05Y4QJbsTksn86RLStfHdbOHERc2YDHdZAekE,48477
 grid_py/_vp_calc.py,sha256=v0MJc-YmWohO5t7LHFopk5ogH-Sink_A_zNFV_1769w,32935
 grid_py/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-grid_py/renderer.py,sha256=hzCRgHMrR8tFpsdqT1al09gnZhgShoe_kIEO4MTYZNY,61620
+grid_py/renderer.py,sha256=6L6Rb-2AfjmvaeQYhWQKlU1L1HYHkKAma03v6YdZcTk,62658
 grid_py/renderer_web.py,sha256=pbOijES1eUUqkeAadXVyZPCBRIUIgzs3HIOgAElTYmo,27958
 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=l8KGgK-qZbJPVvrMAmLUu57RhpSAo_LMibs6rx3RnvA,28340
-rgrid_python-4.5.3.post2.dist-info/METADATA,sha256=uGrI2aBhk9PL1tjCk4izXQNr0niwxEGVhjbI4eOpmJM,19910
-rgrid_python-4.5.3.post2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-rgrid_python-4.5.3.post2.dist-info/licenses/LICENSE,sha256=8zNQKZlkc4JOaW7br_a8aALg4baZwZkLKLTQx3kuHkc,48
-rgrid_python-4.5.3.post2.dist-info/RECORD,,
+rgrid_python-4.5.3.post3.dist-info/METADATA,sha256=U2Lx9ccpNvIWTBozFmqItTD-AWHPY9Wq9zdeKQelK68,19910
+rgrid_python-4.5.3.post3.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+rgrid_python-4.5.3.post3.dist-info/licenses/LICENSE,sha256=8zNQKZlkc4JOaW7br_a8aALg4baZwZkLKLTQx3kuHkc,48
+rgrid_python-4.5.3.post3.dist-info/RECORD,,