Daily effects

[Anders-Holst]

Of course you can not have the same pattern on your lights several days in a row - what will the neighbors think: That you are lazy, or that you don't really care about your lights? On the other hand, you should not switch more often than once a day, to make sure that all the neighbors have a chance to see and admire it. 😉

I intend to publish here a kind of "advent calendar", from December 1 to December 24, of daily effects for your lights that you can produce with this package. Some are straightforward and you can find them in the code yourself, whereas others are variants that require some further lines of code. My focus is on beautiful effects, not just (tastelessly) flashy. But the taste can of course vary.

Some effects will be similar to what you can achieve with the app but not exactly. Most will however be unique and impossible or very difficult to mimic with the app. Either way, see it as an example collection of what you can do when taking full programmatic control over your lights!

[Anders-Holst]

Daily effect, December 1 - Twinkling stars

Here is the first daily effect. A simple effect to start with. It is similar to the Star effect in the Twinkly app. However, in the app all stars have the same purple-tinted sharp white color ("Twinkly-white"). Here instead the stars have different color temperatures, from warm, through neutral white to cold - just like real stars.

Make sure you have installed xled_plus somewhere where python can find it. Connect your Twinkly to the network. Start a python prompt and input the following three lines:

from xled_plus.samples.sample_setup import *
ctr = setup_control()
SparkleStars(ctr).launch_movie()

[Anders-Holst]

Daily effect, December 2 - Water

Bluish, greenish and white, like glittering water in a pond.

Similar to what can be achieved by the Glow effect in the app, but colors change into each other instead of just pulsing, and the transition to the first frame is smooth, rather than with that annoying glitch you get with the effect in the app.

Input the following to python:

from xled_plus.samples.sample_setup import *
ctr = setup_control()
Water(ctr).launch_movie()

Alternatively, if you have upgraded to the latest version of xled_plus today, you can launch it with:
python -m xled_plus.samples.day2

[sgtsilver]

I really like the colors of this effect but it's a tad too hectic for me - is there a way to slow it down?

[Anders-Holst]

There are several ways, depending on how deep into the python code you prefer to go.

The easiest way is to modify the lines in day2.py slightly, so that the last line, Water(ctr).launch_movie() is replaced by three lines:

eff = Water(ctr)
eff.preferred_fps = 8
eff.launch_movie()

This changes the default 20 frames per second to just 8 frames per second, making it slower.

Another way is to note that Water is an effect defined in "xled_plus/effects.py", as a special case of GlowEffect. There are several more examples of glow effects with different color schemes in that file. You can create your own subclass of GlowEffect, copying the colors from Water if you like. (When I started writing these effects I did not know I would release the code, so the meaning of the other parameters might be considered somewhat obscure but I will try to explain.) The other parameters are: bend which affects how much more weight there are on early colors in the list, making later colors only occur occasionally. Typically a number between 1 and 3 where 1 means equal probability whereas 3 is a heavy preference for early colors. cycles is a list of two numbers, which specifies the range (inclusive) of cycle length to use for the leds. That is, not to make everything appear to pulsate synchronously, different leds have different cycle lengths of switching from one color to the next. [2,4] would be quite rapid changes in 2, 3 or 4 frames, whereas [6,10] would be much smoother changes. Finally, fps is the frames per second. For best effect, both cycles and fps can be modified to make a calmer appearance. You can experiment with these parameters.

By the way, the colors are in HSL format (hue in range [0,1], saturation in range [0,1], and lightness in range [-1,1]) and is most conveniently produced by using "xed_plus/xled_colorpicker" #5.

[DanDixon]

Oh wow, this is very helpful. Thanks for explaining bend and cycles.

The color order for hue in the HSL model used (blue = 0, it's not red) is explained in this comment lower in this thread:
#2 (reply in thread)

[vejbuch2]

Hey. Hey,
Nice work, I'm glad there's someone in the community working on it :)
I'm looking forward to more animations, especially something like the one for halloween <3

Thanks,
Vejbuch

[Anders-Holst]

Thanks for the encouragement!
Many of the effects here in the beginning are of the "random position" kind that are independent of any physical layout. There will be more advanced examples soon, using the 2D-layout of the leds.
I am not familiar with the Halloween animation myself. I suppose it is one of those "movie clips" that can be downloaded from the web by the app? The idea has surfaced that we should be able to convert any simple gif animation to a led movie, but it is not yet implemented.

Anders

[vejbuch2]

Hi,
Yeah, it's a few animations right on halloween from the app on mobile.

I read about this gif on xled and I am extremely horny :D please if you will inform me about the alpha/beta test, I will be happy to join the testing.

Thank you,
Vejbuch

[Anders-Holst]

Hi, for your info, I have just published a first attempt at uploading pictures on the lights, #9 . Try it out and see how it works!

Anders

[Anders-Holst]

Daily effect, December 3 - Gold

Similar to the Sparkles effect in the app, of bright flashing leds against a solid background. This example is meant to mimic the "metallic luster" effects of AWW leds, i.e glittering gold.

from xled_plus.samples.sample_setup import *
ctr = setup_control()
Gold(ctr).launch_movie()

[Anders-Holst]

Daily effect, December 4 - Tinted white gradient

Slowly changing gradient between two complementary light colors, such that the middle stays white and the colors above and below traverses the spectrum on opposite sides.

This effect uses the physical layout of the leds. It only uses one coordinate though (y-axis), so it should work for 2D, 3D, or linear layouts. (Older firmware do not store the layout on the leds. For them the effect will follow the string instead.)

from xled_plus.samples.sample_setup import *

def tintedwhite(t, pos):
    y = pos[1] if len(pos) > 1 else pos[0]
    return hsl_color(t%1.0 if y<0.5 else (t + 0.5)%1.0, 1.0, 1.0 - abs(y - 0.5)*1.6)

ctr = setup_control()
mov = ctr.make_func_movie(120, lambda t: ctr.make_layout_pattern(lambda pos: tintedwhite(t / 120.0, pos)))
ctr.show_movie(mov, 0.5)

Or update to latest version and run
python -m xled_plus.samples.day4

This pattern is not trying to mimic anything from the app. Rather, this is not easy to achieve on the app.
The code may look slightly more complicated, but it is only because it does not use a predefined effect from "effects.py", but uses the primitives from "highcontrol.py" to produce a movie out of patterns out of colored pixels defined by a simple function. Once you have defined a function to produce the color at position pos (with y-coordinate between 0 and 1) and time t (here also between 0 and 1), you can get any effect you like this way.

[Anders-Holst]

Daily effect, December 5 - Dark to light colors

Gradient from dark to light of a slowly changing hue across the spectrum.
Again the physical layout of the leds is used, but only one coordinate, so it should work regardless of layout dimension.
And again, you could not easily get this effect with the app.

from xled_plus.samples.sample_setup import *

def darklight(t, pos):
    light = pos[1] if len(pos) > 1 else pos[0]
    hue = t % 1.0
    return hsl_color(hue, 1.0, light*2 - 1)

ctr = setup_control()
mov = ctr.make_func_movie(120, lambda t: ctr.make_layout_pattern(lambda pos: darklight(t / 120.0, pos)))
ctr.show_movie(mov, 0.66)

The same principle as yesterday is used, just another function to calculate the color.

[Anders-Holst]

Daily effect, December 6 - Flash with mixed colors

Light colors starting with a flash and then fading out.

from xled_plus.samples.sample_setup import *
ctr = setup_control()
SparkleEffect(ctr, 4, random_color_func(light=0.2), flashlight_func(16, 16)).launch_movie()

This one uses a "predefined" class of effects, SparkleEffect, which is highly customizable. The number 4 above is the average number of new "sparks" per time point, then follows a callback function for providing the color of new sparks, and then a callback function for how to evolve that color over time. There are some predefined alternatives, as the ones above, taking different parameters. You will see more alternatives coming days. But if you think there are too many chaotic colors in today's pattern, you can experiment with adding a parameter hue=[starthue, endhue] to random_color_func, where both starthue and endhue are numbers between 0.0 and 1.0, to limit the color range used. And, I almost forgot to say, light can be between -1.0 and 1.0, if you like to play with it.

[Anders-Holst]

Daily effect, December 7 - Breathing selected colors

And then an attempt to mimic a pattern from the app again. This is actually more similar to the Glow effect on the app than the Day 2 example: Each led stays the same hue but varies in brightness. The hues are picked from a fixed list. Differences from Glow on the app are: The color positions are random and not regular, and (just as in the Day 2 example) a smooth transition to the first frame.

You can select other colors by changing the cols list below. A second example is provided, remove the # in front of the line to see it. Colors are given as (hue, saturation, lightness) where hue and saturation has range [0, 1] and lightness range [-1, 1] where -1 is black, +1 is white, and 0 the most colored.

from xled_plus.samples.sample_setup import *
ctr = setup_control()
cols = [(0.375, 1.0, 0.0), (0.58, 1.0, 0.0), (0.375, 1.0, 0.3), (0.29, 1.0, 0.0)]
BreathCP(ctr, cols).launch_movie()

Actually I give you two color variants of this effect. If you don't like the first colors, try the second variant:

from xled_plus.samples.sample_setup import *
ctr = setup_control()
cols = [(0.72, 1.0, 0.15), (0.89, 1.0, 0.0), (0.05, 1.0, 0.05), (0.0, 1.0, 0.8)]
BreathCP(ctr, cols).launch_movie()

And if you didn't like that one either - produce your own: Check out the interactive color picker checked in with today's version of xled_plus: #5
Install it according to the instructions found there. If you start it as below, you can select a number of beautiful colors of your own, and then cut-and-paste the printed HSL-coordinates into the cols list in the code above. Good luck!
python -m xled_plus.xled_colorpicker hsl noset

[Anders-Holst]

Daily effect, December 8 - Flash with pair of slowly changing colors

Sparkling effect, starting with a flash and fading out, just like Day6,
but now with two simultaneous colors, slowly traversing the spectrum.

from xled_plus.samples.sample_setup import *
import random

def bicircularfunc(cycle, dist):
    return lambda ind, tm: hsl_color((tm / float(cycle) + (dist if random.random() < 0.5 else 0.0)) % 1.0, 1.0, 0.0)

ctr = setup_control()
eff = SparkleEffect(ctr, 4, bicircularfunc(240, 0.25), flashlight_func(16, 16))
eff.preferred_frames = 240
eff.launch_movie()

I just had to complicate things a little more - was not happy with the limitations posed by the color generating functions I added in "effects.py", so I wrote a new one, letting two colors traverse the spectrum at fixed distance from each other. You can play with the distance if you like, its the argument that is 0.25 above.

[Anders-Holst]

I forgot yesterday that I had actually added a function in effects.py for doing exactly that - circling several colors at some distances from each other. However, obviously I had never tested it, because it was buggy. If you download the latest version of xled_plus, it should be possible to get the same effect as December 8 a little easier:

from xled_plus.samples.sample_setup import *
ctr = setup_control()
eff = SparkleEffect(ctr, 4, circular_color_func(240, [0.0, 0.25]), flashlight_func(16, 16))
eff.preferred_frames = 240
eff.launch_movie()

[Anders-Holst]

Daily effect, December 9 - Pulselights green

Smoothly pulsing lights with random colors from the green spectrum.

from xled_plus.samples.sample_setup import *
ctr = setup_control()
colfunc = random_color_func(hue=[0.16, 0.38], light=0.0)
nsparks = 0.5 * ctr.num_leds / 60.0
eff = SparkleEffect(ctr, nsparks, colfunc, pulselight_func(24, 12, 24))
eff.preferred_fps = 12
eff.preferred_frames = 180
eff.launch_movie()

Using SparkleEffect just like yesterday and day 6, but now with pulselight_func instead of flashlight_func. Also, adjusting some parameters to make the lights change smoother (frames per second to 12, and increase the number of pulselight steps correspondingly). The calculation of nsparks which was missing before, is to adapt the density of sparks to the size of your led lights (ie number of leds).

[Anders-Holst]

Daily effect, December 10 - Pulselights pink

Same principle as yesterday, but now smoothly pulsing lights with random colors from the pink spectrum.

from xled_plus.samples.sample_setup import *
ctr = setup_control()
colfunc = random_color_func(hue=[0.6, 0.8], light=0.0)
nsparks = 0.5 * ctr.num_leds / 60.0
eff = SparkleEffect(ctr, nsparks, colfunc, pulselight_func(24, 12, 24))
eff.preferred_fps = 12
eff.preferred_frames = 180
eff.launch_movie()

Yes I know - you are quick learners and already knew how to do this one. But then, if you find the color scheme too ghastly, you know that you can play with the parameters in the call to random_color_func above to change it.

hue=[0.6,0.8] specifies the range of colors to draw from. The hues goes from 0.0 to 1.0, in the order:
blue (0.0), cyan (0.125), green (0.25), yellow (0.375), orange (0.5), red (0.625), magenta (0.75), purple (0.875) and back to blue (1.0).
Light goes from -1.0 (black) to +1.0 (white) with 0.0 having most color. This parameter can also take a range to draw from. Finally, there is a parameter sat for the saturation, which goes from 0.0 to 1.0. Not specifying it means that it is completely random. You can play with the parameters, setting some constant and giving ranges to others.

[Anders-Holst]

Hi Dan,

Glad that you like the effects!

There is no very good reason for it to start at blue, it could have started with red as well. But if you really want to know the background for why it ended up this way:
My very first "color model" that I had to implement some twenty-five years ago (before python and matplotlib and various plotting libraries) was to display a heat-map where the value 0.0 should be blue, and then higher and higher activity would get green, yellow, orange, all the way up to red at 1.0. Thus in my mind 0.0 is still the coldest color, i.e. blue, also when I later extended it to the whole spectrum. Also, I was not satisfied with the commonly used red-green-blue "computer" spectrum, which I think you refer to, and which have red=0, yellow=0.17, green=0.33, cyan=0.5, blue=0.67, and magenta=0.83. It has an excess of blue-green colors, and skips over orange and purple very quickly. I wanted something like the six basic "children" colors "yellow-orange-red-purple-blue-green" at equal distances. Now my favorite is the eight-color model, combining the "children" and "computer" colors into "blue-cyan-green-yellow-orange-red-magenta-purple" at equal distances. So that's what I implemented. The point is, that since I had therefore already deviated from the standard HSL color model (which has the "computer" colors at equal distances, and starting at red), it could as well start with a different color, just to signal that it is different. (In my original implementation there was actually a policy option "red-based", using the standard HSL order, but I removed it since it just complicated things and I did not think anyone would care about the order...)

Long and winded answer but there it is.

[DanDixon]

Wow, thanks for the detailed explanation.

When I first got this working, I was changing the color values around and wondered why 0 was blue, not red.
I created a simple function to wrap around inputs so I can use the number order I'm familiar with. Although I guess it's still not a 100% match, but works pretty well.

These effects are cooler than the effects possible with the app, so thanks again!

I'm modifying your code to support sending color and scene info to various effects so the colors will match the colors of lights in my house. I just got a shimmer variant to adjust the color (along with changing all the lights in my house) with a single click in Home Assistant. Yay!

[Anders-Holst]

If you really like, you can get closer to the original HSL color circle by calling set_color_style("3col"). You still need your wrapper because pure red is otherwise at 2/3, but the distances are as in the "computer" spectrum.

Nice idea to tint the effects according to your room illumination. I figure this is the kind of stuff a color model like HSL is absolutely necessary for - it would be hopeless to navigate in RGB.

[Anders-Holst]

(Or maybe "tinting" is actually quite easy in RGB, when I think about it. Easier than in HSL. Transforming a whole color scheme around the spectrum is more convenient in HSL though.)

[DanDixon]

The color gradients your code creates are great.
And thanks for the extra info.

Any plans for any more updates?
I've been making my changes in other files to minimize conflicts if you ever update this library.

Also, I'm curious how many light strands you have?
I'm thinking about getting a couple more and setting up a column of lights down my C -shaped staircase so I can enjoy them all year long.

[Anders-Holst]

Daily effect, December 11 - Gradients of yellow

Gradients of yellow, green and orange sweeping diagonally over the lights.
This effect is actually easy to achieve with the app as well. But nice anyway.
Uses the layout, and for best effect you may have to adjust the aspect ratio:
The parameter to adjust_layout_aspect below should be set to width/height of the lights.

from xled_plus.samples.sample_setup import *
ctr = setup_control()
ctr.adjust_layout_aspect(1.0)  # How many times wider than high is the led installation?
cols = [hsl_color(0.375, 0.2, 0.0), hsl_color(0.375, 1.0, 0.0), hsl_color(0.28, 1.0, 0.0), hsl_color(0.375, 0.2, 0.0), hsl_color(0.375, 1.0, 0.0),  hsl_color(0.5, 1.0, 0.0)]
GradientSequence(ctr, cols, speed=0.04, folds=0.5, angle=45).launch_movie()

[Anders-Holst]

Daily effect, December 12 - Gradients of blue

Gradients of blue, green and purple sweeping over the lights in rotating direction.
It is similar to yesterdays effect. However, this one, which slowly changes the angle of the gradient, is not possible to get with the app.
Again, uses the layout, and for best effect you may have to adjust the aspect ratio: The parameter to adjust_layout_aspect should be set to width/height of the lights.

Note: you need to update the installation to today's version (0.1.13), pip install -U xled_plus since the used class was unfinished before.

from xled_plus.samples.sample_setup import *
ctr = setup_control()
ctr.adjust_layout_aspect(1.0)  # How many times wider than high is the led installation?
cols = [hsl_color(0.0, 0.0, 0.0),hsl_color(0.02, 1.0, 0.0), hsl_color(0.9, 1.0, 0.0), hsl_color(0.0, 0.0, 0.0), hsl_color(0.06, 1.0, 0.0), hsl_color(0.18, 1.0, 0.0)]
eff = RotatingAngleGradientSequence(ctr, cols, speed=0.04, folds=0.5, angle=-45, torque=7.2)
eff.preferred_frames = 400
eff.launch_movie()

And if you get dizzy by the rotation, you know what to do - just set the "torque" parameter to zero. Note however, if you play with other values of "torque", that it is currently not so user friendly: you have to make sure yourself that it makes a whole cycle during the length of the movie. "speed=0.04" means that it takes 1/0.04 = 25 seconds for the whole cycle, and the torque is given in degrees per second, so in 25 seconds it makes 25*7.2 = 180 degrees. We would thus need 50 seconds to go all way around. With 8 frames per second (the default) that requires 400 frames. Thus the explicit setting of "preferred_frames". So you can try to set torque to 4.8 and preferred frames to 600, that should also work. Sorry for the math.

[Anders-Holst]

Daily effect, December 13 - Fire

Saint Lucia day, and the trees are on fire.
This effect is similar to the Water effect of day 2. Leds are randomly shifting color between a number of selected colors in a color scheme, this time red-orange-light yellow, to make it look like an open fire.

from xled_plus.samples.sample_setup import *
ctr = setup_control()
Fire(ctr).launch_movie()

Some of you may already have found this effect among the predefined effects in "effects.py".
So if you got disappointed because you have already seen it, I will tell how you make your own variant of it. If you look at the code in "effects.py" again you may notice that Fire is one of several examples of the class GlowEffect with different lists of colors to jump between. There is also a bit further down a class GlowCP, which takes such a list of colors. Now when you have access to the ColorPicker, you may as described for the December 7 daily effect, use it to pick a number of nice colors for your own color scheme. Then you can use the GlowCP class (where CP is short for ColorPicker) like below to get your own nice effect. Note however that the colors will not get the same probability, but the first has highest probability and then decreasing probabilities along the list. The idea is that the first few colors set the basic scheme, and later on in the list comes a few more extreme colors to spice it up. Good luck!

(If you find a particularly beautiful combination of colors, you are of course welcome to share it here.)

from xled_plus.samples.sample_setup import *
ctr = setup_control()
cols = [ Your list of HSL colors here ]
GlowCP(ctr, cols).launch_movie()

[Anders-Holst]

Daily effect, December 14 - Looping lights, red, magenta, green

Another variant of SparkleEffect, this time each led "looping" from black
through one of the selected colors to white, and then dims back to black
again (through gray). Gives nice white mix among the pulsating colors.

from xled_plus.samples.sample_setup import *
ctr = setup_control()
colfunc = selected_color_func([(0.6, 1.0), (0.7, 1.0), (0.28, 1.0)])
SparkleEffect(ctr, 3, colfunc, looplight_func(16, 16)).launch_movie()

[Anders-Holst]

Daily effect, December 20 - Kaleidoscope

Slowly changing symmetric pattern of random colors.
Again, needs the December 18 revision of the xled_plus code, and looks best on a rather dense 2D layout, and with correctly adjusted aspect: Change the number in the call to adjust_layout_aspect in the next to last line of the code below.

from xled_plus.samples.sample_setup import *

class SoftCaleidoScene(MovingShapesScene):
    def __init__(self, ctr, sym, colfunc):
        super(SoftCaleidoScene, self).__init__(ctr)
        self.freq = 0.6
        self.symang = m.pi / sym
        self.colfunc = colfunc
        self.bgpat = ctr.make_solid_pattern(hsl_color(0,0,-0.5))
        self.horizon = 320
        self.preferred_frames = 640
    def create(self):
        col = self.colfunc(self.time)
        speed = m.exp((random() - 0.5) * 1.1) / self.preferred_fps * 0.08
        rad = 0.1 + random() * 0.3
        angle = random() * 2 * m.pi
        offset = random() - 0.5
        vec = (m.sin(angle), m.cos(angle))
        cent = (-vec[0] * 1.5 + vec[1] * offset, -vec[1] * 1.5 - vec[0] * offset + 0.5)
        vel = (vec[0] * speed, vec[1] * speed)
        nstep = int(2.0 / speed)
        shape = Ellipse(cent, 0.0, rad, rad, col)
        shape.set_depth(0.0)
        shape.set_speed(vel[0], vel[1])
        shape.duetime = self.time + nstep
        return shape
    def get_color(self, coord, ind):
        r = m.sqrt(coord[0] ** 2 + coord[1] ** 2)
        a = m.atan2(coord[1], coord[0])
        a = abs((a % (2 * self.symang)) - self.symang)
        return super(SoftCaleidoScene, self).get_color((m.sin(a) * r, m.cos(a) * r), ind)
    def getnext(self):
        pat1 = super(SoftCaleidoScene, self).getnext()
        vec = self.getoccupancy()
        pat = [pat1[i] if vec[i] else self.bgpat[i] for i in range(self.ctr.num_leds)]
        return pat

ctr = setup_control()
ctr.adjust_layout_aspect(1.0)  # How many times wider than high is the led installation?
SoftCaleidoScene(ctr, 3, random_hsl_color_func(light=0.0)).launch_movie()

There will be a number of effects along these lines now, based on moving shapes. The principle here is quite similar to the December 18 effect with randomly moving shapes of random color. However a light background is added and a slice of the scene is mirrored to get the symmetry. Small details that make a huge difference in the appearance!
Note that this effect (and Dec 18 as well) will generate completely new sequences of colors every time you run the script. So if some parts of the sequence is boring or ugly, try again and maybe you have better luck. Each specific sequence will be 1 min and 20 sec long before it repeats itself (seamlessly of course). So you know how long to stay to look for possibly ugly parts.

[Anders-Holst]

There was a mistake in the Kaleidoscope effect code. Or a bunch of mistakes really. With Soft I meant that the shapes should be round and the colors should blend smoothly into each other, and also there should be no sudden jumps in color. I have corrected it now in the distribution. I also increased the symmetry from 3 to 5 (the second parameter in the call on the last line - play with it if you like), because I think it looks more pleasing. I put the new code snippet here too if you are interested:

from xled_plus.samples.sample_setup import *

class SoftKaleidoScene(MovingShapesScene):
    def __init__(self, ctr, sym, colfunc):
        super(SoftKaleidoScene, self).__init__(ctr)
        self.freq = 0.6
        self.symang = m.pi / sym
        self.colfunc = colfunc
        self.bgcol = hsl_color(0, 0, -0.5)
        self.horizon = 320
        self.preferred_frames = 640
    def create(self):
        col = self.colfunc(self.time)
        speed = m.exp((random() - 0.5) * 1.1) / self.preferred_fps * 0.08
        rad = 0.1 + random() * 0.3
        angle = random() * 2 * m.pi
        offset = random() - 0.5
        vec = (m.sin(angle), m.cos(angle))
        cent = (-vec[0] * 1.5 + vec[1] * offset, -vec[1] * 1.5 - vec[0] * offset + 0.5)
        vel = (vec[0] * speed, vec[1] * speed)
        nstep = int(3.0 / speed)
        shape = Blob(cent, rad, col)
        shape.set_depth(0.0)
        shape.set_speed(vel[0], vel[1])
        shape.duetime = self.time + nstep
        return shape
    def get_color(self, coord, ind):
        r = m.sqrt(coord[0] ** 2 + coord[1] ** 2)
        a = m.atan2(coord[1], coord[0])
        a = abs((a % (2 * self.symang)) - self.symang)
        return super(SoftKaleidoScene, self).get_color((m.sin(a) * r, m.cos(a) * r), ind)
    def blend_colors(self, colors):
        cols = colors
        br = list(map(lambda rgb: color_brightness(*rgb), colors))
        maxbr = max(br) if br else 0.0
        sumbr = sum(br) if br else 0.0
        bgbr = color_brightness(*self.bgcol)
        if maxbr < bgbr:
            delta = (bgbr - maxbr) / bgbr
            sumbr += (bgbr - maxbr)
            maxbr = bgbr
            cols = cols + [tuple(map(lambda x: x*delta, self.bgcol))]
        sumcol = tuple(map(lambda *args: int(round(sum(args) * maxbr / sumbr)), *cols))
        return sumcol

ctr = setup_control()
ctr.adjust_layout_aspect(1.0)  # How many times wider than high is the led installation?
SoftKaleidoScene(ctr, 5, random_hsl_color_func(light=0.0)).launch_movie()

[Anders-Holst]

Daily effect, December 21 - Moon

It is winter solstice - the longest night of the year.
And just a couple of days ago was a full moon.
This effect focuses on the night and the phases of the moon. In it, the moon passes all of its phases in just a minute, on a background of sparkling stars.

Again, gives best effect on a fairly dense 2D layout, and adjust the aspect ratio below if you need.

from xled_plus.samples.sample_setup import *

class Moon(Ellipse):
    def __init__(self, cent, rad, light, dark):
        super(Moon, self).__init__(cent, 0.0, rad, rad, None)
        self.light = light
        self.dark = dark
        self.r2 = rad*rad
        self.tilt = 0.5
        self.phase = -180.0
        self.speed = 1.0
    def moonlit(self, pos):
        ca = m.cos(m.pi * self.phase * self.tilt / 360.0)
        sa = m.sin(m.pi * self.phase * self.tilt / 360.0)
        cb = abs(m.cos(m.pi * (self.phase % 180.0) / 180.0))
        y = -ca * pos[1] + sa * pos[0]
        x = (-ca * pos[0] - sa * pos[1]) / cb if cb != 0.0 else 0.0
        if self.phase < -90:
            return x < 0.0 and x**2 + y**2 > self.r2
        elif self.phase == -90:
            return x < 0.0
        elif self.phase < 0:
            return x < 0.0 or x**2 + y**2 < self.r2
        elif self.phase < 90:
            return x > 0.0 or x**2 + y**2 < self.r2
        elif self.phase == 90:
            return x > 0.0
        else:
            return x > 0.0 and x**2 + y**2 > self.r2
    def update(self, step):
        self.phase = (self.phase + 180.0 + self.speed * step) % 360 - 180.0
    def get_color(self, coord):
        if self.is_inside(coord):
            if self.moonlit(coord):
                return self.light
            else:
                return self.dark
        else:
            return False

class MoonScene(MovingShapesScene):
    def __init__(self, ctr):
        super(MoonScene, self).__init__(ctr)
        self.bgeff = SparkleEffect(ctr, 3, self.whitefunc, pulselight_func(10, 1, 10))
        self.moon = Moon((0, 0), 0.4, hsl_color(0, 0, 1), (1, 1, 1))
        self.add_shape(self.moon)
        self.preferred_frames = 360
        self.preferred_fps = 6
    def whitefunc(self, *args):
        r = random()
        return hsl_color(0.05 if r < 0.5 else 0.45, 1.0, 0.8 - abs(r - 0.5))
    def update(self, step):
        self.moon.update(step)
    def reset(self, numframes):
        self.bgeff.reset(numframes)
    def getnext(self):
        pat1 = super(MoonScene, self).getnext()
        pat2 = self.bgeff.getnext()
        vec = self.getoccupancy()
        pat = [pat1[i] if vec[i] else pat2[i] for i in range(self.ctr.num_leds)]
        return pat

ctr = setup_control()
ctr.adjust_layout_aspect(1.0)  # How many times wider than high is the led installation?
MoonScene(ctr).launch_movie()

[Anders-Holst]

Daily effect, December 22 - Snowflakes

Falling snowflakes against a purple-blue background.
Mimics the snowfall effect you can download with the app. Just to show that you can do it this way too...

from xled_plus.samples.sample_setup import *

x = 0.75 ** 0.5

snowflake1 = [
    ([0.0, -1.0], [0.0, 1.0], 0.0),
    ([-x, -0.5], [x, 0.5], 0.0),
    ([-x, 0.5], [x, -0.5], 0.0),
    ([0.0, -0.7], [-0.3*x, -0.85], 0.0),
    ([0.0, -0.7], [0.3*x, -0.85], 0.0),
    ([0.0, 0.7], [-0.3*x, 0.85], 0.0),
    ([0.0, 0.7], [0.3*x, 0.85], 0.0),
    ([-0.7*x, -0.35], [-0.7*x, -0.65], 0.0),
    ([-0.7*x, 0.35], [-0.7*x, 0.65], 0.0),
    ([0.7*x, -0.35], [0.7*x, -0.65], 0.0),
    ([0.7*x, 0.35], [0.7*x, 0.65], 0.0),
    ([-0.7*x, -0.35], [-x, -0.2], 0.0),
    ([-0.7*x, 0.35], [-x, 0.2], 0.0),
    ([0.7*x, -0.35], [x, -0.2], 0.0),
    ([0.7*x, 0.35], [x, 0.2], 0.0),
]

snowflake2 = [
    ([0.0, -1.0], [0.0, 1.0], 0.0),
    ([-x, -0.5], [x, 0.5], 0.0),
    ([-x, 0.5], [x, -0.5], 0.0),
    ([0.0, -0.5], [-0.5*x, -0.25], 0.0),
    ([0.0, -0.5], [0.5*x, -0.25], 0.0),
    ([0.0, 0.5], [-0.5*x, 0.25], 0.0),
    ([0.0, 0.5], [0.5*x, 0.25], 0.0),
    ([0.5*x, 0.25], [0.5*x, -0.25], 0.0),
    ([-0.5*x, 0.25], [-0.5*x, -0.25], 0.0),
]

snowflake3 = [
    ([0.0, -0.5], [0.0, 0.5], 0.0),
    ([-0.5*x, -0.25], [0.5*x, 0.25], 0.0),
    ([-0.5*x, 0.25], [0.5*x, -0.25], 0.0),
]

snowflake4 = [
    ([0.0, -0.3], [-0.3*x, -0.15], 0.0),
    ([0.0, -0.3], [0.3*x, -0.15], 0.0),
    ([0.0, 0.3], [-0.3*x, 0.15], 0.0),
    ([0.0, 0.3], [0.3*x, 0.15], 0.0),
    ([0.3*x, 0.15], [0.3*x, -0.15], 0.0),
    ([-0.3*x, 0.15], [-0.3*x, -0.15], 0.0),
]

class Snowflake(Lineart2D):
    def __init__(self, segs, pos, angle, size, color):
        super(Snowflake, self).__init__()
        for seg in segs:
            self.add_segment(*seg)
        self.color = color
        self.size = size
        self.off = [0.0, 0.0]
        self.angle = 0.0
        self.speed = (0.0, 0.0)
        self.torque = 0.0
        self.change_pos(pos)
        self.change_angle(angle)
    def change_angle(self, deltaangle):
        self.angle += deltaangle
        ca = m.cos(self.angle * m.pi / 180.0) / self.size
        sa = m.sin(self.angle * m.pi / 180.0) / self.size
        self.mat = [[ca, sa], [-sa, ca]]
    def change_pos(self, delta):
        self.off = [self.off[0] - delta[0], self.off[1] - delta[1]]
    def update(self, step):
        self.change_pos((step * self.speed[0], step * self.speed[1]))
        self.change_angle(step * self.torque)

class SnowingScene(MovingShapesScene):
    def __init__(self, ctr):
        super(SnowingScene, self).__init__(ctr)
        self.freq = 0.6
        self.shapetypes = [snowflake1, snowflake2, snowflake3, snowflake4]
        self.shapeprobs = [0.15, 0.15, 0.3, 0.4]
        cf1 = random_hsl_color_func(hue=[0.06,0.12], sat=1.0, light=[0.2,0.6])
        cf2 = random_hsl_color_func(hue=[0.96,0.06], sat=0.7, light=0.0)
        self.shapecolfuncs = [cf1, cf1, cf2, cf2]
        self.horizon = 320
        self.preferred_frames = 640
    def create(self):
        tp = randomdiscrete(self.shapeprobs)
        col = self.shapecolfuncs[tp]()
        dist = 2.0 + random() + (tp // 2)*2
        speed = 0.05 / dist
        rot = (random() - 0.5) * 6.0
        offset = (random() * 2 - 1.0, 1.5)
        vec = (0.0, -speed)
        sf = Snowflake(self.shapetypes[tp], offset, 0.0, 0.3, col)
        sf.speed = vec
        sf.torque = rot
        sf.set_depth(dist)
        sf.lw = 0.15
        sf.duetime = self.time + int(3.0 / speed)
        return sf
    def getnext(self):
        pat1 = super(SnowingScene, self).getnext()
        hue = (0.78 + 0.44 * abs(0.5 - (float(self.time) / 160) % 1.0)) % 1.0
        patbg = ctr.make_layout_pattern(lambda pos: hsl_color(hue, 1.0, -0.92), style="centered")
        vec = self.getoccupancy()
        pat = [pat1[i] if vec[i] else patbg[i] for i in range(self.ctr.num_leds)]
        return pat

ctr = setup_control()
ctr.adjust_layout_aspect(1.0)  # How many times wider than high is the led installation?
SnowingScene(ctr).launch_movie()

[Anders-Holst]

There was a slight mistake here too: Too small planning horizon so some snowflakes disappear when wrapping around to the start of the movie. I have corrected it directly in the code above. And will later tonight in the repository.

[Anders-Holst]

Daily effect, December 23 - Crystal

Glittering white crystal, yet shimmering in all colors at once.
A more simple, random position effect for a change. For those of you without flat dense 2D-layouts of your leds.

from xled_plus.samples.sample_setup import *
from random import shuffle

class Crystal(RotateEffect):
    def __init__(self, ctr):
        saturations = [0.4, 0.0, 0.0, 0.2, 0.0, 0.0]
        folds = len(saturations)
        nleds = ctr.num_leds
        pat = ctr.make_func_pattern(
            lambda i: hsl_color((i*folds / float(nleds))%1.0, saturations[i*folds // nleds], 0.0),
            circular=True,
        )
        perm = list(range(nleds))
        shuffle(perm)
        self.nsparks = 0.02 * nleds
        self.white = hsl_color(0.0, 0.0, 1.0)
        self.preferred_fps = 12
        super(Crystal, self).__init__(ctr, pat, perm, step=2)
    def getnext(self):
        pat1 = super(Crystal, self).getnext()
        return sprinkle_pattern(self.ctr, pat1, [self.white], self.nsparks)

ctr = setup_control()
Crystal(ctr).launch_movie()

[gonzotek]

I think I'm going to use Crystal for New Years Eve :-) 🎉

Question: The shape effects don't really look too good on the only Twinkly device I have (the Christmas tree pictured in my Candy Cane effect thread). The original app has a few similar effects (such as the one named Countdown), which also look poor, so I don't think it's the code. I've tried learning a new layout in the app before, it didn't seem to help with these. Is this just the expected outcome, since the branches and overall shape of the tree layout make things too chaotic, or do you have any recommendations for anything I can try to improve? No worries if it's just the way it is, I have more than enough great-looking effects to keep us happy for a long time!

[Anders-Holst]

Yes I see. Different layouts are suitable for different kind of patterns. Random position effects works for everything. But making a 2D effect work on a 3D layout is not trivial. The ones I have played with above are also quite detailed, so many of them doesn't come to their own on too sparse lights.

The suggestion I have is to use a cylindrical mapping for "rectangular" 2D effects, or a half-spherical one if the pattern is radially symmetric ("circular"). I was lazy when preparing the daily code (or alternatively - prepared many of the recent ones on the fly and did not have much time for each), but of course the code should have checked the dimension of the layout and selected an appropriate mapping.
A cylindrical mapping is already supported by highcontrol.py (but not yet a half-spherical). It would require changes in shapes.py to use it though, but not so much (hint: it might suffice to replace line 67 with something like return self.ctr.make_layout_pattern(lambda pos, ind: self.get_color((pos[1]/180.0, pos[2]*2-1.0), ind), style="cylinder", index=True) but this is quite untested.)

Of course it is not possible to get anything like this through the app, but with Python we have the full freedom.

[gonzotek]

Thank you, I will try these ideas when I have a chance. Your math and python skills are far above my own, but I think I have the general idea of what you're saying with the return in line 67. Will let you know any results (good or bad).

[Anders-Holst]

Yesterday I made an attempt to fix these projections. I added a hint "proj2D3D" that can be given to a Scene object and tells it how to project 2D shapes onto 3D layouts. It can currently be "cylbase" (imagine that you put the 2D picture to show on the floor under the tree and then project each led down to the floor to see what color it gets), "cylshell" (imagine instead that you roll the image into a cylinder and thread it around your tree, and then project each led straight out from the stem to the picture), or "halfsphere" (wrap your picture onto a half sphere that you put over your tree, and the project the leds straight out from the foot of the tree). I have then updated the various daily effects (19 - 24) in the samples directory to use this hint.

From what I can tell, it helps for some of them but not for all. The Christmas balls looked fairly good on my tree actually, and the kaleidoscope effect is acceptable. Snowflakes requires a much denser surface, as do the moon and the moving shapes. The star becomes more regular than before, but quite boring. You can try it by downloading today's version and start the effects by python -m xled_plus.samples.day*.py where the star is the 19,20,21,22, or 24.

So, mixed results, but probably an enhancement.

[Anders-Holst]

Daily effect, December 24 - Christmas Tree Balls

Colored balls moving against a glittering white background.
(Again a 2D effect best on dense layouts, but this might be ok also on other layouts even if you can't make out the shapes.)
Merry Christmas!

Note: This is not the last daily effect! I will continue for the rest of December. Tomorrow there will be quite another kind of effect. So check in again!

from xled_plus.samples.sample_setup import *

class ChristmasBallsScene(MovingShapesScene):
    def __init__(self, ctr, cols):
        super(ChristmasBallsScene, self).__init__(ctr)
        self.freq = 0.5
        self.colors = cols
        self.whites = [hsl_color(0.4, 0.5, 0.2), hsl_color(0.1, 0.5, 0.2), hsl_color(0.0, 0.0, 0.2)]
        self.blink = hsl_color(0.0, 0.0, 1.0)
        self.bgpat = make_random_select_color_pattern(ctr, self.whites)
        self.preferred_frames = 640
    def create(self):
        tp = int(random() * len(self.colors))
        speed = 0.02
        angle = random() * 2 * m.pi
        offset = (random() - 0.5) * 1.6
        vec = (m.sin(angle), m.cos(angle))
        cent = (-vec[0] * 1.5 + vec[1] * offset, -vec[1] * 1.5 - vec[0] * offset)
        vel = (vec[0] * speed, vec[1] * speed)
        nstep = int(3.0 / speed)
        sh = Ellipse(cent, 0.0, 0.16, 0.16, self.colors[tp])
        sh.set_speed(vel[0], vel[1])
        sh.set_depth(0.0)
        sh.duetime = self.time + nstep
        return sh
    def getnext(self):
        pat1 = super(ChristmasBallsScene, self).getnext()
        patbg = sprinkle_pattern(self.ctr, self.bgpat, [self.blink], 0.05*self.ctr.num_leds)
        vec = self.getoccupancy()
        pat = [pat1[i] if vec[i] else patbg[i] for i in range(self.ctr.num_leds)]
        return pat

ctr = setup_control()
ctr.adjust_layout_aspect(1.0)  # How many times wider than high is the led installation?
cols = [hsl_color(0.625, 1.0, -0.15), hsl_color(0.26, 1.0, -0.11), hsl_color(0.42, 1.0, -0.05), hsl_color(0.54, 1.0, -0.15)]
# cols = [hsl_color(0.44, 1.0, -0.21), hsl_color(0.44, 1.0, 0.11), hsl_color(0.625, 1.0, -0.17), hsl_color(0.625, 1.0, 0.11)]
ChristmasBallsScene(ctr, cols).launch_movie()

[vejbuch2]

Merry Christmas Anders

[Anders-Holst]

Daily effect, December 25 - Random walk through color space

Up until now all effects have uploaded movies onto the device, by using launch_movie(). However, the Effect class also supports to run the effects in real time mode, that is continuously feeding the lights with new frames, without uploading a movie. Then the call launch_rt() is used instead. There is a corresponding call stop_rt() to stop playback of the continuous effect.

This possibility opens up for effects which are not easily squeezed into a movie, either because they are too long to fit within the device's movie capacity, or because it is hard to guarantee a smooth transition back to the first frame after a fixed number of frames. In the following days a few such effects will be explored. It requires a steady connection to the leds, and that your computer can be awake, feeding them. The code sleeps between frames though, so the burden on the load should be limited. (All the following effects can be launched as movies too, if you have no to let your computer feed them continuously - but they will not vary indefinitely and the transition back to the start will not be smooth.)

First out is a random walk through color space - a solid color that changes randomly throughout all of color space and never returns with exactly the same sequence. However, it changes so slowly that it is hard to see when it changes if you look at it, but whenever you do something else and then look back, it has a different color.

from xled_plus.samples.sample_setup import *
ctr = setup_control()
oldmode = ctr.get_mode()["mode"]
eff = ColorMeanderEffect(ctr, "solid")
eff.launch_rt()
print("Started continuous effect - press Return to stop it")
input()
eff.stop_rt()
ctr.set_mode(oldmode)

And if you really prefer the non-continuous variant, you get it the "usual" way below. It will then make a sudden jump to gray and repeat itself after about 42 minutes.

from xled_plus.samples.sample_setup import *
ctr = setup_control()
eff = ColorMeanderEffect(ctr, "solid")
eff.launch_movie()

[Anders-Holst]

Daily effect, December 26 - Random walk with complementary colors

A variant of yesterday's effect, with a gradient between a randomly changing color and its complement. May be reminiscent of the Day 4 effect, but the colors wander randomly.
You need today's release of xled_plus to run this effect! I had to add a couple of classes. pip install -U xled_plus
This is again a continuous effect, not a movie, so when you stop the script the effect stops. But if you like you can use the same trick as yesterday and start it as a movie. The code is analogous so you will easily figure out how.

from xled_plus.samples.sample_setup import *
ctr = setup_control()
oldmode = ctr.get_mode()["mode"]
eff = MeanderingTandemSequence(ctr, gap=0.5, fixangle=0.0)
eff.launch_rt()
print("Started continuous effect - press Return to stop it")
input()
eff.stop_rt()
ctr.set_mode(oldmode)

[Anders-Holst]

Daily effect, December 27 - Infinite Kaleidoscope

Slowly changing symmetric pattern of random colors, this time in continuous mode, so it never repeats.
Also, the shapes have sharp borders this time, and their colors follow a slowly changing color theme.
Again, looks best on a dense 2D layout (but this time thanks to a fix might work on 3D layouts such as Christmas trees).
And for correctly adjusted aspect ratio, change the number in the call to adjust_layout_aspect below.

from xled_plus.samples.sample_setup import *

class MeanderingKaleidoScene(MovingShapesScene):
    def __init__(self, ctr, sym):
        super(MeanderingKaleidoScene, self).__init__(ctr)
        self.freq = 0.6
        self.symang = m.pi / sym
        self.cm1 = ColorMeander(start=(random(), 0.6, 0.0))
        self.cm2 = ColorMeander(start=(random(), 0.6, 0.0))
        self.bgcol = hsl_color(0, 0, -0.5)
        self.horizon = 320
        self.preferred_frames = 640
        self.proj2D3D = "halfsphere"
    def create(self):
        colrnd = random()
        if colrnd < 0.3:
            (h, s, l) = self.cm2.get_hsl()
            col = hsl_color(h % 1.0, s, l)
        elif colrnd < 0.7:
            (h, s, l) = self.cm1.get_hsl()
            col = hsl_color((h + colrnd - 0.5) % 1.0, s, l)
        else:
            (h, s, l) = self.cm1.get_hsl()
            col = hsl_color(h % 1.0, colrnd, l)
        speed = m.exp((random() - 0.5) * 1.1) / self.preferred_fps * 0.08
        rad = 0.1 + random() * 0.5
        angle = random() * 2 * m.pi
        offset = random() - 0.5
        vec = (m.sin(angle), m.cos(angle))
        cent = (-vec[0] * 1.5 + vec[1] * offset, -vec[1] * 1.5 - vec[0] * offset + 0.5)
        vel = (vec[0] * speed, vec[1] * speed)
        nstep = int(3.0 / speed)
        corners = int(random() * 4) + 3
        shape = Star(corners, cent, 0.0, rad, rad/2.0, col)
        shape.set_depth(rad)
        shape.set_speed(vel[0], vel[1])
        shape.duetime = self.time + nstep
        return shape
    def update(self, step):
        self.cm1.step()
        self.cm2.step()
        super(MeanderingKaleidoScene, self).update(step)
    def get_color(self, coord, ind):
        r = m.sqrt(coord[0] ** 2 + coord[1] ** 2)
        a = m.atan2(coord[1], coord[0])
        a = abs((a % (2 * self.symang)) - self.symang)
        return super(MeanderingKaleidoScene, self).get_color((m.sin(a) * r, m.cos(a) * r), ind)
    def blend_colors(self, colors):
        cols = colors
        br = list(map(lambda rgb: color_brightness(*rgb), colors))
        maxbr = max(br) if br else 0.0
        sumbr = sum(br) if br else 0.0
        bgbr = color_brightness(*self.bgcol)
        if maxbr < bgbr:
            delta = (bgbr - maxbr) / bgbr
            sumbr += (bgbr - maxbr)
            maxbr = bgbr
            cols = cols + [tuple(map(lambda x: x*delta, self.bgcol))]
        sumcol = tuple(map(lambda *args: max(0, min(255, int(round(sum(args) * maxbr / sumbr)))), *cols))
        return sumcol

ctr = setup_control()
ctr.adjust_layout_aspect(1.0)  # How many times wider than high is the led installation?
eff = MeanderingKaleidoScene(ctr, 6)
oldmode = ctr.get_mode()["mode"]
eff.launch_rt()
print("Started continuous effect - press Return to stop it")
input()
eff.stop_rt()
ctr.set_mode(oldmode)

[Anders-Holst]

Daily effect, December 28 - Flowers

Different colored flowers that bloom from the center.
Similar principle as the Kaleidoscope, but grow pieces from the center.
Again, looks best on a 2D layout, and with correctly adjusted aspect:
Change the number in the call to adjust_layout_aspect in the code below.

from xled_plus.samples.sample_setup import *

class FlowerScene(MovingShapesScene):
    def __init__(self, ctr, sym):
        super(FlowerScene, self).__init__(ctr)
        self.freq = 0.6
        self.symang = m.pi / sym
        self.bgcol = hsl_color(0.25, 1.0, -0.5)
        self.lasthue = 0.25
        self.horizon = 360
        self.preferred_frames = 720
        self.proj2D3D = "halfsphere"
        self.ind = 0
    def makecolorfunc(self, sh):
        hue = (random()*0.74 + 0.36) % 1.0
        while abs(hue - self.lasthue) < 0.1:
            hue = (random()*0.74 + 0.36) % 1.0
        self.lasthue = hue
        sat = random()*0.5 + 0.5
        aa = 0.2
        ss = 0.05 / self.preferred_fps
        def func(pos, ind):
            tm = self.time - sh.crtime
            if tm * ss < aa:
                return hsl_color(hue, sat, 0.0)
            else:
                delta = 2.0 - 2.0 * aa / (tm * ss)
                rad = (pos[0]**2 + pos[1]**2) ** 0.5
                satres = rad * delta / (tm * ss) + 1.0 - delta
                return hsl_color(hue, max(0.0, min(1.0, sat * satres)), 0.0)
        return func
    def reshapefunc(self, sh):
        fact = (random() - 0.4) * 0.7
        aa = 0.2
        ss = 0.05 / self.preferred_fps
        def func():
            tm = self.time - sh.crtime
            if tm * ss < aa:
                sh.cent = (0.0, 0.0)
                sh.rad1 = tm * ss
                sh.rad2 = sh.rad1
            else:
                st = tm - aa / ss
                sh.cent = (sh.speed[0] * ss * st * 0.5, sh.speed[1] * ss * st * 0.5)
                sh.rad2 = aa + st * ss * 0.5
                sh.rad1 = aa + st * fact * ss * 0.5
        return func
    def create(self):
        angle = (random() * 3.0 - 0.5) * self.symang
        vec = (m.sin(angle), m.cos(angle))
        shape = Ellipse((0.0, 0.0), angle, 0.0, 0.0, False)
        shape.crtime = self.time
        shape.color = self.makecolorfunc(shape)
        shape.reshape = self.reshapefunc(shape)
        shape.set_depth(-self.ind)
        shape.set_speed(vec[0], vec[1])
        self.ind += 1
        return shape
    def update(self, step):
        if self.time % 30 == 0:
            if self.record:
                sh = self.create()
                self.add_shape(sh)
                self.pre_shapes.append((self.time + self.preferred_frames, sh))
            elif self.pre_shapes and self.pre_shapes[0][0] <= self.time:
                sh = self.pre_shapes[0][1]
                sh.crtime = self.time
                sh.set_depth(-self.ind)
                self.ind += 1
                self.add_shape(sh)
                self.pre_shapes = self.pre_shapes[1:]
            else:
                self.add_shape(self.create())
        for sh in self.shapes:
            sh.reshape()
        if len(self.shapes) > 12:
            self.shapes = self.shapes[:-1]
        self.time += 1
    def get_color(self, coord, ind):
        r = m.sqrt(coord[0] ** 2 + coord[1] ** 2)
        a = m.atan2(coord[1], coord[0])
        a = abs((a % (2 * self.symang)) - self.symang)
        return super(FlowerScene, self).get_color((m.sin(a) * r, m.cos(a) * r), ind)
    def blend_colors(self, colors):
        cols = colors
        br = list(map(lambda rgb: color_brightness(*rgb), colors))
        maxbr = max(br) if br else 0.0
        sumbr = sum(br) if br else 0.0
        bgbr = color_brightness(*self.bgcol)
        if maxbr < bgbr:
            delta = (bgbr - maxbr) / bgbr
            sumbr += (bgbr - maxbr)
            maxbr = bgbr
            cols = cols + [tuple(map(lambda x: x*delta, self.bgcol))]
        sumcol = tuple(map(lambda *args: max(0, min(255, int(round(sum(args) * maxbr / sumbr)))), *cols))
        return sumcol

ctr = setup_control()
ctr.adjust_layout_aspect(1.0)  # How many times wider than high is the led installation?
eff = FlowerScene(ctr, 6)
# eff.launch_movie()  # Alternatively use this line (remove the initial #) and remove all the below lines instead, if you want to upload a movie
oldmode = ctr.get_mode()["mode"]
eff.launch_rt()
print("Started continuous effect - press Return to stop it")
input()
eff.stop_rt()
ctr.set_mode(oldmode)

I will eventually add the recent days' effects into the main python files - these "snippets" of code are beginning to get ridiculously long...
Remember that you can also download the latest version of xled_plus pip update -U xled_plus and start the effect as python -m xled_plus.samples.day28

[Anders-Holst]

Daily effect, December 29 - Bouncing balls

Balls of slowly changing colors, bouncing over the breathing white leds.
You need to download the latest release again for this effect: pip install -U xled_plus
Unlike the previous effects, this should work reasonably for both 2D and 3D layouts. Works best for fairly dense layouts though.
A continuous effect again. You can upload it as a movie instead if you prefer, but it will jerk in the transition.
Remember to adjust aspect ratio in the call to adjust_layout_aspect in the code below.

from xled_plus.samples.sample_setup import *

class MeanderBouncingScene(BouncingScene):
    def __init__(self, ctr, num, speed=0.25, size=0.3):
        super(MeanderBouncingScene, self).__init__(ctr, num, speed, size, False)
        self.bgcol = hsl_color(0.0, 0.0, -0.5)
        self.bgeffect = BreathEffect(ctr, [(0.0, 0.0, 0.0)], 1.0, 0.75, [12, 30])
        self.colfunc = False
        self.horizon = 0
        self.preferred_frames = 640
    def create(self):
        sh = super(MeanderBouncingScene, self).create()
        sh.cm = ColorMeander("surface", start=(random(), 1.0, 0.0))
        return sh
    def update(self, step):
        for sh in self.shapes:
            sh.cm.step()
            (h, s, l) = sh.cm.get_hsl()
            sh.color = hsl_color(h, 1.0, min(0.3, max(-0.3, l)))
        super(MeanderBouncingScene, self).update(step)
    def blend_colors(self, colors):
        cols = colors
        br = list(map(lambda rgb: color_brightness(*rgb), colors))
        maxbr = max(br) if br else 0.0
        sumbr = sum(br) if br else 0.0
        bgbr = color_brightness(*self.bgcol)
        if maxbr < bgbr:
            delta = (bgbr - maxbr) / bgbr
            sumbr += (bgbr - maxbr)
            maxbr = bgbr
            cols = cols + [tuple(map(lambda x: x*delta, self.bgcol))]
        sumcol = tuple(map(lambda *args: max(0, min(255, int(round(sum(args) * maxbr / sumbr)))), *cols))
        return sumcol
    def reset(self, numframes):
        super(MeanderBouncingScene, self).reset(numframes)
        self.bgeffect.reset(numframes)
    def getnext(self):
        pat1 = super(MeanderBouncingScene, self).getnext()
        patbg = self.bgeffect.getnext()
        vec = self.getoccupancy()
        pat = [pat1[i] if vec[i] else patbg[i] for i in range(self.ctr.num_leds)]
        return pat

ctr = setup_control()
ctr.adjust_layout_aspect(1.0)  # How many times wider than high is the led installation?
eff = MeanderBouncingScene(ctr, 5, size=0.4)
# eff.launch_movie()  # Alternatively use this line (remove the initial #) and remove all the below lines instead, if you want to upload a movie
oldmode = ctr.get_mode()["mode"]
eff.launch_rt()
print("Started continuous effect - press Return to stop it")
input()
eff.stop_rt()
ctr.set_mode(oldmode)

[Anders-Holst]

Daily effect, December 30 - Random walk in colorspace with random gradient direction

Another variant of the Day 25 effect. Here the colors form a gradient that moves over the leds at a slowly and randomly changing angle and change rate.
This is again a continuous effect. Aspect ratio is important as usual, so adjust below. However, dimensionality or density of layout should matter less this time.
You need patience for this one - it is a slowly changing effect. Somewhat meditative.

from xled_plus.samples.sample_setup import *
ctr = setup_control()
ctr.adjust_layout_aspect(1.0)  # How many times wider than high is the led installation?
eff = MeanderingSequence(ctr)
oldmode = ctr.get_mode()["mode"]
eff.launch_rt()
print("Started continuous effect - press Return to stop it")
input()
eff.stop_rt()
ctr.set_mode(oldmode)

[Anders-Holst]

Daily effect, December 31 - Fireworks

My take on the fireworks theme. Colored blobs growing and sparkling and fading away.
I give you two versions this time:
The first is more ordered and gives one explosion at a time at controlled intervalls. Suits best for smaller or nonregular installations, eg a Christmas tree.
The second one, further below, gives explosions at random places and intervalls, suitable for rather large and dense 2D installations.

Again a continuous effect. You can convert it the usual way to a movie effect though, but it will be quite repetitive.

Maybe I should have waited with publishing this until tonight. However, please turn your leds off when the real firework starts! The leds come to their own best when there is no competition... or lets call it light disturbance.

Here is the simple version:

from xled_plus.samples.sample_setup import *

class Fireball(Shape):
    def __init__(self, cent, minrad, maxrad, speed, huesat):
        super(Fireball, self).__init__(cent, 0.0)
        self.rad = minrad
        self.minrad = minrad
        self.maxrad = maxrad
        self.speed = speed
        self.huesat = huesat
    def is_inside(self, coord):
        return (
            sum(map(lambda x1, x2: (x1 - x2) ** 2, self.cent, coord)) <= self.rad ** 2
        )
    def get_color(self, coord, ind):
        dist2 = (
            sum(map(lambda x1, x2: (x1 - x2) ** 2, self.cent, coord)) / self.rad ** 2
        )
        if dist2 > 1.0:
            return False
        elif self.rad == self.minrad:
            return hsl_color(0.0, 0.0, 1.0)
        else:
            (hue, sat) = self.huesat
            p = (self.rad - self.minrad) / (self.maxrad - self.minrad)
            rnd = random()
            if rnd < 0.1 * (1.2 - p):
                light = 1.0
            elif rnd < 0.2 * (1.2 - p):
                light = 0.0
            else:
                light = 2.0 * (1.0 - p) ** 2 - 1.0
            return hsl_color(hue, sat, light)
    def update(self, step):
        self.rad += self.speed * step

class FireworksScene(MovingShapesScene):
    def __init__(self, ctr):
        super(FireworksScene, self).__init__(ctr)
        self.freq = 0.0
        self.horizon = 100
        self.preferred_frames = 700
        self.preferred_fps = 20
        self.proj2D3D = "halfsphere"
    def create(self):
        cent = (0.0, 0.0)
        shape = Fireball(cent, 0.10, 1.0, 0.01, (random(), 1.0 - random()**2))
        shape.duetime = self.time + 0.9/0.01
        return shape
    def update(self, step):
        for sh in reversed(self.shapes):
            if sh.duetime < self.time:
                self.shapes.remove(sh)
        if self.time >= self.crtime:
            if self.record:
                sh = self.create()
                self.add_shape(copy(sh))
                sh.duetime += self.preferred_frames
                self.crtime = self.time + 100
                self.pre_shapes.append((self.crtime + self.preferred_frames, sh))
            elif self.replay:
                if self.pre_shapes:
                    self.add_shape(self.pre_shapes[0][1])
                    self.crtime = self.pre_shapes[0][0]
                    self.pre_shapes = self.pre_shapes[1:]
            else:
                self.add_shape(self.create())
                self.crtime = self.time + 100
                if self.pre_shapes and self.crtime >= self.pre_shapes[0][0]:
                    self.replay = True
        for sh in self.shapes:
            sh.update(step)
        self.time += step

ctr = setup_control()
ctr.adjust_layout_aspect(1.0)  # How many times wider than high is the led installation?
eff = FireworksScene(ctr)
oldmode = ctr.get_mode()["mode"]
eff.launch_rt()
print("Started continuous effect - press Return to stop it")
input()
eff.stop_rt()
ctr.set_mode(oldmode)

And here is the version for larger 2D installations. The only differences are in the FireworksScene class.

from xled_plus.samples.sample_setup import *

class Fireball(Shape):
    def __init__(self, cent, minrad, maxrad, speed, huesat):
        super(Fireball, self).__init__(cent, 0.0)
        self.rad = minrad
        self.minrad = minrad
        self.maxrad = maxrad
        self.speed = speed
        self.huesat = huesat
    def is_inside(self, coord):
        return (
            sum(map(lambda x1, x2: (x1 - x2) ** 2, self.cent, coord)) <= self.rad ** 2
        )
    def get_color(self, coord, ind):
        dist2 = (
            sum(map(lambda x1, x2: (x1 - x2) ** 2, self.cent, coord)) / self.rad ** 2
        )
        if dist2 > 1.0:
            return False
        elif self.rad == self.minrad:
            return hsl_color(0.0, 0.0, 1.0)
        else:
            (hue, sat) = self.huesat
            p = (self.rad - self.minrad) / (self.maxrad - self.minrad)
            rnd = random()
            if rnd < 0.1 * (1.2 - p):
                light = 1.0
            elif rnd < 0.2 * (1.2 - p):
                light = 0.0
            else:
                light = 2.0 * (1.0 - p) ** 2 - 1.0
            return hsl_color(hue, sat, light)
    def update(self, step):
        self.rad += self.speed * step

class FireworksScene(MovingShapesScene):
    def __init__(self, ctr):
        super(FireworksScene, self).__init__(ctr)
        self.freq = 0.8
        self.horizon = 60
        self.preferred_frames = 720
        self.preferred_fps = 20
        self.proj2D3D = "cylshell"
    def create(self):
        cent = (random()*1.6 - 0.8, random()*1.6 - 0.8)
        shape = Fireball(cent, 0.15, 0.63, 0.008, (random(), 1.0))
        shape.duetime = self.time + 0.48/0.008
        return shape

ctr = setup_control()
ctr.adjust_layout_aspect(1.0)  # How many times wider than high is the led installation?
eff = FireworksScene(ctr)
oldmode = ctr.get_mode()["mode"]
eff.launch_rt()
print("Started continuous effect - press Return to stop it")
input()
eff.stop_rt()
ctr.set_mode(oldmode)

[Anders-Holst]

Happy new year!

I hope you have enjoyed this expose of sample effects possible to produce by xled_plus!
I have covered simple deterministic effects, random position effects, gradients, shapes, continuous (infinitely generated) effects, and even interactive effects (if you count the colorpicker). The purpose of this collection is threefold:

• To again drive home the point that everything that can be done by the app can be done better from Python (and then so much more which are not possible from the app at all);
• To give an informal tutorial of how this package can be used, by providing examples that you can modify and play with;
• To provide inspiration and maybe seed ideas for further effects not yet included here.

As you probably noticed, some effects were written on the fly the same evening as published, some containing bugs that had to be fixed afterwards, some requiring simultaneous changes in the main package files. I have now some cleaning up to do, to include the larger new classes in the main package files, and document it all much better. Maybe I will write a proper tutorial and publish in the discussion forum. My hope is that the package will become useful and easy to use. I have a vague idea to provide some sort of GUI too, so simper effects can be produced without needing to deal directly with python.

If you manage to play with these examples and come up with a pattern that you find extra beautiful, or suggested modification of a class, or entirely new effect, please contribute it in the forum, and maybe I will add it to the collection. The idea is to maintain a large collection of possible effects. I will also clean up and rename the samples from "dayN" to something more descriptive.

Again I wish you a Happy 2022, and see you around in the forum!

/ Anders

[Anders-Holst]

You notice that I have not posted any new effects since 2021. Other things came in between. Cleaning up and renaming the effects to descriptive names also remains, and I still hope to do that. But what I have done is the ColorControl python program, which lets you create your own daily effects in an interactive GUI. Check it out: #29