## LitSimulate

LitSimulate is a simulator which simulates what LitSpin will display. We developed the first versions with PyOpenGL and PyGame.

## Image Format

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). Just below an example with r = 8.

## Examples of simulation

We made some simulations with r=10, h=10 and n=100

## Limitations

For now, we simulate an 8-bits-by-colour display and not a 9-bits-by-colour one. This is just because it is easier to create an 8-bits image on the internet rather than 8 bits. However, it will be very simple to change LitSimulate into a 9-bit simulator.

The main issue is a problem of memory. Indeed, the RAM is constantly filling up until the PC is completely blocked. So we can only use this first version of the simulator for a few seconds. Moreover, we can’t simulate with our real values of r, h and n because it takes too much memory to display the results. To deal with this issue there will be several steps:

1. We will try to fix it by keeping Pygame et PyOpenGL
2. If we can’t, we will try without PyGame and only use PyOpenGL (because PyGame is used to initialize OpenGL display). Maybe we would directly go to step 3
3. If it is still too slow, we will make the simulator in C++
4. If it is still too slow or too complicated, we will try the Point Cloud Library for C++

## Ah, yes. Stereoscopic vision.

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. To understand the different configurations, please refer to this article.

As you can see, the dispositions that seem to benefit the most of stereoscopic vision are modulo forests, particularly the ones where the repartition of PCBs seems the most uniform. The parallax effect is all the stongest when PCBs hiding each other are far away in the axis of vision. Modulo forests with k = 3 and 11 seem to be good candidates as the front portion of the cylinder is (almost) complete in both cases.

## Choosing a shape

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. There came the stairs idea:

After modelling this idea in python we get:

As you can see, there are a lot of deadzones, particularly in the central viewing axis.

Imagine a configuration with one vertical PCB with LEDs on both sides, facing the radial direction. Wait, don’t. I modeled it so you don’t have to :

This creates a 2D cylindrical POV display, with dark zones on the sides, which is in our opinion much better than a center dark zone. To create a 3D POV display, we “only” need to add concentric cylinders. The question is now: how serious is the problem of PCBs hiding each other and how to avoid it.

## Spiraling down the rabbit hole

The idea of spirals seems natural. PCBs can laid out with an angular offset when compared to the adjacent PCB. For balancing reason, we alternate the PCBs with a central symmetry in order to create a double spiral.

The major issue is that the adjacent PCBs tend to hide each other in large portions of space, due to the fact that they are aligned and closed to each other. We can also notice that the resulting shape is far from being symmetric (which is expected with a spiral).

## Some arithmetics

In order to shake things up a little more, we can keep the idea of a constant angular offset, but with a twist.

Let us take a circle split in n angular positions. If you choose a starting point and then jump from position to positions by skipping k positions, you will reach all positions if, and only if, n and k are coprime. This gives us a more evenly spread disposition.

For the sake of convenience, and because it is a nice name, we shall name this configuration “modulo forest”.

Deadzones tend to be much more spread out, which seems more acceptable. Further investigation has to be done in order to choose a definitive shape.

## Design Crisis

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. The red dot is the user point of view and the green dot is the rotation center.