|
|
# Summary
|
|
|
|
|
|
1. [Concept](#concept)
|
|
|
2. [The class AxMyFirstAxes](#the-class-axmyfirstaxes)
|
|
|
3. [Linking the class to the module](#linking-the-new-class-to-the-module)
|
|
|
4. [Using the axes](#using-the-axes)
|
|
|
|
|
|
# Concept
|
|
|
|
|
|
**myplotlib** is an interface between you and the great functionality of matplotlib.
|
|
|
|
|
|
As such it naturally inherit a lot of the structures from matplotlib:
|
|
|
alike in matplotlib a plot is composed of four type of objects:
|
|
|
1. **The window** (that contains the buttons, and handle events)
|
|
|
2. **The canvas** (the sheet of paper where you draw the figure)
|
|
|
3. **The figure** (an empty object that contains an array of axes)
|
|
|
4. **The axes** (This is the core of the plot)
|
|
|
|
|
|
We naturally start with the **axes**.
|
|
|
|
|
|
An axes is composed of two **axis**, two **labels**, one **title** and a bunch of **artists**.
|
|
|
- an **axis**: has ticks (minors and majors), ticklabels (the numbers) and limits
|
|
|
- the **labels** and **title** are just text objects
|
|
|
- the **artists** are everything you may draw on the axes: lines, polygones, images, text, surfaces... (see [doc](http://matplotlib.org/users/artists.html#axes-container))
|
|
|
|
|
|
In **myplotlib** we add two intrinsic functionalities to an axes.
|
|
|
The main idea behind **myplotlib** is the independence of the axes.
|
|
|
|
|
|
> *An axes should know how to extract the relevant information it needs and how to represent them on the screen.*
|
|
|
|
|
|
As a results a MyAxes instance (the axes in myplotlib) has two additional functions:
|
|
|
- **formatRawData**: the function that extract the information (tech: produce a self.data object).
|
|
|
- **plotting**: the function that represent these data on the screen (tech: produce artists in the axes container).
|
|
|
|
|
|
If you look at [myplotlib/myAxes.py](https://gitlab.aip.de/yfournier/myplotlib/blob/tools/myAxes.py)
|
|
|
you will remark that these two functions are empty. That is the power of object oriented programming.
|
|
|
`MyAxes` is a container class that fits into a framework, it is compatible with all the functionalities of matplotlib.
|
|
|
So now you have the freedom of specialising this **base class** to any purpose you wish,
|
|
|
ensuring that you can enjoy the full power of matplotlib.
|
|
|
|
|
|
Now we will see how to overwrite the **base class** `MyAxes` with a new class that we will call `AxMyFirstAxes`.
|
|
|
To overwrite a class you just need to overwrite these two empty functions and actually do something.
|
|
|
|
|
|
# The class AxMyFirstAxes
|
|
|
|
|
|
Create `mymodule/myAxes/<name of my class>.py`
|
|
|
|
|
|
> Here we will use mymodule/myAxes/axMyFirstAxes.py
|
|
|
|
|
|
```python
|
|
|
# Import the mother class MyAxes from the local myplotlib module
|
|
|
from ..myplotlib import MyAxes
|
|
|
|
|
|
# Here you can also import any needed module
|
|
|
# ex: from .. import np
|
|
|
# import numpy as np
|
|
|
|
|
|
|
|
|
# Begin of the class
|
|
|
class axMyFirstAxes(MyAxes):
|
|
|
|
|
|
# This is the function that will format the rawdata so that they can be plotted
|
|
|
def formatRawdata(self, rawdata):
|
|
|
|
|
|
|
|
|
# Extract some part of the data
|
|
|
rawdata1 = rawdata.data[<some key>]
|
|
|
rawdata2 = rawdata.data[<some key>]
|
|
|
|
|
|
# Format the data
|
|
|
if(self.fig.keywords[<some key>]):
|
|
|
# format in a certain way
|
|
|
else:
|
|
|
# format in another way
|
|
|
|
|
|
# Put everything you need into the data of the axes
|
|
|
self.data = {'xdata': xdata,
|
|
|
'ydata': ydata,
|
|
|
'xlabel': xlabel,
|
|
|
'ylabel': ylabel}
|
|
|
|
|
|
# Returning True or False is not optional
|
|
|
return(True)
|
|
|
|
|
|
|
|
|
# This function is the plotting procedure
|
|
|
def plotting(self):
|
|
|
|
|
|
# You can get the keywords you need from the figure
|
|
|
xrange = self.fig.keywords.get('xrange', None)
|
|
|
yrange = self.fig.keywords.get('yrange', None)
|
|
|
|
|
|
# All matplotlib functions are available (see http://matplotlib.org/api/axes_api.html)
|
|
|
self.plot(self.data['xdata'], self.data['ydata'])
|
|
|
|
|
|
# Any decoration you need
|
|
|
self.set_xlabel(self.data['xlabel'])
|
|
|
self.set_ylabel(self.data['ylabel'])
|
|
|
|
|
|
if xrange is not None:
|
|
|
self.set_xlim(xrange)
|
|
|
|
|
|
if yrange is not None:
|
|
|
self.set_ylim(yrange)
|
|
|
|
|
|
# Returning True or False is not optional
|
|
|
return(True)
|
|
|
```
|
|
|
|
|
|
# Linking the new class to the module
|
|
|
Now that the axes class is created we just need to link it to the module.
|
|
|
To do so you need to add the following line in `mymodule/myAxes/__init__.py`
|
|
|
```python
|
|
|
from axMyFirstAxes import AxMyFirstAxes
|
|
|
```
|
|
|
|
|
|
the module `mymodule` import by default all axes in the sub-module `myAxes`, so you just need
|
|
|
to tell `myAxes` to load the class `AxMyFirstAxes` from the file `axMyFirstAxes`.
|
|
|
|
|
|
# Using the axes
|
|
|
Now you are ready to play with your new axes:
|
|
|
```python
|
|
|
from mymodule import *
|
|
|
data = ...
|
|
|
fig = FigOneAxes2D((data,), AxMyFirstAxes)
|
|
|
win = MyWin(fig)
|
|
|
``` |
|
|
\ No newline at end of file |