Last meeting before the winter break

Since the last meeting, we decided many things about our project.

During the last weeks, we created the arborescence : we split the core from the graphical user interface (gui).
We now have a main application that gather all the modules . The viewer and the nodes are connected : when we click on a node, the picture associated is seen in the viewer. The Param Editor should be connected soon.

We discuss about five main subjects during the last meeting :

  • The data structure : we have to organize our code in differents layers :
    – The ButtleApp in python : it’s here that we define all our classes.
    – The Buttle Wrapper in python and PySide : it enables to wrap the nodes and to communicate with the interface.
    – The QManager : it enables to handle the elements created dynamically in QML
    – The QItem
  • In order to connect the different layers, we decided to make a system of update : the ButtleWrapper observe the QItem. When an item changes in the interface, it notifies the ButtleWrapper which upadtes itself.
  • Resizable application : currently, if you resize the main window, some contents are hidden. So the aim is now to make everything resizable in order to have a usable application.
  • Undo/Redo : we created the base of the undo-redo but we now need to create all the commands to undo and redo all our functions.
  • Connections : in the graph, the nodes are now functionnal. We have to make the connections between them.

The aim is to connect Buttle to Tuttle when we come back in January. We have a lot to do but we are motivated ! Moreover, Fabien sent us some mails today with technics that simplify our code ! (For example, the QManager is not used anymore for the nodes).


Buttle UI

This is an overview of the future UI we are currently working on

Fourth meeting

During the past days, we’ve been working on the scope statement, trying to define every part of the future UI more precisely. We’ve agreed on the following :


In the viewer we will be able to display images and videos. Many tools will allow the user to zoom in and out, drag an image, play and stop a video.

The user will have the possibility to assign 9 nodes to the viewer (with the mosquito tool) and switch beteween the 9 corresponding views.

If everything goes well, we will add an option so the user can use many viewers at the same time.

Graph editor

In the graph editor, the user can add or remove nodes. A list menu will allow the user to choose the type of node and every node will have a specific color according to his type.

The nodes can be connected to each other : they can have many inputs, but only one output. When the user clicks on a node’s output/input, a curve appears and he can drag it to another node’s input/output to create a connexion.

Every node contains a vignette of the project with the applied effects at the current node’s step, and the user can show or hide it.

In the right bottom corner, a miniature of the graph will make the navigation easier and let the user know which part of the graph he is viewing.

Parameters editor

This module will give access to the current node’s parameters. We will use different components depending on the type of the parameter so the user can set everyone of them :

  • boolean : checkbox
  • int : input or slider
  • choice : list menu

The parameters of a node are grouped according to certain features. Each group will be displayed in a separate widget. The user will be able to show or hide the details of any widget.

All the modules (viewers, graph editor and parameters editos) will be resizable so the user can adjust the interface to his preferences. We might also have a “full screen” option combining the viewer and the graph editor in a single widget.

Second meeting

For this second appointment at Ubisoft with Fabien Castan, we especially discussed about the technologies.

– Firstly, we talked about Python, and its subtleties : the constructor syntax, the variable $PYTHONPATH, how to construct a python package, the particularity of the default parameters in this langage, etc… We helped our self with some programs we wrote during the previous week.
– After that, we made a review of QML langage : the generalities, and how the Python code will communicate with the interface in QML (Q_PROPERTY and Q_INVOKABLE). Fabien showed us “Qt Components Desktop” (a Qt Tool), which enable us to use some object already made, directly on the interface of ButtleOFX ! We need to discuss about that in order to decide if we will use that or not.
– The last main discuss was about GitHub. It will be a very useful tool for the project : to merge our code, and to do project management (we can assign task to someone, etc…).
Finally, we decided to have an other appointment in two weeks. The project begin to be more understanding for us, but we need some concrete things now ! So for the next review with Fabien, we will come with prototypes of the different parts of the project. We distributed the work like this :
    – undo / redo (Python) : Clément – Aurélien
    – Viewer (QML) : Élisa – Aurélien
    – GraphEditor : Élisa – Arthur – Xochitl
    – ParamEditor : Arthur – Clément – Xochitl
In two weeks, we will also come with our computer, in order to install all packages and dependencies to build the TuttleOFX Project.