Archive

Posts Tagged ‘backend’

Matplotlib backend kivy in Windows hands on

September 1, 2015 11 comments

The backend implementations for matplotlib in kivy work just with kivy versions greater or equal than 1.9.1. It is required to install kivy in development mode following these steps: http://kivy.org/docs/installation/installation-windows.html#use-development-kivy. After step 10 you can additionally run


python setup.py install

The script kivy.bat creates an environment in which some python tools are ready to use, for instance pip. The next step is to download numpy and matplotlib from this binaries repositories: http://www.lfd.uci.edu/~gohlke/pythonlibs/#numpy and http://www.lfd.uci.edu/~gohlke/pythonlibs/#matplotlib. Once downloaded install both using pip and then install kivy-garden and the matplotlib package for kivy.


pip install "numpy-1.10.0b1+mkl-cp27-none-win32.whl"
pip install "matplotlib-1.4.3-cp27-none-win32.whl"
pip install kivy-garden
garden install matplotlib

You can go now to the folder that by default garden packages are installed. In my case C:\Users\my_user\.kivy\garden\


cd garden.matplotlib/examples
python test_plt.py

And you should be able to see the matplotlib widget working on windows. Follow the steps from http://kivy.org/docs/installation/installation-windows.html#send-to-method to create a shortcut to execute your kivy apps.

Now you can go directly to the garden path using a file explorer, do right click on test_plt.py and send to kivy-2.7.bat which will start the application.

Advertisements
Categories: kivy, matplotlib Tags: , ,

Matplotlib for Kivy Final Notes

August 26, 2015 Leave a comment

As outcome of one of the projects from the google summer of code 2015 two packages were created and are available as kivy garden packages.

These two packages can be used separately or can be combined as shown in https://andnovar.wordpress.com/2015/08/06/corner-detection-on-strokes-and-strokes-annotations-on-matplotlib/.

Warning:

– If you are using dash_list attribute when creating a line in a figure, it will not work until the update is done in the next kivy version.
– The backend only works with the kivy >= 1.9.1. Some changes were done in the Widget class.
– Matplotlib backend has not been tested on android.

Both packages have been tested and debugged, however it is highly encouraged to submit any issue found while using them. Some of its advantages and weaknesses are exposed in the following paragraphs:

The first package is garden.matplotlib which is a matplotlib backend for kivy, it allows to create applications using pyplot instructions or to embed figures into a kivy application. There are two possible backends that can be invoked:

– backend_kivy which does the render using kivy graphics instructions.
– backend_kivyagg which does the render using an static image texture.

Both of the backends can be connected to the default matplotlib events https://andnovar.wordpress.com/2015/06/15/connecting-events-between-kivy-and-matplotlib/. Additionally another widget called NavigationToolbar can be instantiated and used with both backends, a better description can be found in https://andnovar.wordpress.com/2015/08/06/navigation-toolbar-with-matplotlib-events-connected/. A FigureCanvas can be used without a NavigationToolbar but a NavigationToolbar needs a FigureCanvas to be instantiated. The main advantage of this package is the ability to be added as another Kivy widget inside a Kivy application through the use of matplotlib instructions.

There are some features that were not implemented and the users should be aware of:

– backend_kivy and backend_kivyagg are non interactive backends (http://matplotlib.org/faq/usage_faq.html#what-is-interactive-mode)
– gouraud shading in backend_kivy
– configure_subplots button in the NavigationToolbar is not implemented.

Known bugs:

– When zooming on an area with not enough graphics instructions the render is not properly done. https://github.com/andnovar/kivy/issues/72

In the same way there are some features implemented in backend_kivy that are not implemented in other graphics instructions based backends.

– clip path when rendering an image.
– draw_path_collection method for optimization.
– draw_markers for optimization.

We believe most of matplotlib current capabilities have been considered during this backend implementation. However, we encourage to submit any capability missed you may find.

Categories: GSOC2015, kivy, matplotlib Tags: , ,

Kivy matplotlib backend with right text positioning and rendering.

July 8, 2015 Leave a comment

In order to fix the problem of the layout of the text inside the canvas, an important function had to be overwritten with the information of the bounding box for each text inside it. The function is get_text_width_height_descent in this, one calculates the width and height and return them. Inside matplotlib these values are important to calculate the positioning of the elements according to the layout set by the user. Additionally, in the draw_text method transformations and styling is applied to the text. At the end we can have a working backend with different fonts and styles that are mapped between matplotlib and kivy capabilities.

Another inconvenient in the rendering of the graphs were some glitches while drawing. I was calculating u and v to create the mesh for the polygons when this was not really necessary. After some debugging and analysis of the vertices the final implementation generate the meshes and lines for all the elements in the canvas as follow:

Screenshot from 2015-07-07 12:18:28 example mpl kivy

As can be seen, now it is getting closer to how the static image implementation looks like from the previous post.

Kivy backend using Line and Mesh graphics instructions

June 26, 2015 2 comments

This is the first prototype for the backend, points are extracted from the path an transformed into polygons or lines. Line and Mesh are used in the kivy side to render these objects in a widget canvas. Labels are used for displaying text. Below some examples can be found. The lines are not well defined and the next is to optimize this drawing as well as the text. Some attributes should be added to the labels, positioning is another problem.

matplotlib examples kivy matplotlib kivy matplotlib kivy matplotlib kivy

Read more…

Writing a matplotlib renderer for Kivy

June 24, 2015 Leave a comment

A Renderer is a class that knows all the graphics instructions to draw in a canvas. The first implementation involved to use the canonical agg renderer to get a figure which we could texture in a rectangle, this is fully explained in a previous post. The objective of my implementation is to have a backend implemented using kivy graphics instructions. The RendererBase class defines all the required methods to do so. RendererKivy extends from it and implements draw_path, other 5 different methods can be implemented but the most important is draw_path.

In this method all the required information to draw on the canvas is provided however there is another class as well required to change the style of elements rendered. This class is GraphicsContext which is a middle class between a renderer and an Artist. Artist is one of the layers in the hierarchical architecture of matplotlib, the other two layers are backend and scripting. Basically, everything that can be drawn in a canvas is an Artist object such as Axis, Tick, Figure, etc. A GraphicsContextKivy is defined which extends from GraphicsContextBase and specifically translates matplotlib context instructions such as line width, line style, caps, joints, colors, etc. into the equivalent in Kivy. As can be seen in the figure below the lines are dashed and the foreground of the canvas was changed.

backend kivy

At the moment there are three issues: the first one is that kivy implements caps for lines {‘square’, ’round’, ‘none’} and matplotlib {‘butt’, ‘projecting’, ’round’}. the second issue is that dashes in kivy are supported depending on the line width and finally, kivy does not support dynamic values for dash offset and dash length. The renderer, receives this object GraphicsContext and applies such styles defined there into kivy context and vertex instructions. As can be seen in the figure a very simple drawing of the information received in the draw_path is performed. Basically lines are created with all the vertex received but a path is more complex than that and represents a series of possibly disconnected, possibly closed, line and curve segments. The next post will be about this class Path and which kivy instructions are being used to implement the renderer.

Connecting events between kivy and matplotlib

June 15, 2015 Leave a comment

Matplotlib provides a list of events that can be connected to an external backend. This list of events can be found in backend_bases.py, the events are:


events = [
'resize_event',
'draw_event',
'key_press_event',
'key_release_event',
'button_press_event',
'button_release_event',
'scroll_event',
'motion_notify_event',
'pick_event',
'idle_event',
'figure_enter_event',
'figure_leave_event',
'axes_enter_event',
'axes_leave_event',
'close_event'
]

In order to connect these events to kivy events, we first need to know the corresponding kivy events that can be match with the ones in the previous list:


widget_events = [

'on_touch_down',
'on_touch_up',

]

keyboard_events = [

'on_key_down',
'on_key_up',

]

window_events = [

'on_close',

]

attribute_events = [
'mouse_pos', #from Window
'size',

]

The definition for each mpl event and how it is connected to each kivy event will be explained below:

– ‘button_press_event’ :
On FigureCanvasKivy ‘on_touch_down’ will be triggered when a user touches the widget. A call to FigureCanvasBase will be performed on ‘button_press_event’ with the corresponding touch.x and touch.y arguments.

Read more…

Categories: GSOC2015, kivy, matplotlib Tags: ,

Backend for kivy in matplotlib, first steps

June 11, 2015 4 comments

A backend in matplotlib is a class that creates a link between matplotlib and any frontend framework in which the data can be rendered. Matplotlib provides a template which works as an excellent starting point for anyone who would like to develop a backend. It is a class which by itself works as a backend but do nothing. The very first thing I have been doing the last three days is reading the comments on this file and analyzing how backends for other frameworks are implemented.

The first objective towards implementing a fully functional backend in kivy is to write one with a canonical renderer such as Agg. The first class I modified from the list of classes that the file provides is FigureCanvas which I renamed FigureCanvasKivyAgg. This class extends from a FigureCanvasAgg and a Kivy Widget. The reason why it extends from FigureCanvasAgg is because this class returns an Agg renderer which will contain the graphical information of the graph. Additionally, it extends from Widget because it is handy to add a widget when someone wants to embed matplotlib graphs or use it with pyplot to provide a fully functional App.

Example of a graph rendered in kivypython ../../../examples/mpl/test_plt.py -dmodule://backend_kivy

In FigureCanvasKivyAgg two methods were overridden. The first one is draw which defines the context in which the renderer will be placed. From the FigureCanvasAgg I get the rgba buffer in order to place that in a texture which can be then added to a widget, as you can see in the following snippet.


texture = Texture.create(size=(w, h))
texture.blit_buffer(buffer_rgba, colorfmt='rgba', bufferfmt='ubyte')
texture.flip_vertical()
with self.canvas:
    Rectangle(texture=texture, pos=self.pos, size=(w, h))

The second method is blit, in which given a bounding box defines the rectangular area of the graph to be drawn.

self.blitbox = bbox

FigureCanvasKivyAgg can be embed in any Kivy application given it is a Widget

Read more…

Categories: GSOC2015, kivy, matplotlib Tags: ,