Following the Phyllo demonstration video we recently shot, Xavier and I started thinking about the impact of the flash frequency on the Phyllo effects. The first step being to list the effects we want.
There is a variety of effects that depend on the flash frequency; they all boil down to what we’ll call the “apparent rotation speed” of the Phyllo. Here’s a well-rounded selection of effects to give you a better idea of this:
Vertical aging / de-aging
We could define this kind of effect as having an “apparent speed of zero”: the petals only age or de-age along a top-down line, but don’t move left or right spinwise.… Read more
These past few days I’ve been working on the animation generator. Here’s a result:
I wrote a generator in C (which will later be the code used on the main board) which has a generate_frame function which will generate the next frame of a procedural animation. The generate_frame function can be called an arbitrary amount of times.
The code can export the frame to a file, which is then read by my animation simulator script I wrote for blender.
The simulator takes a few secondes to read the frames (5 secondes for a 500 frames animation for instance), and can then display the animation in real time (same as in the gif)
The simulator can also render high quality realistic animations as the one you can see in our project presentation , but even a small animation will take a day of rendering
Here’s all the concepts / techniques I have been working on right now (most of them are already implemented) which the generator uses:
The virtual petals are the petals you appear to be seeing go down (age) on our phyllo animations.… Read more
Good news today. I completed the testbench connecting the synchronizer and led band controller modules.
This global testbench allowed me to discover and fix new bugs, mainly in the synchonizer module. Everything seems to work as intended now.
The test consists in writing a random frame of data on the led band controller and checking if the simulated driver contains the proper data at the time it should be displayed.
I also tried to change the multiplexing groups, which is an important parameter we will have to set later, and everything still works. I only hope we won’t have too many surprises on the finished product.… Read more
LitSimulate is a simulator which simulates what LitSpin will display. We developed the first versions with PyOpenGL and PyGame.
Each 3D image is represented by a classical image. If we note r the radial resolution (total number of columns), h the number of LEDs by column and n the number of steps by rotation, our image dimensions are rh x n. In our case r=20, h=32 and n=128. So we have 640×128. One line represents the n points one led will display. And each block of h lines represents the 360° image of a column from the outermost to the innermost (from 1 to r).… Read more
This is a follow-up to my previous article, in which we explored the choice of PCB placement in order to get an optimal visibility.
My previous analysis only covered the case of a punctual point of view. However, most people have two eyes, which provide a double point of view and could increase our coverage of space. It is to be pointed out that a point of space seen by one eye does not provide depth information to the brain, however let us assume that our image perception is smart enough to overcome this limit.
In the following simulation, we used a typical eye distance of 6 cm.… Read more
As stated in this previous post, we have to compare different PCB dispositions to avoid blind spots. We soon came to realization that we would not be able to get rid of blind spots with our design, but it is possible to study the different ideas we came up with in order to mitigate this issue.
That’s why we created a python program that can simulate :
blind spots created by PCBs hiding each other
the variations of brightness due to the fact that LEDs can be seen at an angle (which is what created the dark center zone in CyL3D, which we are trying to get rid of)
Stairs : an iteration over CyL3D’s design
To avoid the issue of a dark zone due to all LEDs facing the observer at an angle in the center zone, an idea was to make sure that all LEDs were not facing the same direction.… Read more
We discovered our first model contained a lot of issues. The outermost PCB often hide PCB behind them as you can see below. This results in some voxels being invisible. So we decided to create a simulator on Python to find the invisible areas. We will use it to determine the optimal configuration for our display. This configuration has several parameters such as the number of PCB, their position and the arrangement of the LED on one or both sides.
This a an example with 8 double-sided PCB in double spiral and 100 angular resolution. The blue dots are the visible voxels.… Read more