I created an animation that displays flags of European countries on the tree, in alphabetical order. Each display was created by essentially overlaying a flag on the Y-Z plane, and setting each light's colours to the colour of the closest flag image pixel. The depth of the tree, i.e. the lights positions in the x-dimension, had no influence. Therefore, the animation is best viewed perpendicular to the Y-Z plane (so down the positive x-axis). As the tree is not rectangular, the top-left and top-right sections of the flags are not displayed on the tree. Unsurprisingly, flags with detailed imagery don't come into their own due to the low resolution, but most the more "simple" flags are quite easy to recognise. I started out creating an animation for all of the world's flags, but the CSV file became too large for GitHub.

The scripts used in generating the CSV files can be found here: https://github.com/LuukvanKeeken/Country-Flags-Christmas-Tree. There it can also be seen which flags were used, and the order they appear in in the animation, by looking in the images_europe folder.

These examples flash the words "Merry Xmas" in morse code.

The easiest to read as Morse code is morse-xmas-white.csv which blinks all of the lights together, coloured white. However this is probably also the most power hungry as I think last year you had some problems turning all the lights to full brightness together.

I am also not sure of the hardware requirements. I have been basing my timings off of 60fps, but I don't know if the Raspberry Pi can drive at this frequency. Slower is probably fine, faster might be a problem for epilectics! (seriously - consider that a warning).

The other 2 files are variations morse-xmas-random.csv randomly colors all of the lights each frame. This makes it harder to read the Morse.

And morse-xmas-twinkle.csv gives each light a random colour and offsets the animation randomly per light. This is probably the most power friendly version, but also makes it look like random noise rather than being able to see the message.

I created these using P5 - a Javascript version of Processing using their online editor. You can see the original code that generated the animation here:

https://editor.p5js.org/rendermaniac/sketches/QmKh_KZMk

I also verified that I could read all of these files using this Sketch. It also works with the MIT examples:

https://editor.p5js.org/rendermaniac/sketches/yw-tkWRDPy

I will probably post more details on my STEM / rockets facebook page here soon: https://www.facebook.com/pihighrockets/

Thanks for putting all of this together - it's an interesting challenge!

This example is a simple hue colour change based on the distance from the centre of the Christmas tree. This is animated by adding the frame number as an offset.

Note that I just exported 500 frames - I did not bother to make it loopable.

Created using this code:

https://editor.p5js.org/rendermaniac/sketches/OLLuV7vm1

Thanks

Simon https://www.facebook.com/pihighrockets/

Based on the famous touhou inspired black and white video (https://www.youtube.com/watch?v=FtutLA63Cp8), compared the coordinates of the LEDs to the pixels in the video to replicate it frame by frame. This was made trough a simple script i made in java to convert the images to csv frames for the tree.

The full version didn't fit, as it was larger than the 25 GB permitted on GitHub, so a trimmed version was uploaded. The full version can be found here: https://drive.google.com/file/d/1Zy1kz8YrNmLj9zM24qycitdXuQlJFZLi/view

I am seeing others come up with similar projects for visualizing/simulating tree light sequences. Should we separate these into their own README section, or directory, or is the "Further Work" section fine?

Apart from that, I'm also waiting for others to upload their sequences to have more random sequences to show since currently I'm only linking to a single one.

An online GIFT-Simulator that runs independent of the programming language used: https://leukipp.github.io/xmastree2021/simulator/

A procedural tree is rendered and light coordinates/animation frames can be loaded from url`s or local csv files. GitHub pages can be used to host the static scripts, as everything runs on the client side.

I really hope I didn't miss it in the video or these repos, but @thatmattparker what direction(s) will you be filming our visualizations from? I have a big idea, but will not make sense unless viewed from a specific direction.

You mention in the video that I believe the XZ plane is in frame currently, but will that still be so during the video?

Thanks!

This is just running Perlin noise through the tree and thresholding the result.

I'm not quite sure if I should leave it like this or make it more complex?

https://editor.p5js.org/rendermaniac/sketches/4v1SoYlF1

Hi, saw this YouTube comment from suncrasher, which hasn't been addressed yet and I was wondering too:

Question regarding brightness: Last time you recommended to not go above (50, 50, 50) for large amounts of LEDs because (a) that was bright enough already and (b) your power supplies didn't manage more. Does that still apply?

Hi, I am looking forward to this year's video.

Over the last couple of days I have written a simulator and some utility code to help make users code a bunch simpler than last year.

Are these things you would be interested including so that others can use them?

They will probably need modifying a little to work with the CSV format and if anything else has changed.

Simulator: https://github.com/gentlegiantJGC/xmastree2020/blob/main/simulator.py

Utility code to import either the real tree or fall back to the simulator if it does not exist; a function to set up the LED interface that was imported and a context manager to control the frame time. https://github.com/gentlegiantJGC/xmastree2020/blob/main/matts_tree_helpers.py

I also added a minimal template using this system https://github.com/gentlegiantJGC/xmastree2020/blob/main/template.py

The pull requests to this repo will be used in Matt's video, correct? There was a lot of activity and questions about frame rate, etc, but now it has been very quiet.

Lights are grouped into red and green lights. If a light's position was determined to be probably correct it glows green, positions of other lights were "corrected" to a position that may or may not be closer to the actual position in the real tree. These other lights show red and their intensity increases and decreases as two sine waves move through the string of lights.

I've made a simulation of what somewhat resembles Game of Life in 3D.

Lights will have different amount of neighbors - based on a fixed distance. State (alive/dead) of a light is calculated based on the portion of alive neighbors.

This has some interesting properties, some areas go into loops; they repeat the same effect until another pattern intrudes it. I've no clue how this will look on the real tree, though.

Currently working on making lights that were just "born" illuminate in a different color. -> Draft Request for now.

I've followed the discussion about brightness. For this, I just assumed full brightness for all active lights. Around 120-180 are active simultaneously. If that is too much, let me know! Might share the code, but gotta clean it up first.

Thanks for reading.

All animations designed for 30fps.

• antarctic_solar_eclipse.csv
  • This is pretty much what the December 4 solar eclipse would have looked like on a sunny day (~100x speed).
  • It only makes sense to look on the x-z plane.
• carousel_gallopers.csv
  • Four colored carousel spinning clockwise.
  • Two gallopers spinning counter clockwise.
• rocket_launch.csv
  • Countdown followed by a rocket launch.
  • Experimental animation to test SVG to GIFT conversion.

Coded with GIFT-Development (#32), source code and running examples available here:

• antarctic_solar_eclipse.ipynb
• carousel_gallopers.ipynb
• rocket_launch.ipynb