Archive

Archive for June 1st, 2015

Tentative Matplotlib Integration

June 1st, 2015 No comments

The purpose of this post is to introduce the main goal of my google summer of code project. The second goal is to support ink processing in a more easier way. Both together can make a difference from other backends implementations. First, I am going to start by summarizing what I know so far about how matplotlib works. The package matplotlib.pyplot is the root of a tree hierarchy, they call it “state-machine environment”. The next step is to create a figure which internally will create the structure to handle the rest of the objects inside the figure. The next level in the hierarchy is Axes, Axis and Artist.

Axes is the whole figure area where the Axis and plot are going to be rendered. As I can see it Axes is kind of a subplot since a Figure can handle more than one Axes but it needs at least one. Axes relevant methods are set_title(), set_xlabel() and set_ylabel(). Axis refers to the coordinates of the graph two main attributes of this class are Locator and Formatter. This class handles the ticks and labels over the coordinates as well as the mapping with the plotting area. Finally, Artist is the class that takes care of the style of the graph –> color, line styles, fonts, etc.

GIven this, a backend is an abstract class that allows to render matplotlib plots using different frontend platforms. I am going to be working on writting one for Kivy starting next week. There are two types of backends: user interface and non-interactive. The user interface one provides ways to visually interact with the data using different interaction techniques usually mouse and keyboard. The non-interactive are the ones that export the plot to a hard format such as png, pdf or svg. There are two rendering engines one given by vector renderers and one given by raster renderers. The main difference between both is that vector use primitive geometric elements such as lines and polygons and raster which are an array of pixels. The very first one can scale and the second one are resolution dependent.

For the implementation of kivy backend I am gonna start implementing a RendererBase which needs a GraphicsContext. To the best of my knowledge while creating the Agg implementation I would pass Agg’s graphics context otherwise I would pass kivy.graphics.context for this purpose. The methods to implement in this class are draw_path, draw_image, draw_gouraud_triangle, there are some other methods as well that can be implemented for optimization reasons.

A GraphicsContext needs to be instantiated and mapped to the matplotlib base classes methods and attributes. For instance map the color of a line with a function that gives what is that color in the kivy context. Another example could be to tell matplotlib use normal line or anti aliased implementation. FigureCanvas should map kivy canvas in addition with the set of events that would need to be overwritten in the FigureCanvas implementation. FigureManager creates the window for the look of it. There is a class called timer which seems to handle the delay time between events.

For the Show() one can overwrite the default mainloop to use the kivy mainloop App.run().

A very first outline can be seen here: Read more…

Categories: GSOC2015 Tags: ,