TheRandomLab

“At one’s fingertips”, CvCinema’s first shortfilm!

2012-02-20T06:30:00.000-08:00

We are glad to announce the release of the first experimental shortfilm of the Computer Vision Cinema system, where theRANDOMlab helped in the development. The raw footage was processed by the system, which determined the cuts and framing of the output, based on movement detection algorithms, such as frame differencing, background subtraction or brightness tracking.

This is the film:

Sinopsys:

Life as we know it is ruled by rhythm and cycles from the beginning itself. At any cycle's end, with increased experience, we step at the edge of a fork in our paths. Although we think we are in control, the branch we take depends on rules we don't know. In mathematics, such a situation might be defined as random, i.e., having a result "which cannot be determined but only described probabilistically". Although everyday Humanity increases the amount of knowledge about the Universe, the field is infinite. Every truth we reach opens a new set of questions. If there is a Truth, is it at our fingertips?
This film is part of the Computer Vision Cinema, an experimental research project to apply Computer Vision techniques in the process of filmmaking, in the search for new audiovisual expression languages. The footage is processed by a computer that determines the cuts and framing of the output based on movement detection algorithms, such as frame differencing, background substraction or brightness tracking.

Let's go to the bits and pieces: the making of.

As you can see in the following video, the original footage, recorded with a Canon 600D/t3i, is a hanheld shot, which doesn't help if you want to make a proper detection with the frame differencing/background substraction techniques.

So, the selected fragment of the footage had to be stabilized. We made stabilization tests with AfterEffects (licensed to our University), as well as with free software: Cinelerra and Blender (thanks to Francois Tarlier's tutorial at http://www.francois-tarlier.com/blog/2d-tracking-tutorials-with-blender/). We most liked the Blender result, so we used it to feed the system. This is a low res version of the stabilized footage fragment fed into the CvCinema system:

After tuning the detection parameters, the outputs and the detection of several algorithms and configurations were recorded to be used in the final editing.

Then the footage was arranged from the most abstract (least information) to the most realist (more information), to keep the audience's expectation. We used Kdenlive free video editor.

A low res version of the final video was fed into a PureData patch to generate the soundtrack. This patch analyzes the rgb levels and does a mapping to the parameters of a sysnthesis generator.

Laptop cooling mod

2012-01-26T04:44:00.000-08:00

For my work on computer vision I needed an upgrade from my veteran netbook, so I don't have to spend most of the time watching the compilation for every little change in the code. I got myself an Asus U24E, and upgraded it with an i7-2720qm processor, 8Gb ram, and a ssd hard drive (thanks the guys at this thread for the tips on the upgrade).

Because the new processor dissipates more heat (45w instead of 35w), I was afraid of high core temperatures during the spanish summer.

With the original cooling, at a room temperature of about 18ºC, the cores quickly reach 85ºC at 100% load (junction Tmax is 100º).

I first tried to put some thermal paste and a fanless chipset-heatsink on top of the heatpipe, over the processor. This resulted in instantly lowering the temperature about 10ºC, but as soon as the sink got hot, it couldn't handle the dissipation of the heat just by natural convection.

Test attaching a heatsink over the processor.

So, adding any mass there wouldn't help.

Then I thought about adding a new heatpipe, as seen in many gamer laptops that have several pipes in parallel. I was lucky to savage two small heatpipes from an old laptop, that would fit perfectly in the space left at both sides of the actual heatpipe.

Two small heatpipes savaged from an old laptop, next to the Asus u24e

Of course, I would need to flatten and re-bend the pipes in the proper shape. I did it slowly, by gently applying some heat to them in the kitchen fire and with the help of a custom wood mold.

Custom wood mold to help bending the pipes

Flattening the pipes

I also made an extra support out of a cooper plate, to increase the heat transfer at the end of the pipes opposite from the processor; and a fitting to fill the gap on one side of the original heatsink (which wasn't properly soldered in the middle, but displaced about 2mm).

Making the cooper support

Piece of cooper to fill the gap, just on one side.

After reading this article about efficient cooling with heatpipes, that shows the poor result of a bad cooling configuration, I was afraid of getting an opposite result from my mod. So I did a preliminary test attaching the pieces with some nylon cord and putting a nice amount of thermal paste.

New heatsinks held on place with nylon cord (I)

New heatsinks held on place with nylon cord (II)

New heatsinks held on place with nylon cord (III)

The results were very satisfactory: with prime 95 the temperature took about twice as much time to reach a peak and it never went above 84ºC (without the mod it reached 85º after a few seconds).

So I got some thermal adhesive to make the thing permanent. Soldering would probably improve the performance a lot, but I didn't dare to do it, as the lowest melting point solder alloy (179ºC, alloy: SnPb 2%Ag), is almost the maximum recommended temperature of the heatpipes (180ºC).

Mixing the thermal adhesive

Some pressure to keep the bond as thin as possible.

Detail of the fixture.

Some lapping of the cooper plate in contact with the processor would also help, as there were some irregularities in it's surface. I noticed the thermal paste made an excellent polishing paste, used together with some regular kitchen paper.

Irregular surface of the cooper face. There was a longitudinal line-dent in the middle.

The plate almost mirror-finished

The thermal paste ended up shiny as well.

In my excitement I forgot to make pictures of the finished piece. But you can see how it looked like when installed. I had to flatten one of the pipes at the tightest point, to be able to put the board in place.

The cooling mod finished and in place.

Detail of the tightest point between the memory banks and one screw's place.

After the mod the temperature playing some very demanding games went down from 85ºC to about 73ºC. Not as cool as some gamer laptops, but lower than before anyway. We'll see how well it performs in the summer !

Kinect real-time head tracking with openframeworks

2011-12-05T13:14:00.000-08:00

We are playing with the capabilities of the algorithm published by Gabriele Fanelli, for an upcoming interactive installation. The results are very promising as you can see in the following video...

No training or special setup needed, heads are detected instantly. This funny hack is the first rough test, applied to augmented reality.

We are working to improve our code, specially the speed and quality of the triangulation. The detection algorithm uses random regression forest to match the pose of the user and estimate the position and orientation of the head. The result is surprisingly robust, accurate and fast, even with partial occlusion of the head. However, with the provided training database, it is usual that you get false positives.

PS3 Eye Driver Framerate Patch

2011-12-04T03:09:00.000-08:00

The PS3 eye driver has a fixed default videomode and framerate. If you want to change the framerate of your PS3 eye in linux you usually have to unload the module and load it again. We modified bear24rw's patch to include the posibility to change the framerate form your favorite viewer like GUVCview or from your own code like openFrameworks...

The following steps are reproduced form bear24rw tutorial, which includes his useful patched driver ov534.c (initially patched by kaswy and now includin our modification), but we also included two more files we had to modify: gspca.c and gspca.h

Just follow these instructions to install the modified driver, at your own risk. (Note: each time you or the system updates your kernel you will have to repeat instructions 4-7).

To apply:

1) Install necessary packages:
$ sudo apt-get install kernel-package libncurses5-dev wget bzip2 build-essential linux-source

2) Extract kernel source code:
$ sudo su
$ cd /usr/src
$ tar --bzip2 -xvf linux-source-2.6.(your version).tar.bz2
$ ln -s linux-source-2.6.(your version) linux

3) Replace driver:
$ cd linux
$ wget www.dasaki.com/downloads/ov534/ov534.c www.dasaki.com/downloads/ov534/gspca.h www.dasaki.com/downloads/ov534/gspca.c
$ mv drivers/media/video/gspca/ov534.c drivers/media/video/gspca/ov534.c.bak
$ mv drivers/media/video/gspca/gspca.h drivers/media/video/gspca/gspca.h.bak
$ mv drivers/media/video/gspca/gspca.c drivers/media/video/gspca/gspca.c.bak

$ mv ov534.c drivers/media/video/gspca/

$ mv gspca.h drivers/media/video/gspca/

$ mv gspca.c drivers/media/video/gspca/

4) Recompile driver:
$ cp /usr/src/linux-headers-$(uname -r)/Module.symvers /usr/src/linux
$ make clean
$ make oldconfig
$ make modules_prepare
$ make SUBDIRS=drivers/media/video/gspca modules

5) Install new driver:
$ cp drivers/media/video/gspca/gspca_ov534.ko /lib/modules/$(uname -r)/kernel/drivers/media/video/gspca
$ cp drivers/media/video/gspca/gspca_main.ko /lib/modules/$(uname -r)/kernel/drivers/media/video/gspca
$ depmod

6) Check to make sure it installed:
$ modinfo gspca-ov534

description: GSPCA/OV534 USB Camera Driver(kaswy mod for MT use V0.5 / bear24rw patch V0.1 / theRANDOMlab patch V0.1)
author: Antonio Ospite
srcversion: E412C43D4DAADEA0D3EE5C3
alias: usb:v1415p2000d*dc*dsc*dp*ic*isc*ip*
depends: gspca_main
vermagic: 2.6.32.27+drm33.12 SMP mod_unload modversions 586
parm: videomode: = xx //Set the videomode(see doc) (int)
parm: autogain: = [0|1] //Autogain (agc,aec,awb) (bool)
parm: gain: = [0..63] //main gain (int)
parm: awb: = [0|1] //Auto White Balance (bool)
parm: exposure: = [0..255] //Exposure (int)
parm: brightness: = [0..255] //Brightness (int)
parm: contrast: = [0..255] //Contrast (int)
parm: redblc: = [0..255] //Red Balance (int)
parm: blueblc: = [0..255] //Blue Balance (int)
parm: hue: = [0..255] //Hue (int)
parm: sharpness: = [0..63] //Sharpness (int)
parm: vflip: = [0|1] //Vertical flip (bool)
parm: hflip: = [0|1] //Horizontal mirror (bool)

7) Now we can remove the one currently in use and load our new one:
$ modprobe -r gspca-ov534
$ modprobe -r gspca-main
$ modprobe gspca-main
$ modprobe gspca-ov534 videomode=10

The available video modes are:
00: 640x480@15
01: 640x480@30
02: 640x480@40
03: 640x480@50
04: 640x480@60
10: 320x240@30
11: 320x240@40
12: 320x240@50
13: 320x240@60
14: 320x240@75
15: 320x240@100
16: 320x240@125

You can adjust the image using guvcview

$ sudo apt-get install guvcview

$ guvcview

Cooler Pandaboard with newer kernels?

2011-11-26T05:53:00.000-08:00

After running some stress tests to analyze the thermal performance of the Pandaboard with a newer OS, the results were surprising...

As we posted before, the Pandaboard omap4430 processor temperature was very high under 100% cpu usage. At that time we were running the system from an Ubuntu 10.10 preinstalled image for the Pandaboard. This system was quite unstable, it freezed all the time, and we usually had to restart it several times each session.

Recently, we installed a newer Ubuntu release for the Omap4 platform, the Ubuntu-Linaro 11.09, and also a headless Angstrom Pandaboard Demo Image built from the Narcissus Angstrom online image builder.

We run the test again, with our experimental code (download binary here, run as root AT YOUR OWN RISK!).

These are the results at 100% cpu load:

Omap4 Ubuntu 10.10 temperature / CPU usage

Ubuntu-Linaro 11.09 temperature / CPU usage

Angstrom (2.6.35.3+) temperature / CPU usage

The Linaro image is the best and most stable system we have tested. The installation is straightforward, besides some issues with the language and time zone configuration. It also offers the possibility to switch to the classic gnome desktop, to avoid the new Unity interface.

Seeing the results, it is obvious that something is different between the systems. The 10.10 reaches a maximum temperature of about 80ºC. The other two systems stay under 69ºC at the same load. The load is more constant on the Angstrom because there are fewer system processes that interfere in the test.

We thought the cause of the temperature difference could be that the newer kernels would scale the CPU frequency to protect itself under high loads. But it seems cpu scaling is not enabled for the omap4430 on these systems. The output of 'cat /proc/cpuinfo' showed the actual frequency of both cores:

SYSTEM	cpuinfo	aprox. frequency	max. temp
Ubuntu 10.10	processor: 0 BogoMIPS: 2013.49 processor: 1 BogoMIPS: 1963.08	1GHz	81ºC
Ubuntu-Linaro 11.09	processor: 0 BogoMIPS: 1576.53 processor: 1 BogoMIPS: 1539.77	800MHz	65ºC
Angstrom	processor: 0 BogoMIPS: 2013.49 processor: 1 BogoMIPS: 1996.68	1GHz	69ºC

We wondered if this was just a bug on the file or the cpu runned underclocked. So we checked out the cpuinfo on a Ubutnu 11.10, and it showed the same numbers as the Linaro 11.09. As in the Angstrom system the frequency is as expected, we don't know if the cpu frequency is the actual reason for a lower maximum temperature of the processor at 100% load. Any clue?

EDIT: Nov 28 07:14AM -0800
As answered on the Digest for pandaboard at googlegroups by TI representative S. Jan:

"Yes, this is expected.

Recent Ubuntu and Linaro kernels are based on 3.0 and they do not have smartreflex support enabled. Their voltage is not optimized so they are configured to run at a reduced operating point to avoid heating (so default speed shall be 800MHz for 4430). They do not support dvfs, so you can't change that at run-time.

The kernel delivered with 10.10 (2.6.35 based) used to have smartreflex and dvfs, and could scale to 1GHz.

We are working on a kernel upgrade that can run on top of 11.10, based on 3.1 kernel, that integrates smartreflex and dvfs, and can scale up to max speed."

That is the solution to the mistery!

Pointclouds (PCL) test with Kinect

2011-11-22T01:25:00.000-08:00

I want to test the PCL performance for realtime 3D visualization and processing of data captured from a Kinect.

The installation of the library is straightforward under Ubuntu. After playing a while with the examples provided, I started to apply some filters.

First, a voxel-grid to downsample the raw cloud form 302700 to about 60000, then a crop-box to exclude the farthest points.

The resulting cloud had about 4000 points, corresponding to a person's upper body.

Then I applied the Fast triangulation for unordered point clouds included in PCL. The result is quite good and the performance is not as bad as it looks, as the machine was my atom netbook. Also, the algorithm is for unordered clouds, that doesn't take the advantage of the Kinects x-y ordered point grid.

3d point cloud blob tracking & targeting with kinect and a robotic pan-tilt turret

2011-10-07T05:36:00.000-07:00

After exploring the possibilities of using opencv 2d algorithms for 3d tracking with 3d depth buffer images, we decided to work directly with the 3d point cloud data to perform a better and more versatile 3d tracking.

One of the most interesting open source resources available for 3d point cloud handling is the PointCloud (PCL) project. The aim of this initiative is to provide a robust and easy way of analysing 3d world data, including goals like 3d object recognition, surface features estimation, etc.

Before getting deeply into the use of PCL (which allows not only an efficient handling of the 3D data, but also interfacing directly with 3D sensors as the kinect), we decided to implement from scratch one of the blob parsing algorithms already available in PCL and explained in the PCL documentation (http://pointclouds.org/documentation/tutorials/cluster_extraction.php).

The algorithm is an Euclidean Cluster Extraction. Basically, identifying sets of point that are within a given 3d range one from its neighbour, equivalent to adjacent pixels of the same colour in 2d.

The advantage of making a custom implementation is that we know exactly where to look for adjacent points: they come already next to each other as 2d pixels in the depth buffer image. This allows us also to keep using for now all the image based noise filtering and background subtraction, instead of moving everything to the PCL way. Another useful thing of working directly with the 3d point cloud data, is that we can develop a more user friendly interface, now in an opengl 3d virtual world, to see what is occurring with the 3d blob detection and localization. A further step will be to allow the setup to be done via this opengl interface, like in most 3d modelling software.

Here is a clip of the system up and running as we have it now, with the pan-tilt turret pointing to the highest point of the nearest blob. The turret and the kinect sensor are both represented as 3d objects in the virtual world according to the positions and rotations measured from the real scene.

Taller en vida 75º Color

2011-09-04T20:28:00.000-07:00

The Ramdom Lab has collaborated with Malotaprojects in development of an interactive application that lets you play with your artwork using a sensor kinect.
The piece was presented at the Taller en vida de 75º Color in Mexico City on 3rd of September.

Samuel Beckett's QUAD play robotic performance

2011-08-20T07:25:00.000-07:00

The lab had the honor to be working in the robotic version of Beckett's Quad play. The project, by the STUDIO for Creative Inquiry (SCI) at CMU, is an original concept by Matt Gray (director of the play), and was produced by Golan Levin, in charge of the SCI.

The Random Lab's task was to develop the Computer Vision Control System and design the radio wireless communication system between the CVCS and the iRobot Create robots (Roomba).

Matt Gray soldering some pins to interface the robots.

There were a few challenges that came across during the development. Once we managed to communicate to the robots with an arduino via it's serial port, the first test were based on the scripting language. As the play consists of a long series of pattern movement repetition, after a few rounds each robot started to accumulate the small deviations and drift significantly, until each one ended up in different corners of the room, or collapsing one another, in a rather beautiful dance.

To achieve the goal of making the robots follow the pattern, Golan, expert in computer vision, helped us in the development of a color tracking system that would be able to detect and track the robots' positions and orientation, and send the appropriate signals to each one in order to me them along the proper trajectory and correct any deviation in real time.

Work in progress at the STUDIO for Creative Inquiry. Photo by Riley Harmon.

After solving several problems with the xbee radio wireless communication, and tuning the system, the result was accurate enough to perform the play.

Here is a raw footage fragment of the performance in the Rauh Theater, Purner Hall, Carnegie Mellon (follow the link to the video´s Vimeo page for more info and complete credit list):

Malota´s interactives puppets

2011-07-31T20:11:00.000-07:00

The Random Lab is collaborating with Malota Projects in the development of an interactive project. We are using Malota´s character to animate with Animata and can be moved by the user in real time. OSCeleton sent to Animata the position of the skeleton joints detected by a sensor kinect.

Pandaboard face detection performance test

2011-07-11T06:19:00.000-07:00

We did a simple performance test of OpenCV's haar finder face detection with Pandaboard on Ubuntu and openFramewroks.

The Ubuntu is: 2.6.35-903-omap4 #21-Ubuntu

Compiled with Code::Blocks and openFrameworks with the ofxCvHaarFinder addon.

The source of the test can be downloaded here.

Here is a video of the screen with webcam capture resolution 320x240.

And here with webcam capture resolution 160x120.

[EDIT]

Here is a test capturing at 160x120, but with the haar finder set up for a minimum blob size of 16x12px (the bigger minimum blob size, the faster the detection, with the loss of detection for small/distant faces).
The code is rendering the result via SDL on the framebuffer. The gdm was shut down before running the application.

Heatsink performance analysis on Pandaboard

2011-06-29T08:24:00.000-07:00

Within our research collaboration with Aectir we made an application to select the % CPU load an monitor the temperature of the Pandaboard's OMAP4430.

We tested the board under several CPU loads and setups. The preliminar results:

SETUP	aprox. CPU usage (%)	max. internal sensor temp (C)	max. external IR temp (C)	aprox. current (mA)
No heatsink	20	61	67.3	840
	50	69	74.4	920
	70	72	77.7	970
	100	76	82.5	1030
One heatsink (15x15x15mm)	20	54	57.8	840
	50	57	62.0	920
	70	61	64.2	970
	100	63	67.4	1030
2 heatsinks (one on each side)	100	56	60.8	1030

Here you can watch a speeded-up video of the analysis:

We also tested a bigger heatsink (30x30x15mm) that keeps the temperature in the same range as the two-heasink setup, stable at about 56 C.

Arduino Roomba Wishield

2011-06-28T13:47:00.000-07:00

Last week we experimented with the iRobot Create Open Interface platform as part of our collaboration with Golan Levin and his GML to Roomba project (see other GML related projects), at the CMU STUDIO for Creative Inquiry, Pittsburgh, with the following people involved:

Golan Levin: GML parsing; project management.
David Sanz Kirbis: Arduino development and wireless protocols.
Paul Miller: Processing software and robot control.
Evan Roth and Matthew Gray: Instigation.

We had to deal with a Wishield 1.0 board for Arduino, and the library provided by AsyncLabs. In the library's examples, there is a UDP protocol sketch to communicate to the Wishield through the wireless network, but we found a lack of documentation about it. The example comes with a .c file that handles the access to the incoming and outgoing data packets, but there was no access from the arduino sketch itself.

After a couple of modifications of the the library's WiFi class, we added some properties to be able to receive and send data from the Arduino .pde sketch.

The arduino was connected to the robot via the DB-25 cargo bay port. This port delivers TTL serial RX/TX, regulated 5v to power the arduino, and direct access to the battery 14.4v unregulated power for higher voltage devices.

We made a simple test program to let the arduino parse the incoming wifi data commands and send to the robot the ones destined to it. In addition the arduino would detect a specific command to handle the on and off switching of a 14v bulb attached to one of the available digital pins (not used by the Wishield).

For the switching we first put a transistor directly to the arduino's digital pin, but it couldn't handle the drained current, so the board poweref off to protect itself. To solve this we put a resistor that kept the current below the maximum of the pin, but enough to trigger the transistor.

Here is a fritzing schematic of the connections and parts used (the drawing doesn't show the Wishield connected to the arduino):

1 NPN transistor TIP3055
1 resistor 160 ohm
1 bulb rated 14.4v 200mA

To controll the path of the robot for the lightpainting, Paul Miller made a Processing sketch that reads the GML data parsed by Golan Levin's code and sends the proper commands via UDP to move the robot.

Here is a link to the ligthpainting video and further explanation by Golan.

Symet+micro camera

2011-06-19T08:30:00.000-07:00

After some time modifying the design and testing with various combinations of components, we present our version of symet with built-in micro camera. This experimental video device is a solar junkbot to call serendipity in the video shots. Subliminal video stream is going to be analyzed by OpenCV to extract meaningful images and make new assemblies.
Thanks to the help of Julio Zaldivar from robotics area of Centro Multimedia

Below are 2 videos, the first documented movement symet and the second reflects the micro video camera recorded by the built-in.

Below are a video of the robotic Julio advice.

GPSerendipity Going to Teotihuacan

The following videos documents the use of the object pix_opencv_of_lk for extraction of images captured video stream. Pix_opencv_of_lk calculates the optical flow, trying to correlate the movement of blocks from a frame to next one, this algorithm is known as Block Matching. It uses a variable size of blocks that can be adjusted. it uses the Lucas/Kanade algorithm for the identification and tracking of points.

In the following videos we can see the result of analysis of OpenCV is used to produce one-second pause in the video stream in search of the "photographic serendipity."

Pandaboard thermographic analysis

2011-04-03T00:00:00.000-07:00

Thanks to the help of Rafael Royo from Aectir, we had the opportunity to make a thermal recording of the Pandaboard.
The board gets quite hot and the Omap4430 reaches about 80ºC at heavy load with a room temperature of 20ºC. The processor's thermal specs are: TJmax = 105°C and TBmax = 85°C.

Every change in the CPU load showed up almost inmediatly on the thermal camera. We tracked the heat of the hotspots to see the evolution graphically.

Here is a video of the heating up process.

One surprising thing we noticed is that after shutting down the system, the processor didn't cool, and stayed warm until we unplugged the board from the power supply. This issue may affect a system based on batteries, causing some draining.
This can be seen in this video of the thermography of a small pasive heatsink attached to the processor.

Here is a 20 min. long video of the entire heating up process of the board

Pandaboard is hot!

2011-03-31T12:57:00.000-07:00

The Pandaboard's Omap 4430 is designed to work in small devices without heatsink. However, we noticed it gets really hot in a warm environment.

We are trying to keep our board in safe temperature ranges. It doesn't have a PC-like chipset with temperature sensors, so monitoring tools like lmsensors don't seem to work.

We made an experiment to attach a heatsink in a non permanent way (avoiding the thermal epoxy alternative).
Here are some pics of our setup:

We divided a low airspeed heatsink in 4 small pieces

Some good quality thermal compound


And a few extra pieces to keep it in place

The sink still gets very hot, so we are considering putting a whole heatsink instead of 1/4 of it.

Pandaboard + openFrameworks / Processing / PureData

2011-03-20T12:11:00.000-07:00

After more than a month waiting the Pandaboard we ordered arrived. We are testing the performance of the board for development with GNU/Linux. The distribution is a Ubuntu Maverick.

The performance is not very promising, specially the SD card interface to the Omap4 processor.

We managed to setup the three environments we use to develop: openFrameworks, Processing and PureData. With oF the board reached 4-5 fps analyzyng blobs from a webcam at 320x240@30; however, without rendering the images on screen, the same analysis can reach 17fps.

Here is a testimonial video:

Kinect OpenNI-NITE ofxOpenNI Skeleton with openFrameworks on Linux

2011-03-04T04:31:00.000-08:00

At last, after some setting up we got the Nite library accesible from openFrameworks on linux thanxs to the work of the independent community.

To make it work, we followed closely these instructions to install the OpenNI libs, Primesense's Sensor drivers, and the NITE library.

We got some of the "InitFromXml failed: Can't create any node of the requested type!" error reported by other, but it was solved after rebooting, deleting the three folders (OpenNI, Sensors and NITE), and repeating everithing.

We used as wrapper Alohas's "ofxONI_notYetAddon" with some changes. We also had to change the name of several "Status" variables to "theStatus" on the XnStatus.h file as follows:


XN_C_API const XnChar* xnGetStatusString(const XnStatus theStatus);

XN_C_API const XnChar* xnGetStatusName(const XnStatus theStatus);

XN_C_API void xnPrintError(const XnStatus theStatus, const XnChar* csUserMessage);

Download the modified codeblocks linux project for of_0062 here. You should uncompress the file in your of_0062/apps/addonsExamples folder.

There are some other oF addon initiatives (by roxlu, Kyle McDonald, HalfDanJ, etc.) that will probably be included in oF07, just google "ofxopenni".

Here is a short video of our first test:

Sorry for the quality!

kinect and puredata_opencv

2011-02-25T07:51:00.000-08:00

We used the sensor Kinect as imput for detection using OpenCV algorithms for pure data designed by Yves Degoyon and Lluis Gomez i Bigorda.

Kinect with Processing on Ubuntu Linux

2011-02-21T09:54:00.000-08:00

At last it seems to work!

We have been trying to make Kinect accessible from Processing with the help of OpenKinect's Java JNI Wrapper tutorial, Nikolaus Gradwohl's tutorial and some hints at this thread.

UPDATED 2nd June 2011: Just in case, here is the compiled processing openkinect library , and here the modified source and build file of Shiffman's wrapper for Ubuntu Lucid 10.04, 2.6.32-28 (tested with java-6-sun-1.6.0.24 and OpenKinect-libfreenect-4a159f8).

Weekend at Medialab Prado with Golan Levin's Kinect workshop

2011-02-21T07:34:00.000-08:00

We spent last weekend at Medialab Prado enjoying a workshop by Golan Levin.

He explained some of his most renown pieces in an interesting conference. You can watch the video at Medialab Prado site. Golan also showed some of the last creations of the independent community taking advantage of this technology.

The workshop was with OSX, but we managed to make things work with linux too. We wanted to post how to, but someone already did nice tutorials to install the libfreenect library and then to setup Kinect for developing under Ubuntu.
It was a rainy weekend that led us to stay inside and enjoy Madrid's nice food...

Realtime mapping video projection experiments (2)

2011-02-16T11:48:00.000-08:00

Second experiment to realtime mapping video projection over a physical object in movement. Currently testing the object "pdp_artkp": ARToolKitPlus object for pd, developed by Yves Degoyon. Imaging performed on a white base, as the marker is on the back of the stand, hidden from the user but visible to the camera.

Custom size embedded Vimeo videos on Wordpress

2011-01-18T03:06:00.000-08:00

I'm keeping a research diary of my thesis project in the Wordpress blog site of the university: cvcinema.blogs.upv.es

There is a tutorial showing how to easily embed vimeo videos on Wordpress: http://en.support.wordpress.com/videos/vimeo/ . However, in my blog the videos where always shown in 4:3 aspect with letterbox.

As I keep posting with embedded Vimeo videos in rare aspect ratios, I wanted to manually set the size of the videos shown in the blog.

I looked for some info about it without success. The only info I found about the subject told to put the size this way:

[vimeo vimeo_link w=desired_width&h=desired_height]

But this didn't work.

Then I just tryed to write it as it would be html inside the brackets like this:

[vimeo vimeo_link width=desired_width height=desired_height]

For example:

[vimeo http://vimeo.com/18908525 width="480" height="135"]

And it worked!!!

Have a look here to see the results.

TheRandomLab swiss army knife

2010-12-12T03:39:00.000-08:00

Victorinox knife with the logo engraved on the handle and key holder of Friends With You.

Working with OpenCV and Processing under linux

2010-11-29T10:46:00.000-08:00

Just a tip for everyone having trouble when working with the OpenCV library for Processing.

After installing OpenCV in a recent Ubuntu distro, following the instructions, you might get an error like:

UnsatisfiedLinkError: hypermedia.video.OpenCV.capture(III) ...

When you try to execute the Opencv library examples in Processing.

The solution is easy...

This is because the library is looking for the wrong OpenCV version.

The solution is to make simbolic links to the instaled version files in the folder /usr/lib:


$ cd /usr/lib
$ sudo ln -s libcxcore.so.4 libcxcore.so.1
$ sudo ln -s libcv.so.4 libcv.so.1
$ sudo ln -s libhighgui.so.4 libhighgui.so.1
$ sudo ln -s libcvaux.so.4 libcvaux.so.1
$ sudo ln -s libml.so.4 libml.so.1

Hope it helps!

Drawing frames

2010-11-12T12:20:00.000-08:00

Audiovisual installation in which the robotic arm of "Random" draw the silhouettes from the captured frames of a video camera.

Some drafts made for the design of the installation:

Android meets with arduino

2010-10-14T05:45:00.000-07:00

Early tests to communicate Android with Arduino to control servos.
Establishing wireless communication using the OSC protocol sends data from mobile sensors by pduino to pure data that communicates with Arduino to control the servo.

We are using andOSC application for Android.

The Drawing Robot sketching a smiley

2010-10-08T14:53:00.001-07:00

We are currently testing the possibilities of a robot arm we built. As it is a prototype, the accuracy still needs to be improved.

The key of the arm design is to translate the weight of the motors as next as possible to the base, in order to lighten the arm, thereby reducing the inertia and the stress of the motors.

The control is done with Processing via an Arduino and a selfmade version of Renbotics multiplexing shield and the help of all the info provided by Oleg at CircuitsAtHome.

This is a test, plotting a svg file. The figure is upside down because in the screen the measures start from the top, and in the real world the robot measures start at the base.

Realtime mapping video projection experiments

2010-09-09T07:54:00.000-07:00

Early experiments to realtime mapping video projection over a physical object in movement.

We used pix_artoolkit object from Gem library.

The robotic arm interacts with sound

2010-08-05T14:45:00.000-07:00

TheRandomLab experiments presented publicly during IN-BETWEEN project in Delphi, Greece.

The robotic arm was programmed to interact with the sound environment, generating unique choreography. Another issue was the mapping of video projected onto the fan wearing the robot.

Axiomtek PicoITX embedded board - making an enclosure case

2010-07-07T11:53:00.000-07:00

We found a good deal in ebay and bought an Axiomtek Pico820 board to use it for robotics projects. This board is a full Atom PC with 5W power consumption at 5v.

The first problem we had is to get the graphic hardware acceleration to work under linux, as it affects the overall performance of the system. The problematic chipset is the US15W aka poulsbo aka GMA500. Although we tried the community developed drivers, we didn't manage to make them work properly. But thanks to the people at ubuntuforums we found a compatible distro made by the developers of the Fit-PC embedded board, a board with much more support than Axiomtek's one (these never answered our emails). The only other distro that worked out of the box is the Gentoo based Pixielive.
To find out more Read "How To Kick Your Friends in the Face: GMA500" by Shawn Powers and the Intel "apology" "Blaming Intel for how the world is" by Henry Kingman.

We also wanted to have an enclosure for the board in order to work safely on the desk, so we made what might probably be the smallest intel atom nettop in the world, measuring just 104x76x32mm.

Random has brain & wheels

2010-05-16T16:19:00.000-07:00

Random, our pet, already have brain and motorized wheelchairs. We used the RCX 2.0 & Lego bricks.

We have programmed the "mixed reality" with gem.pix_artoolkit.

Random has a light sensor that let him follows the line of initial stroke of the ground, approximately.

Portable P48 microphone preamplifier

2010-01-15T07:47:00.000-08:00

Once every while, I like to have a look at second hand shops searching for any nice deal. In one of these visitsI bought a Sennheiser MKH-416 P48 professional shot gun microphone for 275€. But then I had the problem of how to interface it to my videocamera.
Phantom powered microphones need some voltage to work. The P48 standard defines how to feed these mics with 48volt through the XLR connector. Of course, I could buy one of the professional fiels Shure FP23 or Sound Devices Mic Pre, but I didn't want to spend that money. There are some other alternatives like the Juicedlink JL-CX231 or the Beacktek DXA-2T, but also quite a spend.

The other opion was to build an adapter myself.

After some research about the P48 standard and some DIY, I decided to put together four circuits I found:

- The Low Noise Balanced Microphone Preamp by Phil Allison

- The 48V Phantom Feed Supply for Microphones by Rod Elliott.

- The DC-DC step up 9v to 48v step-up converter by Thomas Schaerer.

- The MAX1044 / ICL7660 Negative Voltage Converter (see application notes), needed to get the -9v for the preamp circuit.

The result is a transformerless cheap 9v portable single mic preamplifier. It is important to remark that it is transformerless. I looked for the proper audio transformers (Jensen, etc.)in order to insulate the mic and the camera, but the prices are too high for this project.

This is my arrangement of the component in standard prototyping boards:

This is a picture of the circuits in a standard box: