def __init__(self, figure, fh, dummy=False): """ Creates a new PGF renderer that translates any drawing instruction into text commands to be interpreted in a latex pgfpicture environment. Attributes ---------- figure : `matplotlib.figure.Figure` Matplotlib figure to initialize height, width and dpi from. fh : file-like File handle for the output of the drawing commands. """ RendererBase.__init__(self) self.dpi = figure.dpi self.fh = fh self.figure = figure self.image_counter = 0 # get LatexManager instance self.latexManager = LatexManager._get_cached_or_new() if dummy: # dummy==True deactivate all methods for m in RendererPgf.__dict__: if m.startswith("draw_"): self.__dict__[m] = lambda *args, **kwargs: None else: # if fh does not belong to a filename, deactivate draw_image if not hasattr(fh, 'name') or not os.path.exists(fh.name): cbook._warn_external("streamed pgf-code does not support " "raster graphics, consider using the " "pgf-to-pdf option", UserWarning) self.__dict__["draw_image"] = lambda *args, **kwargs: None
def __init__(self, dpi, width, height): RendererBase.__init__(self) self.dpi = dpi self.width = width self.height = height self.gc = GraphicsContextMac() self.mathtext_parser = MathTextParser('MacOSX')
def __init__(self, width, height, svgwriter, basename=None): self.width = width self.height = height self.writer = XMLWriter(svgwriter) self._groupd = {} if not rcParams['svg.image_inline']: assert basename is not None self.basename = basename self._imaged = {} self._clipd = {} self._char_defs = {} self._markers = {} self._path_collection_id = 0 self._imaged = {} self._hatchd = {} self._has_gouraud = False self._n_gradients = 0 self._fonts = {} self.mathtext_parser = MathTextParser('SVG') RendererBase.__init__(self) self._glyph_map = dict() svgwriter.write(svgProlog) self._start_id = self.writer.start( u'svg', width=u'%ipt' % width, height='%ipt' % height, viewBox=u'0 0 %i %i' % (width, height), xmlns=u"http://www.w3.org/2000/svg", version=u"1.1", attrib={u'xmlns:xlink': u"http://www.w3.org/1999/xlink"}) self._write_default_style()
def __init__(self, width, height, pswriter, dpi=72): RendererBase.__init__(self) self.width = width self.height = height self._pswriter = pswriter if rcParams['text.usetex']: self.textcnt = 0 self.psfrag = [] self.dpi = dpi # current renderer state (None=uninitialised) self.color = None self.linewidth = None self.linejoin = None self.linecap = None self.linedash = None self.fontname = None self.fontsize = None self.hatch = None self.image_magnification = dpi / 72.0 self._clip_paths = {} self._path_collection_id = 0 self.used_characters = {} self.mathtext_parser = MathTextParser("PS")
def _for_fmt_output(cls, fmt, stream, width, height, dpi): if stream is not None and cbook.file_requires_unicode(stream): if fmt in [_StreamSurfaceType.PS, _StreamSurfaceType.EPS]: # PS is (typically) ASCII -- Language Reference, section 3.2. stream = _BytesWritingWrapper(stream, "ascii") elif fmt is _StreamSurfaceType.SVG: # cairo outputs SVG with encoding="UTF-8". stream = _BytesWritingWrapper(stream, "utf-8") # (No default encoding for pdf, which is a binary format.) args = fmt, stream, width, height, dpi cairo_debug_pdf = os.environ.get("CAIRO_DEBUG_PDF") if mpl.rcParams["pdf.compression"]: os.environ.setdefault("CAIRO_DEBUG_PDF", "1") try: obj = _mplcairo.GraphicsContextRendererCairo.__new__(cls, *args) _mplcairo.GraphicsContextRendererCairo.__init__(obj, *args) finally: if cairo_debug_pdf is None: os.environ.pop("CAIRO_DEBUG_PDF", None) else: os.environ["CAIRO_DEBUG_PDF"] = cairo_debug_pdf try: name = os.fsdecode(stream.name) except (AttributeError, TypeError): pass # In particular, stream.name is an int for TemporaryFile. else: obj._set_path(name) RendererBase.__init__(obj) return obj
def __init__(self, width, height, svgwriter, basename=None, image_dpi=72): self.width = width self.height = height self.writer = XMLWriter(svgwriter) self.image_dpi = image_dpi # actual dpi at which we rasterize stuff self._groupd = {} if not rcParams['svg.image_inline']: assert basename is not None self.basename = basename self._imaged = {} self._clipd = OrderedDict() self._markers = {} self._path_collection_id = 0 self._imaged = {} self._hatchd = OrderedDict() self._has_gouraud = False self._n_gradients = 0 self._fonts = OrderedDict() self.mathtext_parser = MathTextParser('SVG') RendererBase.__init__(self) self._glyph_map = dict() str_height = short_float_fmt(height) str_width = short_float_fmt(width) svgwriter.write(svgProlog) self._start_id = self.writer.start( 'svg', width='%spt' % str_width, height='%spt' % str_height, viewBox='0 0 %s %s' % (str_width, str_height), xmlns="http://www.w3.org/2000/svg", version="1.1", attrib={'xmlns:xlink': "http://www.w3.org/1999/xlink"}) self._write_default_style()
def from_pycairo_ctx(cls, ctx, width, height, dpi, orig_scale): obj = _mplcairo.GraphicsContextRendererCairo.__new__( cls, ctx, width, height, dpi, orig_scale) _mplcairo.GraphicsContextRendererCairo.__init__( obj, ctx, width, height, dpi, orig_scale) RendererBase.__init__(obj) return obj
def __init__(self, figure, fh, dummy=False): """ Create a new PGF renderer that translates any drawing instruction into text commands to be interpreted in a latex pgfpicture environment. Attributes ---------- figure : `matplotlib.figure.Figure` Matplotlib figure to initialize height, width and dpi from. fh : file-like File handle for the output of the drawing commands. """ RendererBase.__init__(self) self.dpi = figure.dpi self.fh = fh self.figure = figure self.image_counter = 0 self._latexManager = LatexManager._get_cached_or_new() # deprecated if dummy: # dummy==True deactivate all methods for m in RendererPgf.__dict__: if m.startswith("draw_"): self.__dict__[m] = lambda *args, **kwargs: None
def __init__(self, width, height, svgwriter, basename=None, image_dpi=72): self.width = width self.height = height self.writer = XMLWriter(svgwriter) self.image_dpi = image_dpi # the actual dpi we want to rasterize stuff with self._groupd = {} if not rcParams['svg.image_inline']: assert basename is not None self.basename = basename self._imaged = {} self._clipd = OrderedDict() self._char_defs = {} self._markers = {} self._path_collection_id = 0 self._imaged = {} self._hatchd = OrderedDict() self._has_gouraud = False self._n_gradients = 0 self._fonts = OrderedDict() self.mathtext_parser = MathTextParser('SVG') RendererBase.__init__(self) self._glyph_map = dict() svgwriter.write(svgProlog) self._start_id = self.writer.start( 'svg', width='%ipt' % width, height='%ipt' % height, viewBox='0 0 %i %i' % (width, height), xmlns="http://www.w3.org/2000/svg", version="1.1", attrib={'xmlns:xlink': "http://www.w3.org/1999/xlink"}) self._write_default_style()
def __init__(self, figure, fh, dummy=False): """ Creates a new PGF renderer that translates any drawing instruction into text commands to be interpreted in a latex pgfpicture environment. Attributes: * figure: Matplotlib figure to initialize height, width and dpi from. * fh: File handle for the output of the drawing commands. """ RendererBase.__init__(self) self.dpi = figure.dpi self.fh = fh self.figure = figure self.image_counter = 0 # get LatexManager instance self.latexManager = LatexManagerFactory.get_latex_manager() if dummy: # dummy==True deactivate all methods nop = lambda *args, **kwargs: None for m in RendererPgf.__dict__.keys(): if m.startswith("draw_"): self.__dict__[m] = nop else: # if fh does not belong to a filename, deactivate draw_image if not hasattr(fh, 'name') or not os.path.exists(fh.name): warnings.warn("streamed pgf-code does not support raster " "graphics, consider using the pgf-to-pdf option", UserWarning) self.__dict__["draw_image"] = lambda *args, **kwargs: None
def __init__(self, width, height, svgwriter, basename=None): self.width = width self.height = height self.writer = XMLWriter(svgwriter) self._groupd = {} if not rcParams["svg.image_inline"]: assert basename is not None self.basename = basename self._imaged = {} self._clipd = {} self._char_defs = {} self._markers = {} self._path_collection_id = 0 self._imaged = {} self._hatchd = {} self._has_gouraud = False self._n_gradients = 0 self._fonts = {} self.mathtext_parser = MathTextParser("SVG") RendererBase.__init__(self) self._glyph_map = dict() svgwriter.write(svgProlog) self._start_id = self.writer.start( u"svg", width=u"%ipt" % width, height="%ipt" % height, viewBox=u"0 0 %i %i" % (width, height), xmlns=u"http://www.w3.org/2000/svg", version=u"1.1", attrib={u"xmlns:xlink": u"http://www.w3.org/1999/xlink"}, ) self._write_default_style()
def __init__(self, width, height, ipewriter, basename): self.width = width self.height = height self.writer = XMLWriter(ipewriter) self.basename = basename RendererBase.__init__(self) # use same latex as Ipe (default is xelatex) rcParams['pgf.texsystem'] = "pdflatex" self.latexManager = None if rcParams.get("ipe.textsize", False): self.latexManager = LatexManagerFactory.get_latex_manager() self._start_id = self.writer.start( u'ipe', version=u"70005", creator="matplotlib") pre = rcParams.get('ipe.preamble', "") if pre != "": self.writer.start(u'preamble') self.writer.data(pre) self.writer.end(indent=False) sheet = rcParams.get('ipe.stylesheet', "") if sheet != "": self.writer.insertSheet(sheet) self.writer.start(u'ipestyle', name=u"opacity") for i in range(10,100,10): self.writer.element(u'opacity', name=u'%02d%%'% i, value=u'%g'% (i/100.0)) self.writer.end() self.writer.start(u'page')
def __init__(self, figure, fh, dummy=False): """ Creates a new PGF renderer that translates any drawing instruction into text commands to be interpreted in a latex pgfpicture environment. Attributes ---------- figure : `matplotlib.figure.Figure` Matplotlib figure to initialize height, width and dpi from. fh : file-like File handle for the output of the drawing commands. """ RendererBase.__init__(self) self.dpi = figure.dpi self.fh = fh self.figure = figure self.image_counter = 0 # get LatexManager instance self.latexManager = LatexManager._get_cached_or_new() if dummy: # dummy==True deactivate all methods for m in RendererPgf.__dict__: if m.startswith("draw_"): self.__dict__[m] = lambda *args, **kwargs: None else: # if fh does not belong to a filename, deactivate draw_image if not hasattr(fh, 'name') or not os.path.exists(fh.name): cbook._warn_external( "streamed pgf-code does not support " "raster graphics, consider using the " "pgf-to-pdf option", UserWarning) self.__dict__["draw_image"] = lambda *args, **kwargs: None
def __init__(self, width, height, pswriter, imagedpi=72): """ Although postscript itself is dpi independent, we need to imform the image code about a requested dpi to generate high res images and them scale them before embeddin them """ RendererBase.__init__(self) self.width = width self.height = height self._pswriter = pswriter if rcParams['text.usetex']: self.textcnt = 0 self.psfrag = [] self.imagedpi = imagedpi if rcParams['path.simplify']: self.simplify = (width * imagedpi, height * imagedpi) else: self.simplify = None # current renderer state (None=uninitialised) self.color = None self.linewidth = None self.linejoin = None self.linecap = None self.linedash = None self.fontname = None self.fontsize = None self._hatches = {} self.image_magnification = imagedpi/72.0 self._clip_paths = {} self._path_collection_id = 0 self.used_characters = {} self.mathtext_parser = MathTextParser("PS")
def __init__(self, width, height, ipewriter, basename): self.width = width self.height = height self.writer = XMLWriter(ipewriter) self.basename = basename RendererBase.__init__(self) # use same latex as Ipe (default is xelatex) rcParams['pgf.texsystem'] = "pdflatex" self.latexManager = None if rcParams.get("ipe.textsize", False): self.latexManager = LatexManagerFactory.get_latex_manager() self._start_id = self.writer.start(u'ipe', version=u"70005", creator="matplotlib") pre = rcParams.get('ipe.preamble', "") if pre <> "": self.writer.start(u'preamble') self.writer.data(pre) self.writer.end(indent=False) sheet = rcParams.get('ipe.stylesheet', "") if sheet <> "": self.writer.insertSheet(sheet) self.writer.start(u'ipestyle', name=u"opacity") for i in range(10, 100, 10): self.writer.element(u'opacity', name=u'%02d%%' % i, value=u'%g' % (i / 100.0)) self.writer.end() self.writer.start(u'page')
def __init__(self, dpi): self.dpi = dpi self.gc = GraphicsContextCairo(renderer=self) self.text_ctx = cairo.Context( cairo.ImageSurface(cairo.FORMAT_ARGB32, 1, 1)) self.mathtext_parser = MathTextParser('Cairo') RendererBase.__init__(self)
def __init__(self, width, height, dpi): if __debug__: verbose.report('RendererAgg.__init__', 'debug-annoying') RendererBase.__init__(self) self.dpi = dpi self.width = width self.height = height if __debug__: verbose.report('RendererAgg.__init__ width=%s, \ height=%s'%(width, height), 'debug-annoying') self._renderer = _RendererAgg(int(width), int(height), dpi.get(), debug=False) if __debug__: verbose.report('RendererAgg.__init__ _RendererAgg done', 'debug-annoying') self.draw_polygon = self._renderer.draw_polygon self.draw_rectangle = self._renderer.draw_rectangle self.draw_path = self._renderer.draw_path self.draw_lines = self._renderer.draw_lines self.draw_markers = self._renderer.draw_markers self.draw_image = self._renderer.draw_image self.draw_line_collection = self._renderer.draw_line_collection self.draw_quad_mesh = self._renderer.draw_quad_mesh self.draw_poly_collection = self._renderer.draw_poly_collection self.draw_regpoly_collection = self._renderer.draw_regpoly_collection self.copy_from_bbox = self._renderer.copy_from_bbox self.restore_region = self._renderer.restore_region self.mathtext_parser = MathTextParser('Agg') self.bbox = lbwh_to_bbox(0,0, self.width, self.height) if __debug__: verbose.report('RendererAgg.__init__ done', 'debug-annoying')
def __init__(self, width, height, dpi): if __debug__: verbose.report("RendererAgg.__init__", "debug-annoying") RendererBase.__init__(self) self.dpi = dpi self.width = width self.height = height if __debug__: verbose.report( "RendererAgg.__init__ width=%s, \ height=%s" % (width, height), "debug-annoying", ) self._renderer = _RendererAgg(int(width), int(height), dpi.get(), debug=False) if __debug__: verbose.report("RendererAgg.__init__ _RendererAgg done", "debug-annoying") self.draw_polygon = self._renderer.draw_polygon self.draw_rectangle = self._renderer.draw_rectangle self.draw_path = self._renderer.draw_path self.draw_lines = self._renderer.draw_lines self.draw_markers = self._renderer.draw_markers self.draw_image = self._renderer.draw_image self.draw_line_collection = self._renderer.draw_line_collection self.draw_quad_mesh = self._renderer.draw_quad_mesh self.draw_poly_collection = self._renderer.draw_poly_collection self.draw_regpoly_collection = self._renderer.draw_regpoly_collection self.copy_from_bbox = self._renderer.copy_from_bbox self.restore_region = self._renderer.restore_region self.mathtext_parser = MathTextParser("Agg") self.bbox = lbwh_to_bbox(0, 0, self.width, self.height) if __debug__: verbose.report("RendererAgg.__init__ done", "debug-annoying")
def __init__(self, width, height, dpi): if __debug__: verbose.report('RendererAgg.__init__', 'debug-annoying') RendererBase.__init__(self) self.texd = maxdict(50) # a cache of tex image rasters self._fontd = maxdict(50) self.dpi = dpi self.width = width self.height = height if __debug__: verbose.report('RendererAgg.__init__ width=%s, height=%s'%(width, height), 'debug-annoying') self._renderer = _RendererAgg(int(width), int(height), dpi, debug=False) if __debug__: verbose.report('RendererAgg.__init__ _RendererAgg done', 'debug-annoying') #self.draw_path = self._renderer.draw_path # see below self.draw_markers = self._renderer.draw_markers self.draw_path_collection = self._renderer.draw_path_collection self.draw_quad_mesh = self._renderer.draw_quad_mesh self.draw_image = self._renderer.draw_image self.copy_from_bbox = self._renderer.copy_from_bbox self.tostring_rgba_minimized = self._renderer.tostring_rgba_minimized self.mathtext_parser = MathTextParser('Agg') self.bbox = Bbox.from_bounds(0, 0, self.width, self.height) if __debug__: verbose.report('RendererAgg.__init__ done', 'debug-annoying')
def __init__(self, width, height, dpi, dxfversion): RendererBase.__init__(self) self.height = height self.width = width self.dpi = dpi self.dxfversion = dxfversion self._init_drawing()
def __init__(self, dpi): self.dpi = dpi self.gc = GraphicsContextCairo(renderer=self) self.text_ctx = cairo.Context( cairo.ImageSurface(cairo.FORMAT_ARGB32, 1, 1)) self.mathtext_parser = MathTextParser('Cairo') RendererBase.__init__(self)
def __init__(self, width, height, pswriter, dpi=72): RendererBase.__init__(self) self.width = width self.height = height self._pswriter = pswriter if rcParams['text.usetex']: self.textcnt = 0 self.psfrag = [] self.dpi = dpi # current renderer state (None=uninitialised) self.color = None self.linewidth = None self.linejoin = None self.linecap = None self.linedash = None self.fontname = None self.fontsize = None self.hatch = None self.image_magnification = dpi/72.0 self._clip_paths = {} self._path_collection_id = 0 self.used_characters = {} self.mathtext_parser = MathTextParser("PS")
def __init__(self, width, height, dpi): if __debug__: verbose.report('RendererAgg.__init__', 'debug-annoying') RendererBase.__init__(self) self.dpi = dpi self.width = width self.height = height if __debug__: verbose.report( 'RendererAgg.__init__ width=%s, height=%s' % (width, height), 'debug-annoying') self._renderer = _RendererAgg(int(width), int(height), dpi, debug=False) self._filter_renderers = [] if __debug__: verbose.report('RendererAgg.__init__ _RendererAgg done', 'debug-annoying') self._update_methods() self.mathtext_parser = MathTextParser('Agg') self.bbox = Bbox.from_bounds(0, 0, self.width, self.height) if __debug__: verbose.report('RendererAgg.__init__ done', 'debug-annoying')
def __init__(self, width, height, dpi): if __debug__: verbose.report('RendererAgg.__init__', 'debug-annoying') RendererBase.__init__(self) self.dpi = dpi self.width = width self.height = height if __debug__: verbose.report( 'RendererAgg.__init__ width=%s, height=%s' % (width, height), 'debug-annoying') self._renderer = _RendererAgg(int(width), int(height), dpi, debug=False) if __debug__: verbose.report('RendererAgg.__init__ _RendererAgg done', 'debug-annoying') self.draw_path = self._renderer.draw_path self.draw_markers = self._renderer.draw_markers self.draw_path_collection = self._renderer.draw_path_collection self.draw_quad_mesh = self._renderer.draw_quad_mesh self.draw_image = self._renderer.draw_image self.copy_from_bbox = self._renderer.copy_from_bbox self.restore_region = self._renderer.restore_region self.tostring_rgba_minimized = self._renderer.tostring_rgba_minimized self.mathtext_parser = MathTextParser('Agg') self.bbox = Bbox.from_bounds(0, 0, self.width, self.height) if __debug__: verbose.report('RendererAgg.__init__ done', 'debug-annoying')
def __init__(self, dpi, width, height): RendererBase.__init__(self) self.dpi = dpi self.width = width self.height = height self.gc = GraphicsContextMac() self.mathtext_parser = MathTextParser('MacOSX')
def __init__(self, width, height, pswriter, imagedpi=72): """ Although postscript itself is dpi independent, we need to imform the image code about a requested dpi to generate high res images and them scale them before embeddin them """ RendererBase.__init__(self) self.width = width self.height = height self._pswriter = pswriter if rcParams['text.usetex']: self.textcnt = 0 self.psfrag = [] self.imagedpi = imagedpi if rcParams['path.simplify']: self.simplify = (width * imagedpi, height * imagedpi) else: self.simplify = None # current renderer state (None=uninitialised) self.color = None self.linewidth = None self.linejoin = None self.linecap = None self.linedash = None self.fontname = None self.fontsize = None self._hatches = {} self.image_magnification = imagedpi / 72.0 self._clip_paths = {} self._path_collection_id = 0 self.used_characters = {} self.mathtext_parser = MathTextParser("PS")
def __init__(self, dpi, width, height): RendererBase.__init__(self) self.dpi = dpi self.width = width self.height = height self.gc = GraphicsContextIos() self.gc.set_dpi(self.dpi) self.mathtext_parser = MathTextParser('ios')
def __init__(self, l, b, w, h, dpi, bbox, draw_point_callback, draw_sign_callback): RendererBase.__init__(self) self.l = l self.b = b self.w = w self.h = h self.dpi = dpi self.bbox = bbox self.dpc = draw_point_callback self.dsc = draw_sign_callback
def __init__(self, dpi): """ """ if _debug: print('%s.%s()' % (self.__class__.__name__, _fn_name())) self.dpi = dpi self.gc = GraphicsContextCairo(renderer=self) self.text_ctx = cairo.Context( cairo.ImageSurface(cairo.FORMAT_ARGB32, 1, 1)) self.mathtext_parser = MathTextParser('Cairo') RendererBase.__init__(self)
def __init__(self, dpi): """ """ if _debug: print('%s.%s()' % (self.__class__.__name__, _fn_name())) self.dpi = dpi self.gc = GraphicsContextCairo (renderer=self) self.text_ctx = cairo.Context ( cairo.ImageSurface (cairo.FORMAT_ARGB32,1,1)) self.mathtext_parser = MathTextParser('Cairo') RendererBase.__init__(self)
def _for_fmt_output(cls, fmt, stream, width, height, dpi): args = fmt, stream, width, height, dpi obj = _mplcairo.GraphicsContextRendererCairo.__new__(cls, *args) _mplcairo.GraphicsContextRendererCairo.__init__(obj, *args) try: name = os.fsdecode(stream.name) except (AttributeError, TypeError): pass # In particular, stream.name is an int for TemporaryFile. else: obj._set_path(name) RendererBase.__init__(obj) return obj
def __init__(self, width, height, dpi): RendererBase.__init__(self) self.dpi = dpi self.width = width self.height = height self._renderer = _RendererAgg(int(width), int(height), dpi) self._filter_renderers = [] self._update_methods() self.mathtext_parser = MathTextParser('Agg') self.bbox = Bbox.from_bounds(0, 0, self.width, self.height)
def __init__(self, width, height, dpi): RendererBase.__init__(self) self.dpi = dpi self.width = width self.height = height self._renderer = _RendererAgg(int(width), int(height), dpi) self._filter_renderers = [] self._update_methods() self.mathtext_parser = MathTextParser('Agg') self.bbox = Bbox.from_bounds(0, 0, self.width, self.height)
def __init__(self, figure, fh): """ Creates a new PGF renderer that translates any drawing instruction into text commands to be interpreted in a latex pgfpicture environment. Attributes: * figure: Matplotlib figure to initialize height, width and dpi from. * fh: File handle for the output of the drawing commands. """ RendererBase.__init__(self) self.dpi = figure.dpi self.fh = fh self.figure = figure self.image_counter = 0 # get LatexManager instance self.latexManager = LatexManagerFactory.get_latex_manager()
def __init__(self, figure, fh): """ Creates a new PGF renderer that translates any drawing instruction into text commands to be interpreted in a latex pgfpicture environment. Attributes: * figure: Matplotlib figure to initialize height, width and dpi from. * fh: File handle for the output of the drawing commands. """ RendererBase.__init__(self) self.dpi = figure.dpi self.fh = fh self.figure = figure self.image_counter = 0 # get LatexManager instance self.latexManager = LatexManagerFactory.get_latex_manager()
def __init__(self, width, height, dpi): if __debug__: verbose.report('RendererAgg.__init__', 'debug-annoying') RendererBase.__init__(self) self.texd = maxdict(50) # a cache of tex image rasters self._fontd = maxdict(50) self.dpi = dpi self.width = width self.height = height if __debug__: verbose.report('RendererAgg.__init__ width=%s, height=%s'%(width, height), 'debug-annoying') self._renderer = _RendererAgg(int(width), int(height), dpi, debug=False) self._filter_renderers = [] if __debug__: verbose.report('RendererAgg.__init__ _RendererAgg done', 'debug-annoying') self._update_methods() self.mathtext_parser = MathTextParser('Agg') self.bbox = Bbox.from_bounds(0, 0, self.width, self.height) if __debug__: verbose.report('RendererAgg.__init__ done', 'debug-annoying')
def _for_fmt_output(cls, fmt, stream, width, height, dpi): if cbook.file_requires_unicode(stream): if fmt in [_StreamSurfaceType.PS, _StreamSurfaceType.EPS]: # PS is (typically) ASCII -- Language Reference, section 3.2. stream = _BytesWritingWrapper(stream, "ascii") elif fmt is _StreamSurfaceType.SVG: # cairo outputs SVG with encoding="UTF-8". stream = _BytesWritingWrapper(stream, "utf-8") # (No default encoding for pdf, which is a binary format.) args = fmt, stream, width, height, dpi obj = _mplcairo.GraphicsContextRendererCairo.__new__(cls, *args) _mplcairo.GraphicsContextRendererCairo.__init__(obj, *args) try: name = os.fsdecode(stream.name) except (AttributeError, TypeError): pass # In particular, stream.name is an int for TemporaryFile. else: obj._set_path(name) RendererBase.__init__(obj) return obj
def __init__(self, width, height, svgwriter, basename=None): self.width=width self.height=height self._svgwriter = svgwriter self._groupd = {} if not rcParams['svg.image_inline']: assert basename is not None self.basename = basename self._imaged = {} self._clipd = {} self._char_defs = {} self._markers = {} self._path_collection_id = 0 self._imaged = {} self._hatchd = {} self._n_gradients = 0 self.mathtext_parser = MathTextParser('SVG') RendererBase.__init__(self) self._glyph_map = dict() svgwriter.write(svgProlog%(width,height,width,height))
def __init__(self, width, height, dpi): if __debug__: verbose.report('RendererAgg.__init__', 'debug-annoying') RendererBase.__init__(self) self.texd = maxdict(50) # a cache of tex image rasters self._fontd = maxdict(50) self.dpi = dpi self.width = width self.height = height if __debug__: verbose.report('RendererAgg.__init__ width=%s, height=%s'%(width, height), 'debug-annoying') self._renderer = _RendererAgg(int(width), int(height), dpi, debug=False) self._filter_renderers = [] if __debug__: verbose.report('RendererAgg.__init__ _RendererAgg done', 'debug-annoying') self._update_methods() self.bbox = Bbox.from_bounds(0, 0, self.width, self.height) if __debug__: verbose.report('RendererAgg.__init__ done', 'debug-annoying')
def __init__(self, width, height, dpi): if __debug__: verbose.report("RendererAgg.__init__", "debug-annoying") RendererBase.__init__(self) self.dpi = dpi self.width = width self.height = height if __debug__: verbose.report("RendererAgg.__init__ width=%s, height=%s" % (width, height), "debug-annoying") self._renderer = _RendererAgg(int(width), int(height), dpi, debug=False) self._filter_renderers = [] if __debug__: verbose.report("RendererAgg.__init__ _RendererAgg done", "debug-annoying") self._update_methods() self.mathtext_parser = MathTextParser("Agg") self.bbox = Bbox.from_bounds(0, 0, self.width, self.height) if __debug__: verbose.report("RendererAgg.__init__ done", "debug-annoying")
def __init__(self, width, height, svgwriter, basename=None): self.width = width self.height = height self._svgwriter = svgwriter self._groupd = {} if not rcParams['svg.image_inline']: assert basename is not None self.basename = basename self._imaged = {} self._clipd = {} self._char_defs = {} self._markers = {} self._path_collection_id = 0 self._imaged = {} self._hatchd = {} self._n_gradients = 0 self.mathtext_parser = MathTextParser('SVG') RendererBase.__init__(self) self._glyph_map = dict() svgwriter.write(svgProlog % (width, height, width, height))
def __init__(self, figure, fh, dummy=False): """ Creates a new PGF renderer that translates any drawing instruction into text commands to be interpreted in a latex pgfpicture environment. Attributes: * figure: Matplotlib figure to initialize height, width and dpi from. * fh: File handle for the output of the drawing commands. """ RendererBase.__init__(self) self.dpi = figure.dpi self.fh = fh self.figure = figure self.image_counter = 0 # get LatexManager instance self.latexManager = LatexManagerFactory.get_latex_manager() # dummy==True deactivate all methods if dummy: nop = lambda *args, **kwargs: None for m in RendererPgf.__dict__.keys(): if m.startswith("draw_"): self.__dict__[m] = nop
def __init__(self, figure, fh, dummy=False): """ Creates a new PGF renderer that translates any drawing instruction into text commands to be interpreted in a latex pgfpicture environment. Attributes: * figure: Matplotlib figure to initialize height, width and dpi from. * fh: File handle for the output of the drawing commands. """ RendererBase.__init__(self) self.dpi = figure.dpi self.fh = fh self.figure = figure self.image_counter = 0 # get LatexManager instance self.latexManager = LatexManagerFactory.get_latex_manager() # dummy==True deactivate all methods if dummy: nop = lambda *args, **kwargs: None for m in list(RendererPgf.__dict__.keys()): if m.startswith("draw_"): self.__dict__[m] = nop
def __init__(self, renderer, width, height): self.width = width self.height = height self._renderer = renderer RendererBase.__init__(self)
def __init__(self, w, h, dpi): RendererBase.__init__(self) self.width = w self.height = h self.dpi = dpi self._draw_stack = []
def __init__(self, w, h, dpi): RendererBase.__init__(self) self.width = w self.height = h self.dpi = dpi self._draw_stack = []
def __init__(self, width, height, dpi): # Hide the overloaded constructors used by from_pycairo_ctx and # _for_fmt_output. _mplcairo.GraphicsContextRendererCairo.__init__( self, width, height, dpi) RendererBase.__init__(self)
def __init__(self, dpi, width, height): RendererBase.__init__(self) self.dpi = dpi self.width = width self.height = height self.gc = GraphicsContextMac()
def from_pycairo_ctx(cls, ctx, dpi): obj = _mplcairo.GraphicsContextRendererCairo.__new__(cls, ctx, dpi) _mplcairo.GraphicsContextRendererCairo.__init__(obj, ctx, dpi) RendererBase.__init__(obj) return obj