File Manager

Hackfut Security File Manager

Current Path: /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/backends

opt / alt / python27 / lib64 / python2.7 / site-packages / matplotlib / backends /

📁 ..
📁 Matplotlib.nib
📄 __init__.py(2.17 KB)
📄 __init__.pyc(2.12 KB)
📄 __init__.pyo(2.12 KB)
📄 _backend_agg.so(420.74 KB)
📄 _backend_gdk.so(8.2 KB)
📄 _gtkagg.so(140.51 KB)
📄 backend_agg.py(12.73 KB)
📄 backend_agg.pyc(14.6 KB)
📄 backend_agg.pyo(13.42 KB)
📄 backend_cairo.py(16.11 KB)
📄 backend_cairo.pyc(18.32 KB)
📄 backend_cairo.pyo(18.32 KB)
📄 backend_cocoaagg.py(8.78 KB)
📄 backend_cocoaagg.pyc(12.04 KB)
📄 backend_cocoaagg.pyo(12.04 KB)
📄 backend_emf.py(21.81 KB)
📄 backend_emf.pyc(25.25 KB)
📄 backend_emf.pyo(25.25 KB)
📄 backend_fltkagg.py(20.36 KB)
📄 backend_fltkagg.pyc(26.77 KB)
📄 backend_fltkagg.pyo(26.77 KB)
📄 backend_gdk.py(15.59 KB)
📄 backend_gdk.pyc(17.21 KB)
📄 backend_gdk.pyo(17.21 KB)
📄 backend_gtk.py(39.75 KB)
📄 backend_gtk.pyc(45.22 KB)
📄 backend_gtk.pyo(45.22 KB)
📄 backend_gtkagg.py(4.04 KB)
📄 backend_gtkagg.pyc(5.11 KB)
📄 backend_gtkagg.pyo(5.11 KB)
📄 backend_gtkcairo.py(2.03 KB)
📄 backend_gtkcairo.pyc(3.79 KB)
📄 backend_gtkcairo.pyo(3.79 KB)
📄 backend_macosx.py(14.3 KB)
📄 backend_macosx.pyc(20.82 KB)
📄 backend_macosx.pyo(20.72 KB)
📄 backend_mixed.py(5.04 KB)
📄 backend_mixed.pyc(4.81 KB)
📄 backend_mixed.pyo(4.74 KB)
📄 backend_pdf.py(75.89 KB)
📄 backend_pdf.pyc(66.56 KB)
📄 backend_pdf.pyo(66.45 KB)
📄 backend_ps.py(50.24 KB)
📄 backend_ps.pyc(47.73 KB)
📄 backend_ps.pyo(47.73 KB)
📄 backend_qt.py(16.45 KB)
📄 backend_qt.pyc(21.19 KB)
📄 backend_qt.pyo(21.19 KB)
📄 backend_qt4.py(20.51 KB)
📄 backend_qt4.pyc(24.83 KB)
📄 backend_qt4.pyo(24.83 KB)
📄 backend_qt4agg.py(4.69 KB)
📄 backend_qt4agg.pyc(5.91 KB)
📄 backend_qt4agg.pyo(5.91 KB)
📄 backend_qtagg.py(4.86 KB)
📄 backend_qtagg.pyc(6.05 KB)
📄 backend_qtagg.pyo(6.05 KB)
📄 backend_svg.py(25.34 KB)
📄 backend_svg.pyc(24.31 KB)
📄 backend_svg.pyo(24.2 KB)
📄 backend_template.py(8.6 KB)
📄 backend_template.pyc(9.42 KB)
📄 backend_template.pyo(9.42 KB)
📄 backend_wx.py(77.07 KB)
📄 backend_wx.pyc(79.2 KB)
📄 backend_wx.pyo(79.13 KB)
📄 backend_wxagg.py(8.89 KB)
📄 backend_wxagg.pyc(9.37 KB)
📄 backend_wxagg.pyo(9.37 KB)

Editing: backend_mixed.py

from matplotlib._image import frombuffer
from matplotlib.backends.backend_agg import RendererAgg
from matplotlib.tight_bbox import process_figure_for_rasterizing

class MixedModeRenderer(object):
    """
    A helper class to implement a renderer that switches between
    vector and raster drawing.  An example may be a PDF writer, where
    most things are drawn with PDF vector commands, but some very
    complex objects, such as quad meshes, are rasterised and then
    output as images.
    """
    def __init__(self, figure, width, height, dpi, vector_renderer,
                 raster_renderer_class=None,
                 bbox_inches_restore=None):
        """
        figure: The figure instance.

width: The width of the canvas in logical units

height: The height of the canvas in logical units

dpi: The dpi of the canvas

vector_renderer: An instance of a subclass of RendererBase
        that will be used for the vector drawing.

raster_renderer_class: The renderer class to use for the
        raster drawing.  If not provided, this will use the Agg
        backend (which is currently the only viable option anyway.)
        """
        if raster_renderer_class is None:
            raster_renderer_class = RendererAgg

self._raster_renderer_class = raster_renderer_class
        self._width = width
        self._height = height
        self.dpi = dpi

assert not vector_renderer.option_image_nocomposite()
        self._vector_renderer = vector_renderer

self._raster_renderer = None
        self._rasterizing = 0

# A renference to the figure is needed as we need to change
        # the figure dpi before and after the rasterization. Although
        # this looks ugly, I couldn't find a better solution. -JJL
        self.figure=figure

self._bbox_inches_restore = bbox_inches_restore
        
        self._set_current_renderer(vector_renderer)

_methods = """
        close_group draw_image draw_markers draw_path
        draw_path_collection draw_quad_mesh draw_tex draw_text
        finalize flipy get_canvas_width_height get_image_magnification
        get_texmanager get_text_width_height_descent new_gc open_group
        option_image_nocomposite points_to_pixels strip_math
        """.split()
    def _set_current_renderer(self, renderer):
        self._renderer = renderer

for method in self._methods:
            if hasattr(renderer, method):
                setattr(self, method, getattr(renderer, method))
        renderer.start_rasterizing = self.start_rasterizing
        renderer.stop_rasterizing = self.stop_rasterizing

def start_rasterizing(self):
        """
        Enter "raster" mode.  All subsequent drawing commands (until
        stop_rasterizing is called) will be drawn with the raster
        backend.

If start_rasterizing is called multiple times before
        stop_rasterizing is called, this method has no effect.
        """

# change the dpi of the figure temporarily.
        self.figure.set_dpi(self.dpi)

if self._bbox_inches_restore: # when tight bbox is used
            r = process_figure_for_rasterizing(self.figure,
                                               self._bbox_inches_restore,
                                               mode="png")

self._bbox_inches_restore = r
            
        
        if self._rasterizing == 0:
            self._raster_renderer = self._raster_renderer_class(
                self._width*self.dpi, self._height*self.dpi, self.dpi)
            self._set_current_renderer(self._raster_renderer)
        self._rasterizing += 1

def stop_rasterizing(self):
        """
        Exit "raster" mode.  All of the drawing that was done since
        the last start_rasterizing command will be copied to the
        vector backend by calling draw_image.

If stop_rasterizing is called multiple times before
        start_rasterizing is called, this method has no effect.
        """
        self._rasterizing -= 1
        if self._rasterizing == 0:
            self._set_current_renderer(self._vector_renderer)

width, height = self._width * self.dpi, self._height * self.dpi
            buffer, bounds = self._raster_renderer.tostring_rgba_minimized()
            l, b, w, h = bounds
            if w > 0 and h > 0:
                image = frombuffer(buffer, w, h, True)
                image.is_grayscale = False
                image.flipud_out()
                self._renderer.draw_image(int(float(l)/self.dpi*72.),
                                          int((float(height) - b - h)/self.dpi*72.),
                                          image, None)
            self._raster_renderer = None
            self._rasterizing = False

# restore the figure dpi.
        self.figure.set_dpi(72)

if self._bbox_inches_restore:  # when tight bbox is used
            r = process_figure_for_rasterizing(self.figure,
                                               self._bbox_inches_restore,
                                               mode="pdf")
            self._bbox_inches_restore = r

Hackfut Security File Manager

Editing: backend_mixed.py

Upload File

Create Folder