Dec 26 daily effect, xled_picture, and updates

Author: Anders-Holst

setup.py

@@ -1,4 +1,4 @@
-__version__ = '0.1.26'
+__version__ = '0.1.27'
 
 _classifiers = [
     'Development Status :: 4 - Beta',

xled_plus/highcontrol.py

@@ -651,11 +651,16 @@ def fetch_layout(self, aspect=False):
         }
         if dim == 3:
             crad = 0.0
+            hsrad = 0.0
             for p in self.layout:
                 r2 = (p[0] - cent[0]) ** 2 + (p[2] - cent[2]) ** 2
                 if r2 > crad:
                     crad = r2
+                r2 += (p[1] - bounds[1][0]) ** 2
+                if r2 > hsrad:
+                    hsrad = r2
             self.layout_bounds["cylradius"] = crad ** 0.5
+            self.layout_bounds["halfsradius"] = hsrad ** 0.5
 
     def layout_transform(self, pos, style):
         # style == 'square', 'rect', 'centered', 'cylinder', 'sphere'
@@ -680,21 +685,31 @@ def layout_transform(self, pos, style):
             # xz-radius max 1, angle in [-180,180], y in [0, 1]
             crad = self.layout_bounds["cylradius"]
             ybounds = self.layout_bounds["bounds"][1]
-            p = ((v - c) / crad for v, c in zip(pos, self.layout_bounds["center"]))
+            p = tuple((v - c) / crad for v, c in zip(pos, self.layout_bounds["center"]))
             return (
                 m.sqrt(p[0] ** 2 + p[2] ** 2),
-                m.atan2(p[2], p[0]) * 180.0 / m.pi,
-                (p[1] * crad - ybounds[0]) / (ybounds[1] - ybounds[0]),
+                m.atan2(p[0], p[2]) * 180.0 / m.pi,
+                (pos[1] - ybounds[0]) / (ybounds[1] - ybounds[0]),
             )
         elif style == "sphere" and self.layout_bounds["dim"] == 3:
             # radius max 1, longitude [-180,180], latitude [-90,90]
             rad = self.layout_bounds["radius"]
-            p = ((v - c) / rad for v, c in zip(pos, self.layout_bounds["center"]))
+            p = tuple((v - c) / rad for v, c in zip(pos, self.layout_bounds["center"]))
             return (
                 m.sqrt(p[0] ** 2 + p[1] ** 2 + p[2] ** 2),
-                m.atan2(p[2], p[0]) * 180.0 / m.pi,
+                m.atan2(p[0], p[2]) * 180.0 / m.pi,
                 m.atan2(p[1], m.sqrt(p[0] ** 2 + p[2] ** 2)) * 180.0 / m.pi,
             )
+        elif style == "halfsphere" and self.layout_bounds["dim"] == 3:
+            # radius max 1, longitude [-180,180], polar angle [0,90]
+            rad = self.layout_bounds["halfsradius"]
+            cent = (self.layout_bounds["center"][0], self.layout_bounds["bounds"][1][0], self.layout_bounds["center"][2])
+            p = tuple((v - c) / rad for v, c in zip(pos, cent))
+            return (
+                m.sqrt(p[0] ** 2 + p[1] ** 2 + p[2] ** 2),
+                m.atan2(p[0], p[2]) * 180.0 / m.pi,
+                m.atan2(m.sqrt(p[0] ** 2 + p[2] ** 2), p[1]) * 180.0 / m.pi,
+            )
         else:
             return pos
 

xled_plus/samples/day19.py

@@ -26,6 +26,7 @@ def __init__(self, ctr):
         self.add_shape(self.star1b)
         self.add_shape(self.star1c)
         self.add_shape(self.star2)
+        self.proj2D3D = "cylbase"
 
     def update(self, step):
         self.star1a.update(step)

xled_plus/samples/day20.py

@@ -18,6 +18,7 @@ def __init__(self, ctr, sym, colfunc):
         self.bgcol = hsl_color(0, 0, -0.5)
         self.horizon = 320
         self.preferred_frames = 640
+        self.proj2D3D = "halfsphere"
 
     def create(self):
         col = self.colfunc(self.time)

xled_plus/samples/day21.py

@@ -45,7 +45,7 @@ def moonlit(self, pos):
     def update(self, step):
         self.phase = (self.phase + 180.0 + self.speed * step) % 360 - 180.0
 
-    def get_color(self, coord):
+    def get_color(self, coord, ind):
         if self.is_inside(coord):
             if self.moonlit(coord):
                 return self.light
@@ -62,6 +62,7 @@ def __init__(self, ctr):
         self.add_shape(self.moon)
         self.preferred_frames = 360
         self.preferred_fps = 6
+        self.proj2D3D = "cylshell"
 
     def whitefunc(self, *args):
         r = random()

xled_plus/samples/day22.py

@@ -92,6 +92,7 @@ def __init__(self, ctr):
         self.shapecolfuncs = [cf1, cf1, cf2, cf2]
         self.horizon = 320
         self.preferred_frames = 640
+        self.proj2D3D = "cylshell"
 
     def create(self):
         tp = randomdiscrete(self.shapeprobs)

xled_plus/samples/day24.py

@@ -16,6 +16,7 @@ def __init__(self, ctr, cols):
         self.blink = hsl_color(0.0, 0.0, 1.0)
         self.bgpat = make_random_select_color_pattern(ctr, self.whites)
         self.preferred_frames = 640
+        self.proj2D3D = "cylshell"
 
     def create(self):
         tp = int(random() * len(self.colors))

xled_plus/samples/day26.py

@@ -0,0 +1,19 @@
+"""
+Day 26 - Random walk with complementary colors
+
+Variant of the Day 25 effect, with a gradient between a random walk
+color and its complement. 
+This is again a continuous effect, not a movie, so when you stop the script
+the effect stops. 
+"""
+
+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)

xled_plus/sequence.py

@@ -19,7 +19,7 @@
 
 from xled_plus.effect_base import Effect
 from xled_plus.colormeander import ColorMeander
-from xled_plus.pattern import blendcolors
+from xled_plus.pattern import blendcolors, dimcolor
 from xled_plus.ledcolor import hsl_color
 import math as m
 
@@ -186,13 +186,13 @@ class VaryingAngleSequence(Sequence):
     def initialize(self, maxfold):
         self.maxfold = maxfold
         if self.dim == 3:
-            self.meander = ColorMeander("sphere")
+            self.mangle = ColorMeander("sphere")
         else:
-            self.meander = ColorMeander("cylinder")
+            self.mangle = ColorMeander("cylinder")
 
     def update(self, step):
-        self.meander.step()
-        (x, y, z) = self.meander.get_xyz()
+        self.mangle.step()
+        (x, y, z) = self.mangle.get_xyz()
         if self.dim == 3:
             self.vect = (
                 x * self.maxfold / 2.0,
@@ -219,23 +219,66 @@ def __init__(self, ctr, cols, lens=False, speed=1.0, folds=3.0):
 
 
 class MeanderingSequence(VaryingAngleSequence):
-    def __init__(self, ctr):
-        super(MeanderingSequence, self).__init__(ctr, self.getcolor, 0.0, 0.0, 0.0)
+    def __init__(self, ctr, fixangle=False):
+        super(MeanderingSequence, self).__init__(ctr, self.getcolor, 0.0, 1.0, fixangle)
+        self.fixangle = fixangle
         self.initialize(1.0)
         self.cm = ColorMeander("sphere")
-        self.colvec = [self.cm.get()] * 100
+        self.colvec = [self.cm.get()] * 200
+        self.iter = 1
         self.init_fps(2)
+        self.preferred_frames = 800
 
     def reset(self, numframes):
         self.currpos = 0.5
+        if numframes:
+            self.mangle.steplen *= 10
+            self.mangle.noiselev *= 3
+            self.iter = 9
+            self.preferred_fps /= 10
 
     def update(self, step):
-        super(MeanderingSequence, self).update(step)
-        self.cm.step()
-        self.colvec = [self.cm.get()] + self.colvec[:-1]
+        if self.fixangle is False:
+            super(MeanderingSequence, self).update(step)
+        for i in range(self.iter):
+            self.cm.step()
+            self.colvec = [self.cm.get()] + self.colvec[:-1]
 
     def getcolor(self, x):
         ind = int(x * len(self.colvec) - 0.5)
         return self.colvec[min(max(0, ind), len(self.colvec)-1)]
 
-        
+
+class MeanderingTandemSequence(VaryingAngleSequence):
+    def __init__(self, ctr, gap=False, fixangle=False):
+        super(MeanderingTandemSequence, self).__init__(ctr, self.getcolor, 0.0, 1.0, fixangle)
+        self.initialize(1.0)
+        self.gap = gap
+        self.fixangle = fixangle
+        self.cm = ColorMeander("sphere")
+        self.init_fps(2)
+        self.preferred_frames = 800
+
+    def reset(self, numframes):
+        self.currpos = 0.5
+        if numframes:
+            self.cm.steplen *= 10
+            self.cm.noiselev *= 3
+            self.preferred_fps /= 10
+
+    def update(self, step):
+        if self.fixangle is False:
+            super(MeanderingTandemSequence, self).update(step)
+        self.cm.step()
+        (h, s, l) = self.cm.get_hsl()
+        self.hsl1 = (h, s, l)
+        self.hsl2 = ((h + 0.5) % 1.0, s, l)
+
+    def getcolor(self, x):
+        hsl = self.hsl1 if x < 0.5 else self.hsl2
+        fact = min(1.0, abs(2*x - 1.0) / abs(self.gap)) if self.gap else 1.0
+        if self.gap >= 0.0:
+            return hsl_color(hsl[0], hsl[1]*fact, hsl[2])
+        else:
+            return hsl_color(hsl[0], hsl[1], hsl[2]) if fact == 1.0 else (0,0,0)
+