class FigureCanvasGR(FigureCanvasBase):
"""
The canvas the figure renders into. Calls the draw and print fig
methods, creates the renderers, etc...
"""
if __version__ >= '1.4':
register_backend('gr', 'backend_gr', 'GR File Format')
else:
register_backend('gr', 'backend_gr')
def __init__(self, figure):
FigureCanvasBase.__init__(self, figure)
width, height = self.get_width_height()
self.renderer = RendererGR(figure.dpi, width, height)
def draw(self):
"""
Draw the figure using the renderer
"""
flags = gr.inqregenflags()
if not flags & gr.MPL_SUPPRESS_CLEAR:
gr.clearws()
self.renderer.configure()
self.figure.draw(self.renderer)
if not flags & gr.MPL_POSTPONE_UPDATE:
gr.updatews()
def print_gr(self, filename, *args, **kwargs):
gr.begingraphics(filename)
self.draw()
gr.endgraphics()
def set_pretty_plots(use_latex=False, use_pgf=False, use_microtype=True):
if use_latex:
if use_pgf:
register_backend('pdf', FigureCanvasPgf, 'pgf')
rcParams['pgf.texsystem'] = 'pdflatex'
preamble = [r'\usepackage{siunitx}',
r'\usepackage{lmodern}',
r'\usepackage{subdepth}',
]
if use_microtype:
preamble.append(
r'\usepackage[protrusion = true, expansion = true]{microtype}'
)
rcParams['text.usetex'] = True
rcParams['text.latex.preamble'] = preamble
rcParams['pgf.preamble'] = preamble
rcParams['text.latex.unicode'] = True
rcParams['font.family'] = 'serif'
rcParams['font.serif'] = ['STIXGeneral']
rcParams['axes.prop_cycle'] = mpl.cycler(color=set3)
rcParams['axes.edgecolor'] = almost_black
rcParams['axes.labelcolor'] = almost_black
rcParams['text.color'] = almost_black
rcParams['grid.color'] = almost_black
rcParams['legend.scatterpoints'] = 1
rcParams['legend.fancybox'] = True
rcParams['legend.frameon'] = False
rcParams['legend.framealpha'] = 0.0
rcParams['lines.linewidth'] = 2.0
# rcParams['image.aspect'] = 'equal'
# rcParams['image.origin'] = 'lower'
rcParams['image.interpolation'] = 'nearest'
def register():
from matplotlib.backend_bases import register_backend
for ext in ['pkl', 'pickle']:
register_backend(
ext, 'pickleback.backend_pkl',
'Python pickle format, to be used with caution on a '
'single matplotlib version')
def register():
"""Enable saving version-control friendly PDF files with Matplotlib.
After calling, all subsequently saved PDF files will have the CreationDate
metadata field stripped out in order to generate reproducible and
deterministic output."""
description = 'Portable Document Format (version control friendly)'
register_backend('pdf', __name__, description=description)
def register():
"""Enable saving version-control friendly PDF files with Matplotlib.
After calling, all subsequently saved PDF files will have the CreationDate
metadata field stripped out in order to generate reproducible and
deterministic output."""
description = 'Portable Document Format (version control friendly)'
register_backend('pdf', __name__, description=description)
def configure_latex(scaler: float = 1.5, width_scaler: float = 1):
"""Configure matplotlib for LaTeX figure output."""
register_backend('pdf', FigureCanvasPgf)
plt.rcParams.update(
{
"pgf.texsystem": "pdflatex",
"pgf.preamble": [
r"\usepackage[utf8x]{inputenc}",
r"\usepackage[T1]{fontenc}",
],
"figure.figsize": [width_scaler * scaler * 3.39, scaler * 2.0951352218621437],
"text.usetex": True,
"backend": "ps",
}
)
class FigureCanvasGR(FigureCanvasBase):
"""
The canvas the figure renders into. Calls the draw and print fig
methods, creates the renderers, etc...
"""
if __version__ >= '1.4':
register_backend('gr', 'backend_gr', 'GR File Format')
else:
register_backend('gr', 'backend_gr')
def draw(self):
"""
Draw the figure using the renderer
"""
gr.clearws()
renderer = RendererGR(self.figure.dpi)
self.figure.draw(renderer)
gr.updatews()
def print_gr(self, filename, *args, **kwargs):
gr.begingraphics(filename)
self.draw()
gr.endgraphics()
except ImportError:
raise ImportError("this backend requires Kivy to be installed.")
from kivy.app import App
from kivy.graphics.texture import Texture
from kivy.graphics import Rectangle, Color
from kivy.uix.widget import Widget
from kivy.properties import ObjectProperty
from kivy.base import EventLoop
from kivy.uix.floatlayout import FloatLayout
from kivy.core.image import Image
from func.garden.matplotlib.backend_kivy import FigureCanvasKivy,\
FigureManagerKivy, show, new_figure_manager,\
NavigationToolbar2Kivy
register_backend('png', 'backend_kivyagg', 'PNG File Format')
toolbar = None
my_canvas = None
def new_figure_manager(num, *args, **kwargs):
'''Create a new figure manager instance for the figure given.
'''
# if a main-level app must be created, this (and
# new_figure_manager_given_figure) is the usual place to
# do it -- see backend_wx, backend_wxagg and backend_tkagg for
# examples. Not all GUIs require explicit instantiation of a
# main-level app (egg backend_gtk, backend_gtkagg) for pylab
FigureClass = kwargs.pop('FigureClass', Figure)
thisFig = FigureClass(*args, **kwargs)
from kivy.graphics.texture import Texture
from kivy.graphics import Rectangle, Color
from kivy.uix.widget import Widget
from kivy.properties import ObjectProperty
from kivy.base import EventLoop
from kivy.uix.floatlayout import FloatLayout
from kivy.core.image import Image
from kivy.garden.matplotlib.backend_kivy import (
FigureCanvasKivy,
FigureManagerKivy,
show,
new_figure_manager,
NavigationToolbar2Kivy,
)
register_backend("png", "backend_kivyagg", "PNG File Format")
toolbar = None
my_canvas = None
def new_figure_manager(num, *args, **kwargs):
"""Create a new figure manager instance for the figure given.
"""
# if a main-level app must be created, this (and
# new_figure_manager_given_figure) is the usual place to
# do it -- see backend_wx, backend_wxagg and backend_tkagg for
# examples. Not all GUIs require explicit instantiation of a
# main-level app (egg backend_gtk, backend_gtkagg) for pylab
FigureClass = kwargs.pop("FigureClass", Figure)
thisFig = FigureClass(*args, **kwargs)
except ImportError:
raise ImportError("this backend requires Kivy to be installed.")
from kivy.app import App
from kivy.graphics.texture import Texture
from kivy.graphics import Rectangle, Color
from kivy.uix.widget import Widget
from kivy.properties import ObjectProperty
from kivy.base import EventLoop
from kivy.uix.floatlayout import FloatLayout
from kivy.core.image import Image
from kivy.garden.matplotlib.backend_kivy import FigureCanvasKivy,\
FigureManagerKivy, show, new_figure_manager,\
NavigationToolbar2Kivy
register_backend('png', 'backend_kivyagg', 'PNG File Format')
toolbar = None
my_canvas = None
def new_figure_manager(num, *args, **kwargs):
'''Create a new figure manager instance for the figure given.
'''
# if a main-level app must be created, this (and
# new_figure_manager_given_figure) is the usual place to
# do it -- see backend_wx, backend_wxagg and backend_tkagg for
# examples. Not all GUIs require explicit instantiation of a
# main-level app (egg backend_gtk, backend_gtkagg) for pylab
FigureClass = kwargs.pop('FigureClass', Figure)
thisFig = FigureClass(*args, **kwargs)
import os, sys
here = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.normpath(os.path.join(here, '../python/')))
from matplotlib.backends.backend_pgf import FigureCanvasPgf
from matplotlib.backend_bases import register_backend
register_backend('pdf', FigureCanvasPgf)
import planckStyle as s
from pylab import *
#g = s.getSinglePlotter(plot_data='plot_data/')
import GetDistPlots
import planckStyle
g = planckStyle.getSinglePlotter(chain_dir='./chains', ratio=.7)
roots = ['BAO_ddt', 'union_ddt', 'BAO+union_ddt']
g.settings.solid_contour_palefactor = 0.8
g.plot_2d(roots,
'omegam',
'sigma8',
filled=[True, True, False],
colors=['#FFB300', '#8E001C',
'black']) #, lims=[0.25, 0.45, 0.6, 1.1])#0.6, 0.9])
labels = [r'BAO', 'SN', 'BAO+SN']
g.add_legend(labels, legend_loc='upper left', fontsize='small')
#, colored_text=True);
#plt.show()
from matplotlib.font_manager import findfont, get_font
from matplotlib.ft2font import LOAD_NO_HINTING
from matplotlib.mathtext import MathTextParser
from matplotlib.path import Path
from matplotlib import _path
from matplotlib.transforms import Affine2D, Affine2DBase
import os
import subprocess
from matplotlib.backend_bases import register_backend
from matplotlib.backend_bases import rcParams
_log = logging.getLogger(__name__)
backend_version = mpl.__version__
register_backend('pdftex', 'PdfTex', 'PdfTex File Format')
# ----------------------------- pdftex backend by Farshid Varno
# Based on an SVG backend in matplotlib original repo
def escape_cdata(s):
s = s.replace("&", "&")
s = s.replace("<", "<")
s = s.replace(">", ">")
return s
_escape_xml_comment = re.compile(r'-(?=-)')
