"""
Mapping of the R library "grid" for graphics.
The R library provides a low-level coordinate
system and graphic primitives to built visualizations.
"""
import rpy2.robjects as robjects
import rpy2.robjects.conversion as conversion
from rpy2.rlike.container import OrdDict
from rpy2.robjects.packages import importr, WeakPackage
NULL = robjects.NULL
grid = importr('grid')
grid = WeakPackage(grid._env,
grid.__rname__,
translation=grid._translation,
exported_names=grid._exported_names,
on_conflict="warn",
version=grid.__version__,
symbol_r2python=grid._symbol_r2python,
symbol_resolve=grid._symbol_resolve)
grid_env = robjects.baseenv['as.environment']('package:grid')
layout = grid.grid_layout
newpage = grid.grid_newpage
grill = grid.grid_grill
edit = grid.grid_edit
get = grid.grid_get
remove = grid.grid_remove
add = grid.grid_add
xaxis = grid.grid_xaxis
yaxis = grid.grid_yaxis
class Unit(robjects.RObject):
""" Vector of unit values (as in R's grid package) """
_unit = grid_env['unit']
@classmethod
def unit(cls, *args, **kwargs):
""" Constructor (uses the R function grid::unit())"""
res = cls._unit(*args, **kwargs)
return res
unit = Unit.unit
class Gpar(robjects.RObject):
""" Graphical parameters """
_gpar = grid_env['gpar']
_get_gpar = grid_env['get.gpar']
@classmethod
def gpar(cls, *args, **kwargs):
""" Constructor (uses the R function grid::gpar())"""
res = cls._gpar(*args, **kwargs)
return res
def get(self, names=None):
return self._get_gpar(names)
gpar = Gpar.gpar
class Grob(robjects.RObject):
""" Graphical object """
_grob = grid_env['grob']
_draw = grid_env['grid.draw']
def __init__(self, *args, **kwargs):
od = OrdDict()
for item in args:
od[None] = conversion.py2rpy(item)
for k, v in kwargs.items():
od[k] = conversion.py2rpy(v)
res = self._constructor.rcall(tuple(od.items()), robjects.globalenv)
super().__init__(res.__sexp__)
@classmethod
def grob(cls, **kwargs):
""" Constructor (uses the R function grid::grob())"""
res = cls._grob(**kwargs)
return res
def draw(self, recording=True):
""" Draw a graphical object (calling the R function
grid::grid.raw())"""
self._draw(self, recording=recording)
grob = Grob.grob
class Rect(Grob):
_constructor = grid_env['rectGrob']
rect = Rect
class Lines(Grob):
_constructor = grid_env['linesGrob']
lines = Lines
class Circle(Grob):
_constructor = grid_env['circleGrob']
circle = Circle
class Points(Grob):
_constructor = grid_env['pointsGrob']
points = Points
class Text(Grob):
_constructor = grid_env['textGrob']
text = Text
class GTree(Grob):
""" gTree """
_gtree = grid_env['gTree']
_grobtree = grid_env['grobTree']
@classmethod
def gtree(cls, **kwargs):
""" Constructor (uses the R function grid::gTree())"""
res = cls._gtree(**kwargs)
return res
@classmethod
def grobtree(cls, **kwargs):
""" Constructor (uses the R function grid::grobTree())"""
res = cls._grobtree(**kwargs)
return res
class Axis(GTree):
pass
class XAxis(Axis):
_xaxis = xaxis
_xaxisgrob = grid.xaxisGrob
@classmethod
def xaxis(cls, **kwargs):
""" Constructor (uses the R function grid::xaxis())"""
res = cls._xaxis(**kwargs)
return res
@classmethod
def xaxisgrob(cls, **kwargs):
""" Constructor (uses the R function grid::xaxisgrob())"""
res = cls._xaxisgrob(**kwargs)
return res
class YAxis(Axis):
_yaxis = yaxis
_yaxisgrob = grid.yaxisGrob
@classmethod
def yaxis(cls, **kwargs):
""" Constructor (uses the R function grid::yaxis())"""
res = cls._yaxis(**kwargs)
return res
@classmethod
def yaxisgrob(cls, **kwargs):
""" Constructor (uses the R function grid::yaxisgrob())"""
res = cls._yaxisgrob(**kwargs)
return res
class Viewport(robjects.RObject):
""" Drawing context.
Viewports can be thought of as nodes in a scene graph. """
_pushviewport = grid_env['pushViewport']
_popviewport = grid_env['popViewport']
_current = grid_env['current.viewport']
_plotviewport = grid_env['plotViewport']
_downviewport = grid_env['downViewport']
_seek = grid_env['seekViewport']
_upviewport = grid_env['upViewport']
_viewport = grid_env['viewport']
def push(self, recording=True):
self._pushviewport(self, recording=recording)
@classmethod
def pop(cls, n):
""" Pop n viewports from the stack. """
cls._popviewport(n)
@classmethod
def current(cls):
""" Return the current viewport in the stack. """
cls._current()
@classmethod
def default(cls, **kwargs):
cls._plotviewport(**kwargs)
@classmethod
def down(cls, name, strict=False, recording=True):
""" Return the number of Viewports it went down """
cls._downviewport(name, strict=strict, recording=recording)
@classmethod
def seek(cls, name, recording=True):
""" Seek and return a Viewport given its name """
cls._seek(name, recording=recording)
@classmethod
def up(cls, n, recording=True):
""" Go up n viewports """
cls._downviewport(n, recording=recording)
@classmethod
def viewport(cls, **kwargs):
""" Constructor: create a Viewport """
res = cls._viewport(**kwargs)
res = cls(res)
return res
viewport = Viewport.viewport
_grid_dict = {
'gpar': Gpar,
'grob': Grob,
'gTree': GTree,
'unit': Unit,
'xaxis': XAxis,
'yaxis': YAxis,
'viewport': Viewport
}
original_py2rpy = None
original_rpy2py = None
def grid_rpy2py(robj):
pyobj = original_rpy2py(robj)
if not isinstance(pyobj, robjects.RS4):
rcls = pyobj.rclass
if rcls is NULL:
rcls = (None, )
try:
cls = _grid_dict[rcls[0]]
pyobj = cls(pyobj)
except KeyError:
pass
return pyobj
def activate():
global original_py2rpy, original_rpy2py
# If module is already activated, there is nothing to do
if original_py2rpy:
return
original_py2rpy = conversion.py2rpy
original_rpy2py = conversion.rpy2py
conversion.rpy2py = grid_rpy2py
def deactivate():
global original_py2rpy, original_rpy2py
# If module has never been activated or already deactivated,
# there is nothing to do
if not original_py2rpy:
return
conversion.py2rpy = original_py2rpy
conversion.rpy2py = original_rpy2py
original_py2rpy = original_rpy2py = None
