Ever since I was a kid I have found interesting how it is possible to find a relation between any to objects. As many others, I had been following the news about the Higgs Boson. Cycling to my university, I was trying to sort out the new ideas of quantum physics that I have learned in this process. Not that I understand a lot of it but I remembered quantum physics still have problems to explain one of the most obvious forces that keeps the universe together and beautifully ordered, gravity.
Yes, Higgs Boson explains the universe not being just a disperse wave of energy with any structure. But this particle is a micro force unable to keep the earth going around the sun. So, they have several theories including gravitons. It is not that quantum theory is incompatible with gravity, there is just not a well proven theory but most of the scientists accept its existence.
So, there, culture. What keeps a culture together? Why do we recognize and feel different when are surrounded by the ones we considered members of our culture? The majority find this place just comfortable. A few express totally the opposite, a repulsive effect. There is good explanations of collaboration between individuals. There is also evidence of the strong cohesion between small groups, according, around 12 . “Furthermore, the maximum number of people with whom we can develop relations of trust regulated by face to face interaction and the presence of a mutually respected leader, during any time, is several hundred people”‘  And that is more or less the size of most of the companies in the world.
Then, we have countries but I will stop here because not sure what to say about cohesion of countries. We have very uniform ones, as the one in Nordic regions and we have Guatemala, for example. With 20 different languages and a bigger number of identities. Furthermore, a clear distrust on the government after the war in the 80s (considered genocide by many). If I were a governor, I would definitively would like to be in a country with a uniform culture. So, what is that force that keeps people together?
So, here is what I wanted to say about culture and gravity. They are there, very obvious, very strong, shaping mega-structures and, yet, there is no coherent explanation of their existence.
Face recognition algorithms (used in digital cameras) allowed us to detect faces in paintings. This has gave us the possibility of having a collection of faces of a particular epoch (in this case, the baroque). However, the results of the algorithms are not perfect when applied in paintings instead of pictures. Gamexgives the chance to clean this collection. This is very important since these paintings are the only historical visual inheritance we have from the period. A period that started after the meet of two worlds.
Gamex was born from the merging of different ideas we had at the very beginning of the Interactive Exhibit Design course. It basically combines motion detection, face recognition and games to produce an interactive exhibit of Baroque paintings. The user is going to interact with the game by touching, or more properly poking, faces, eyes, ears, noses, mouths and throats of the characters of the painting. We will be scoring him if there is or there is not a face already recognized on those points. Previously, the database has a repository with all the information the faces recognition algorithms have detected. With this idea, we will be able to clean mistakes that the automatic face recognition has introduced.
The projector. Just to project the image from the back to the screen (rear screen projetion).
Microsoft Kinect. It is going to capture the deformations on the fabric and send them to the computer.
Computer. Captures the deformations send by the Kinect device and translates them to touch events (similar to mouse clicks). These events are used in a game to mark on different parts of the face of people from baroque paintings. All the information is stored in a database and we are going to use it to refine a previously calculated set of faces obtained through face recognition algorithms.
3. The Technology
There were several important pieces of technology that were involved in this project.
Recent technologies offers us the possibility of recognizing objects in digital images. In this case, we were interested in recognizing faces. To achieve that, we used the libraries OpenCV and SimpleCV. The second one just allowed us to use OpenCV with Python, the glue of our project. There are several posts in which we explain a bit more the details of this technology and how we used.
One of the biggest part of our work involved working with multi-touch screens. Probably because it is still a very new technology where things haven’t set down that much we have several problems but fortunately we managed to solved them all. The idea is to have a rear screen projection using the Microsoft Kinect. Initially though for video-game system Microsoft Xbox 360, there is a lot of people creating hacks (such as Simple Kinect Touch) to take advantage of the abilities of this artifact to capture deepness. Using two infrared lights and arithmetic, this device is able to capture the distance from the Kinect to the objects in front of it. It basically returns an image, in which each pixel is the deepness of the object to the Kinect. All sorts of magic tricks could be performed, from recognizing gestures of faces to deformations in a piece of sheet. This last idea is the hearth of our project. Again, some of the posts explaining how and how do not use this technology.
Last but not least, Kivy. Kivy is an open source framework for the development of applications that make use of innovative user interfaces, such as multi-touch applications. So, it fits to our purposes. As programmers, we have developed interfaces in many different types of platforms, such as Java, Microsoft Visual, Python, C++ and HTML. We discovered Kivy being very different from anything we knew before. After struggling for two or three weeks we came with our interface. The real thing about Kivy is that they use a very different approach which, apart from having their own language, the developers claim to be very efficient. At the very end, we started to liked and to be fair it has just one year out there so it will probably improve a lot. Finally, it has the advantage that it is straightforward to have a version for Android and iOS devices.
It is also interesting how ideas changes over the time, some of them we probably forgot. Others, we tried and didn’t work as expected. Most of them changed a little bit but the spirit of our initial concept is in our project. I guess creative process is a long way between a driven idea and the hacks to get to it.
5. The Exhibition
Technology fails on the big day and the day of the presentation we couldn’t get our video but there is the ThatCamp coming soon. A new opportunity to see users in action. So the video of the final result, although not puclib yet, is attached here. It will come more soon!
6. Future Work
This has been a long post but there is still a few more things to say. And probably much more in the future. We liked the idea so much that we are continuing working on this and we liked to mention some ideas that need to be polished and some pending work:
Score of the game. We want to build a better system for scores. Our main problem is that the data that we have to score is incomplete and imperfect (who has always the right answers anyway). We want to give a fair solution to this. Our idea is to work with fuzzy logic to lessen the damage in case the computer is not right.
Graphics. We need to improve our icons. We consider some of them very cheesy and needs to be refined. Also, we would like to adapt the size of the icon to the size of the face the computer already recognized, so the image would be adjusted almost perfectly.
Sounds. A nice improvement but also a lot of work to have a good collection of midi or MP3 files if we don’t find any publicly available.
Mobile versions. Since Kivy offers this possibility, it would be silly not to take advantage of this. At the end, we know addictive games are the key to entertain people on buses. This will convert the application in a real crowd sourcing project. Even if this implies to build a better system for storing the information fllowing the REST principles with OAuth and API keys.
Cleaning the collection. Finally, after having enough data it would be the right time to collect the faces and have the first repository of “The Baroque Face”. This will give us an spectrum of how does the people of the XVI to XVIII looked like. Exciting, ¿isn’t it?
Visualizations. Also we will be able to do some interesting visualizations, like heat maps where the people did touch for being a mouth, or an ear, or a head.
In conclusion we can say that the experience has been awesome. Even better than that was to see the really high level of our classmates’ projects. In the honour of the truth, we must say that we have a background in Computer Science and we played somehow with a little bit more of adventage. Anyway, it was an amazing experience the presentation of all the projects. We really liked the course and we recommend to future students. Let’s see what future has prepared for Gamex!
This post was written and edit togetter with my classmate Javier. So you also can find the post on his blog.
Kivy is an open source library for rapid development of applications that make use of innovative user interfaces, such as multi-touch apps”. It works very well except that the documentation is not fantastic. The introductory tutorial is excellent but after that things start to get complicated.
Specifically, Javier and me struggled with the design of the interface. After a weekend reading the documentation and even code, we finally came with a solution that still feels sort of hacked, specially the coordinates (x,y) of the events. However, there were also nice surprises that start to explain some (at the beginning) weird decisions in the kivy arquitecture.
Since it is difficult to enumerate all the mysteries that we solved out, I will got through the code. The first important thing that you should know about Kivy is that it is not merely python. They have their own Kivy language. Even though, it is possible to use all the library with python, there are several advantages of the Kivy languange that will save you lots of code.
The kivy code is saved in files .kv. To use this code, all you need is
from kivy.lang import Builder
The other important thing is to distinguish between Apps, Widget, Canvas and Graphics.
App is generally one and will control your program. It needs at least one Widget.
Widgets. I would divide this in three types:
Form components: any button, label, textfield or similar
Layouts: these are basically panels in which you can sort other widgets (AnchorLayout, GridLayout, BoxLayout, etc)
Image: in our particular application, the most important one
Canvas. Here is where the confusion begins and I am still not sure if I am totally right. It seem that there is just one canvas and it corresponds to the “drawable” part of the App (the app, not the widget). And this brings problems because when you capture events it could be produce in any area of the App (except the areas occupy by widgets that captures their own events such as buttons). The problem is that you have to calculate your own relative coordinates from the absolute ones.
Graphics. This are objects that you can draw in the canvas: rectangles, ellipses, etc.
A minimal application will look like this
from kivy.app import App
from kivy.lang import Builder
from kivy.uix.floatlayout import FloatLayout
# Class attributes....
def __init__(self, **kwargs):
#some initial configuration but be very careful
#because kivy is quite sensitive with the constructor
#use the .kv instead
return Controller(info='Hello world')
if __name__ in ('__android__', '__main__'):
The file gamex.kv is actually the one that organize the interface which you can see in the next picture. Some details are missing but basically it has three components. The image, a right-side menu and a bottom menu.
I will try to give you some clues of the code:
Line 1: it’s mandatory and specify the kivy version.
Line 3: it has to have the same name of the first widget of the application. Look in the previous python minimal example. The rest of the code is indented inside of this line so it belongs to controller
Line 4 to 7: The right side of the assignations must be attributes in the class Controller. The second part of the assignation are ids for some of the components of the interfaces. I will be back to this at the end.
Line 9 to 11: This correspond to the image component of the interface. Anchor layout means that the position is going to be set by two of five types of references: top, bottom, right, left and center. One of the references set the x axis and the other the y axis. So in total there are nine combinations. In the example the layout is going to use the top-left part of the widget.
Line 15: We can reference the attributes of the class using the variable root. The nice thing is that if the attribute change, then the interface is updated automatically.
Line 16: Complements the previous 9 to 11. The size_hint of the image (not the AnchorLayout as you would expect) is the one that stablish the size of the Layout.
Line 19 to 40 are not important.
Line 43: This is going to define the right list of buttons. The size hint is set in Line 49
Line 47: Stablish a BoxLayout to organize the buttons. In this case the buttons are actually kivy images. The problem we found with the buttons is that if you assign and image to a button, then the image is distorted.
Line 96: It has a very similar structure to line 43 and correspond to the bottom components. In this case we use buttons and labels since we didn’t need to put images.
This kivy languages already have saved us a lot of code in our interface but also there is another important detail that I need to explain. It corresponds to lines 4 to 7. As I said these assignations corresponds to attributes inside the class and ids inside the kivy code. So, for example, the line 4 assigns the id _paint to the attribute paint (the attribute in the final code is here). The _paint is in line 14 and also you must add the attribute to the class. The previous python code will look like this:
# Class attributes….
paint = ObjectProperty(None)
I guess that’s it. I didn’t expect to say that much. Thanks.
One of the most important ideas in object recognition, particularly faces recognition, became with the work of Viola and Jones . This work is based in the algorithm of Adaboost . The idea is use very simple features of the faces that can be calculated very fast. Then select the best ones testing against a previously set of faces. In general, a feature is any value we can extract from a digital image. For example, a simple value of a pixel could be a feature. It is also possible to use more sophisticated stuff like histograms of colors or edges. In the case of Viola and Jones they use a very simple way of play with pixels. Just as an example, a feature could be the substraction of the area (sum of pixels) of one region of the image to another region of the image.
So, as part of the course Interactive Exhibit Design we decided to use this. Then I processed a lot of old baroque paintings and extract the faces. Even though the results are not perfect, I obtained decent results. I have a whole folder of faces and these are two sections of it. the first is a good section of the folder and the second a not-so-good section. I hope to do something interesting with all of this.
I already posted our proof of concept for our project in the course of Interactive Exhibit Design. Here I combined the example of Simple Kinect Touch (SKT) with some of the code Javier has been working on. I took some time to sort out the position of my screen and the kinect to get a better result. I guess it would be useful since I am using the last version of the SKT in which the interface has changed a bit. I hope it would be useful to somebody.