mpl_axes.py

#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# ================= FILE HEADER ========================================
#
#   myplotlib v3.0.1,
#
#   @file      myAxes.py
#   @author    Yori 'AGy' Fournier
#   @licence   CC-BY-SA
#
#   MyAxes class: Overlay of matplotlib Axes class
#   It is done such that the user can concentrate on
#   the important aspect of the figure and not the
#   technical part. It consists of a constructor,
#   that requires a Figure, the ratio of the xaxis over
#   the yaxis, and the frame in which the figure
#   should be plotted.
#
#   @Class MyAxes
#
#   @Constructor(self, fig, ratio, frame, +user defined kw):
#
#   @section Functions
#
#            - plotting: this is the overwritten function
#                        from Axes. It is called by it's
#                        parent-figure's function .plot()
#
#            - formatRawData: it computes out of the rawData
#                        given as argument some quantities that
#                        are returned as a dictionary and
#                        become accessable for plotting.
#
#   @section History
#
#   v 0.0.0 - MyAxes class for the myplotlib module, consists
#             of a constructor, a pltting function and
#             formatRawData.
#
#   v 2.2.3 - Add testRawData function
#
# ======================================================================
#
#
# IMPORT ---------------------------------------------------------------
from . import SEVR, DBUG
from . import CONTEXT

if CONTEXT.lower() != 'server':
    from . import Axes
    from . import rcParams

_D_FRAME = [0.1, 0.1, 0.8, 0.8]


# COMPUTE SMART FRAME -----------------------------------------------
def compute_fit_rect(fig, ratio, frame_rect):

    # get the frame allowed
    frame_pos_x, frame_pos_y, frame_width, frame_height = frame_rect
    # get the size of the figure
    fig_width = fig.get_figwidth()
    fig_height = fig.get_figheight()
    fig_dpi = fig.get_dpi()

    # get the font size in inches
    fontsize = rcParams['font.size'] / fig_dpi

    # the largest width and height allowed in inches
    max_width = fig_width * frame_width - 8. * (fig_dpi / 75.) * fontsize
    max_height = fig_height * frame_height - 4. * (fig_dpi / 75.) * fontsize

    # the hypothetical width and height in inches
    # for a given aspect ratio
    hypo_width = max_height / ratio
    hypo_height = max_width * ratio

    # if the hypothetical width is larger that the
    # maximum allowed width (in inches) then chose
    # the hypothetical Height
    if (hypo_width > max_width):
        height = hypo_height / fig_height  # height in percent
        width = max_width / fig_width     # width in percent
        pos_x = frame_pos_x + 4. * (fig_dpi / 75.) \
            * fontsize / fig_width      # posX
        pos_y = frame_pos_y + 3. * (fig_dpi / 75.) \
            * fontsize / fig_height     # posY
    else:
        height = max_height / fig_height
        width = hypo_width / fig_width
        pos_x = frame_pos_x + (frame_width - width) / 2.
        pos_y = frame_pos_y + 3. * (fig_dpi / 75.) * fontsize / fig_height

    rect = [pos_x, pos_y, width, height]

    return(rect)

# Class Factory
class AxesClassFactory(type):


    # PREPARE METHOD --------------------------------------------------
    @classmethod
    def __prepare__(mcls, name, bases, **kwargs):
        return(type.__prepare__(mcls, name, bases))

    # NEW METHOD ------------------------------------------------------
    def __new__(mcls, name, bases, attrs, **kwargs):

#        context = kwargs.get('context', 'local')  # python3
        context = attrs.get('__context__', 'local')  # python2.7

        # Set the contextualized parent_constructor method
        parent_constructor = attrs.get('parent_constructor_'+str(context))
        if parent_constructor is not None:
            parent_constructor.__name__ = 'parent_constructor'
            attrs.update({'parent_constructor': parent_constructor})

        # Set the contextualized update method
        update = attrs.get('update_'+str(context))
        if update is not None:
            update.__name__ = 'update'
            attrs.update({'update': update})
        
        # Contextualize the bases for MplAxes
        if context in ('client', 'local'):
            if bases == (): # in the case of MplAxes
                bases = (Axes,)
        elif context == 'server':
            if bases == (): # in the case of MplAxes
                bases = (object,)
        else:
            print("{sevr} The context given in the configuration file \
            is not correct: should be either local, client or server. \
            ".format(sevr=SEVR))
            raise ImportError

        # Actually create the class
        axes_class = type.__new__(mcls, name, bases, attrs)

        return(axes_class)


    # INITIALIZATION METHOD -------------------------------------------
    def __init__(cls, name, bases, dct, **kwargs):
        super(AxesClassFactory, cls).__init__(name, bases, dct)


# Class MyAxes Overwriting Matplotlib.figure.Axes
class MplAxes():

    __metaclass__ = AxesClassFactory
    __context__ = CONTEXT.lower()

    # --- SHARED METHODS -------------------------------------------------

    # CONSTRUCTOR --------------------------------------------------------
    def __init__(self, fig, frame=_D_FRAME, **kwargs):

        self.fig = fig
        self.declare_keywords()

        # parent constructor
        self.parent_constructor(fig, frame, **kwargs)

        # set a default name. Should be individualized by instance
        self.name = 'default'

    # COMPUTE RECT -------------------------------------------------------
    def compute_rect(self, frame_rect, *args, **kwargs):

        # Get the optional keyword
        ratio = kwargs.pop('ratio', None)
        force_ratio_on_width = kwargs.pop('force_ratio_on_width', None)
        force_ratio_on_height = kwargs.pop('force_ratio_on_height', None)
        fit_in_frame = kwargs.pop('fit_in_frame', None)

        # get the frame allowed
        frame_pos_x, frame_pos_y, frame_width, frame_height = frame_rect

        # get the size of the figure
        fig_width = self.fig.get_figwidth()
        fig_height = self.fig.get_figheight()

        if ratio is not None:

            if(force_ratio_on_width):
                frame_width = ratio * fig_width / (frame_height * fig_height)
            elif(force_ratio_on_height):
                frame_height = ratio * (frame_width * fig_width) / fig_height
            else:
                frame_height = ratio * (frame_width * fig_width) / fig_height

        rect = [frame_pos_x, frame_pos_y, frame_width, frame_height]

        if (fit_in_frame):

            if ratio is None:
                ratio = fig_height / fig_width

            rect = compute_fit_rect(self.fig, ratio, rect)

        return(rect)

    # DECLARE KEYWORDS -------------------------------------------------
    def declare_keywords(self):
        self.keywords = {}

    # TESTING THE RAWDATA ----------------------------------------------
    def test_rawdata(self, rawdata):
        return(True)

    # --- INTERFACE METHODS --------------------------------------------
    
    # PLOTTING ---------------------------------------------------------
    def plotting(self):
        raise(NotImplementedError, 'You should have overwrite the'
              ' plotting function.')
        return(False)

    # FORMATTING -------------------------------------------------------
    def format_rawdata(self, rawdata):
        raise(NotImplementedError, 'You should have overwritten the '
              'format_rawdata method.')
        return(False)    
    
    # --- ABSTRACT METHODS ---------------------------------------------

    # PARENT CONSTRUCTOR -----------------------------------------------
    def parent_constructor(self, fig, rect, **kwargs):
        raise(NotImplementedError, 'You should have overwritten the '
              'parent_constructor method.')

    # UPDATE -----------------------------------------------------------
    def update(self, *args, **kwargs):
        raise(NotImplementedError, 'You should have overwritten the '
              'update method.')

    # --- LOCAL/CLIENT CONTEXT METHODS ---------------------------------
    
    def parent_constructor_local(self, fig, frame, **kwargs):

        rect = self.compute_rect(frame, **kwargs)

        # clean kwargs
        kwargs.pop('ratio', None)
        kwargs.pop('force_ratio_on_width', None)
        kwargs.pop('force_ratio_on_height', None)
        kwargs.pop('fit_in_frame', None)
        
        Axes.__init__(self, fig, rect, **kwargs)

    def update_local(self, *args, **kwargs):

        # Because matplotlib.axes.update expect kwargs and not **kwargs
        # ... (stupid!! no, this is just WRONG!!)
        if args:  # catch matplotlib kwargs
            kwargs.update(args[0])
            # kw_for_axes = {key: value for (key, value) in args[0].items() if
            # key not in self.keywords}  # Not compatible with python2.6

        kw_for_axes = {}
        for (key, value) in kwargs.items():
            if key not in self.keywords:
                kw_for_axes.update({key: value})

        Axes.update(self, kw_for_axes)  # update matplotlib.Axes

        # myplotlib update
        # self.keywords.update({key: value for (key, value) in kwargs.items()
        # if key in self.keywords})  # Not compatible with python2.6

        for (key, value) in kwargs.items():
            if key in self.keywords:
                self.keywords.update({key: value})
        
    parent_constructor_client = parent_constructor_local
    update_client = update_local

    # --- SERVER CONTEXT METHODS --------------------------------------
        
    def parent_constructor_server(self, fig, frame, **kwargs):
        pass

    def update_server(self, *args, **kwargs):
        for (key, value) in kwargs.items():
            if key in self.keywords:
                self.keywords.update({key: value})