Change pack() to an instance method. Update examples.

Author: PaintYourDragon

adafruit_fancyled.py

@@ -45,10 +45,11 @@
 class CRGB(object):
     """Color stored in Red, Green, Blue color space.
 
-       One of two ways: separate red, gren, blue values (either as integers (0 to 255
-       range) or floats (0.0 to 1.0 range), either type is 'clamped' to valid range and
-       stored internally in the normalized (float) format), OR can accept a CHSV color as
-       input, which will be converted and stored in RGB format.
+       One of two ways: separate red, gren, blue values (either as integers
+       (0 to 255 range) or floats (0.0 to 1.0 range), either type is
+       'clamped' to valid range and stored internally in the normalized
+       (float) format), OR can accept a CHSV color as input, which will be
+       converted and stored in RGB format.
 
        Following statements are equivalent - all return red:
 
@@ -108,23 +109,34 @@ def __repr__(self):
     def __str__(self):
         return "(%s, %s, %s)" % (self.red, self.green, self.blue)
 
+    def pack(self):
+        """'Pack' a `CRGB` color into a 24-bit RGB integer.
+
+           :returns: 24-bit integer a la ``0x00RRGGBB``.
+        """
+
+        return ((denormalize(self.red) << 16) |
+                (denormalize(self.green) << 8) |
+                (denormalize(self.blue)))
+
 
 class CHSV(object):
     """Color stored in Hue, Saturation, Value color space.
 
-       Accepts hue as float (any range) or integer (0-256 -> 0.0-1.0) with no clamping
-       performed (hue can 'wrap around'), saturation and value as float (0.0 to 1.0) or
-       integer (0 to 255), both are clamped and stored internally in the normalized (float)
-       format.  Latter two are optional, can pass juse hue and saturation/value will
-       default to 1.0.
+       Accepts hue as float (any range) or integer (0-256 -> 0.0-1.0) with
+       no clamping performed (hue can 'wrap around'), saturation and value
+       as float (0.0 to 1.0) or integer (0 to 255), both are clamped and
+       stored internally in the normalized (float) format.  Latter two are
+       optional, can pass juse hue and saturation/value will default to 1.0.
 
-       Unlike `CRGB` (which can take a `CHSV` as input), there's currently no equivalent
-       RGB-to-HSV conversion, mostly because it's a bit like trying to reverse a hash...
-       there may be multiple HSV solutions for a given RGB input.
+       Unlike `CRGB` (which can take a `CHSV` as input), there's currently
+       no equivalent RGB-to-HSV conversion, mostly because it's a bit like
+       trying to reverse a hash...there may be multiple HSV solutions for a
+       given RGB input.
 
-       This might be OK as long as conversion precedence is documented, but otherwise (and
-       maybe still) could cause confusion as certain HSV->RGB->HSV translations won't have
-       the same input and output.  Hmmm.
+       This might be OK as long as conversion precedence is documented,
+       but otherwise (and maybe still) could cause confusion as certain
+       HSV->RGB->HSV translations won't have the same input and output.
         """
 
     def __init__(self, h, s=1.0, v=1.0):
@@ -147,6 +159,15 @@ def __repr__(self):
     def __str__(self):
         return "(%s, %s, %s)" % (self.hue, self.saturation, self.value)
 
+    def pack(self):
+        """'Pack' a `CHSV` color into a 24-bit RGB integer.
+
+           :returns: 24-bit integer a la ``0x00RRGGBB``.
+        """
+
+        # Convert CHSV to CRGB, return packed result
+        return CRGB(self).pack()
+
 
 def clamp(val, lower, upper):
     """Constrain value within a numeric range (inclusive).
@@ -157,7 +178,10 @@ def clamp(val, lower, upper):
 def normalize(val, inplace=False):
     """Convert 8-bit (0 to 255) value to normalized (0.0 to 1.0) value.
 
-       Accepts integer, 0 to 255 range (input is clamped) or a list or tuple of integers.  In list case, 'inplace' can be used to control whether the original list is modified (True) or a new list is generated and returned (False).
+       Accepts integer, 0 to 255 range (input is clamped) or a list or tuple
+       of integers.  In list case, 'inplace' can be used to control whether
+       the original list is modified (True) or a new list is generated and
+       returned (False).
 
        Returns float, 0.0 to 1.0 range, or list of floats (or None if inplace).
     """
@@ -180,11 +204,12 @@ def normalize(val, inplace=False):
 def denormalize(val, inplace=False):
     """Convert normalized (0.0 to 1.0) value to 8-bit (0 to 255) value
 
-       Accepts float, 0.0 to 1.0 range or a list or tuple of floats.  In list case,
-       'inplace' can be used to control whether the original list is modified (True) or a
-       new list is generated and returned (False).
+       Accepts float, 0.0 to 1.0 range or a list or tuple of floats.  In
+       list case, 'inplace' can be used to control whether the original list
+       is modified (True) or a new list is generated and returned (False).
 
-       Returns integer, 0 to 255 range, or list of integers (or None if inplace).
+       Returns integer, 0 to 255 range, or list of integers (or None if
+       inplace).
     """
 
     # 'Denormalizing' math varies slightly from normalize().  This is on
@@ -206,22 +231,6 @@ def denormalize(val, inplace=False):
     return [denormalize(n) for n in val]
 
 
-def pack(val):
-    """'Pack' a `CRGB` or `CHSV` color into a 24-bit RGB integer.
-
-       :param obj val: `CRGB` or `CHSV` color.
-       :returns: 24-bit integer a la ``0x00RRGGBB``.
-    """
-
-    # Convert CHSV input to CRGB if needed
-    if isinstance(val, CHSV):
-        val = CRGB(val)
-
-    return ((denormalize(val.red) << 16) |
-            (denormalize(val.green) << 8) |
-            (denormalize(val.blue)))
-
-
 def unpack(val):
     """'Unpack' a 24-bit color into a `CRGB` instance.
 
@@ -239,8 +248,9 @@ def unpack(val):
 
 
 def mix(color1, color2, weight2=0.5):
-    """Blend between two colors using given ratio. Accepts two colors (each may be `CRGB`,
-       `CHSV` or packed integer), and weighting (0.0 to 1.0) of second color.
+    """Blend between two colors using given ratio. Accepts two colors (each
+       may be `CRGB`, `CHSV` or packed integer), and weighting (0.0 to 1.0)
+       of second color.
 
        :returns: `CRGB` color in most cases, `CHSV` if both inputs are `CHSV`.
     """
@@ -283,29 +293,32 @@ def mix(color1, color2, weight2=0.5):
                 (color1.blue * weight1 + color2.blue * weight2))
 
 
-GFACTOR = 2.5  # Default gamma-correction factor for function below
+GFACTOR = 2.7  # Default gamma-correction factor for function below
 
 def gamma_adjust(val, gamma_value=None, brightness=1.0, inplace=False):
     """Provides gamma adjustment for single values, `CRGB` and `CHSV` types
        and lists of any of these.
 
        Works in one of three ways:
-         1. Accepts a single normalized level (0.0 to 1.0) and optional gamma-adjustment
-            factor (float usu. > 1.0, default if unspecified is GFACTOR) and
-            brightness (float 0.0 to 1.0, default is 1.0). Returns a single normalized gamma-corrected brightness level (0.0 to 1.0).
-         2. Accepts a single `CRGB` or `CHSV` type, optional single gamma factor OR a
-            (R,G,B) gamma tuple (3 values usu. > 1.0), optional single
-            brightness factor OR a (R,G,B) brightness tuple.  The input tuples
-            are RGB even when a `CHSV` color is passed. Returns a normalized
-            gamma-corrected `CRGB` type (NOT `CHSV`!).
-         3. Accept a list or tuple of normalized levels, `CRGB` or `CHSV` types (and
-            optional gamma and brightness levels or tuples applied to all). Returns a list
-            of gamma-corrected values or `CRGB` types (NOT `CHSV`!).
+         1. Accepts a single normalized level (0.0 to 1.0) and optional
+            gamma-adjustment factor (float usu. > 1.0, default if
+            unspecified is GFACTOR) and brightness (float 0.0 to 1.0,
+            default is 1.0). Returns a single normalized gamma-corrected
+            brightness level (0.0 to 1.0).
+         2. Accepts a single `CRGB` or `CHSV` type, optional single gamma
+            factor OR a (R,G,B) gamma tuple (3 values usu. > 1.0), optional
+            single brightness factor OR a (R,G,B) brightness tuple.  The
+            input tuples are RGB even when a `CHSV` color is passed. Returns
+            a normalized gamma-corrected `CRGB` type (NOT `CHSV`!).
+         3. Accept a list or tuple of normalized levels, `CRGB` or `CHSV`
+            types (and optional gamma and brightness levels or tuples
+            applied to all). Returns a list of gamma-corrected values or
+            `CRGB` types (NOT `CHSV`!).
 
        In cases 2 and 3, if the input is a list (NOT a tuple!), the 'inplace'
        flag determines whether a new tuple/list is calculated and returned,
-       or the existing value is modified in-place.  By default this is 'False'.
-       If you try to inplace-modify a tuple, an exception is raised.
+       or the existing value is modified in-place.  By default this is
+       'False'.  If you try to inplace-modify a tuple, an exception is raised.
 
        In cases 2 and 3, there is NO return value if 'inplace' is True --
        the original values are modified.
@@ -338,14 +351,18 @@ def gamma_adjust(val, gamma_value=None, brightness=1.0, inplace=False):
             gamma_red, gamma_green, gamma_blue = GFACTOR, GFACTOR, GFACTOR
         elif isinstance(gamma_value, float):
             # Single gamma value provided, apply to R,G,B
-            gamma_red, gamma_green, gamma_blue = gamma_value, gamma_value, gamma_value
+            gamma_red, gamma_green, gamma_blue = (
+                gamma_value, gamma_value, gamma_value)
         else:
-            gamma_red, gamma_green, gamma_blue = gamma_value[0], gamma_value[1], gamma_value[2]
+            gamma_red, gamma_green, gamma_blue = (
+                gamma_value[0], gamma_value[1], gamma_value[2])
         if isinstance(brightness, float):
             # Single brightness value provided, apply to R,G,B
-            brightness_red, brightness_green, brightness_blue = brightness, brightness, brightness
+            brightness_red, brightness_green, brightness_blue = (
+                brightness, brightness, brightness)
         else:
-            brightness_red, brightness_green, brightness_blue = brightness[0], brightness[1], brightness[2]
+            brightness_red, brightness_green, brightness_blue = (
+                brightness[0], brightness[1], brightness[2])
         if inplace:
             for i, x in enumerate(val):
                 if isinstance(x, CHSV):
@@ -369,14 +386,18 @@ def gamma_adjust(val, gamma_value=None, brightness=1.0, inplace=False):
         gamma_red, gamma_green, gamma_blue = GFACTOR, GFACTOR, GFACTOR
     elif isinstance(gamma_value, float):
         # Single gamma value provided, apply to R,G,B
-        gamma_red, gamma_green, gamma_blue = gamma_value, gamma_value, gamma_value
+        gamma_red, gamma_green, gamma_blue = (
+            gamma_value, gamma_value, gamma_value)
     else:
-        gamma_red, gamma_green, gamma_blue = gamma_value[0], gamma_value[1], gamma_value[2]
+        gamma_red, gamma_green, gamma_blue = (
+            gamma_value[0], gamma_value[1], gamma_value[2])
     if isinstance(brightness, float):
         # Single brightness value provided, apply to R,G,B
-        brightness_red, brightness_green, brightness_blue = brightness, brightness, brightness
+        brightness_red, brightness_green, brightness_blue = (
+            brightness, brightness, brightness)
     else:
-        brightness_red, brightness_green, brightness_blue = brightness[0], brightness[1], brightness[2]
+        brightness_red, brightness_green, brightness_blue = (
+            brightness[0], brightness[1], brightness[2])
 
     if isinstance(val, CHSV):
         val = CRGB(val)
@@ -397,24 +418,24 @@ def palette_lookup(palette, position):
 
     position %= 1.0  # Wrap palette position in 0.0 to <1.0 range
 
-    weight2 = position * len(palette)    # Scale position to palette length
-    idx = int(floor(weight2))   # Index of 'lower' color (0 to len-1)
-    weight2 -= idx              # Weighting of 'upper' color
+    weight2 = position * len(palette) # Scale position to palette length
+    idx = int(floor(weight2))         # Index of 'lower' color (0 to len-1)
+    weight2 -= idx                    # Weighting of 'upper' color
 
-    color1 = palette[idx]           # Fetch 'lower' color
-    idx = (idx + 1) % len(palette)  # Get index of 'upper' color
-    color2 = palette[idx]           # Fetch 'upper' color
+    color1 = palette[idx]             # Fetch 'lower' color
+    idx = (idx + 1) % len(palette)    # Get index of 'upper' color
+    color2 = palette[idx]             # Fetch 'upper' color
 
     return mix(color1, color2, weight2)
 
 
 def expand_gradient(gradient, length):
     """Convert gradient palette into standard equal-interval palette.
 
-    :param sequence gradient: List or tuple of of 2-element lists/tuples containing
-      position (0.0 to 1.0) and color (packed int, CRGB or CHSV).  It's OK if the
-      list/tuple elements are either lists OR tuples, but don't mix and match lists and
-      tuples -- use all one or the other.
+    :param sequence gradient: List or tuple of of 2-element lists/tuples
+      containing position (0.0 to 1.0) and color (packed int, CRGB or CHSV).
+      It's OK if the list/tuple elements are either lists OR tuples, but
+      don't mix and match lists and tuples -- use all one or the other.
 
     :returns: CRGB list, can be used with palette_lookup() function.
     """
@@ -443,7 +464,8 @@ def expand_gradient(gradient, length):
                 if pos <= x[0]:
                     above = -1 - n
 
-        r = gradient[above][0] - gradient[below][0]  # Range between below, above
+        # Range between below, above
+        r = gradient[above][0] - gradient[below][0]
         if r <= 0:
             newlist.append(gradient[below][1]) # Use 'below' color only
         else:

examples/cpx_helper_example.py

@@ -0,0 +1,39 @@
+""" FancyLED example for Circuit Playground Express using fastled_helpers
+"""
+
+from adafruit_circuitplayground.express import cpx
+import adafruit_fancyled as fancy
+import fastled_helpers as helper
+
+cpx.pixels.auto_write = False  # Refresh pixels only when we say
+
+# A dynamic gradient palette is a compact way of representing a palette with
+# non-equal spacing between elements.  This one's a blackbody palette with a
+# longer red 'tail'.  The helper functions let us declare this as a list of
+# bytes, so they're easier to copy over from existing FastLED projects.
+heatmap_gp = bytes([
+    0, 255, 255, 255, # White
+    64, 255, 255, 0,  # Yellow
+    128, 255, 0, 0,   # Red
+    255, 0, 0, 0])    # Black
+
+# Convert the gradient palette into a normal palette w/16 elements:
+palette = helper.loadDynamicGradientPalette(heatmap_gp, 16)
+
+offset = 0 # Positional offset into color palette to get it to 'spin'
+
+while True:
+    for i in range(10):
+        # Load each pixel's color from the palette.  FastLED uses 16-step
+        # in-between blending...so for a 16-color palette, there's 256
+        # steps total.  With 10 pixels, multiply the pixel index by 25.5
+        # (and add our offset) to get FastLED-style palette position.
+        color = helper.ColorFromPalette(palette, int(offset + i * 25.5),
+                                        blend=True)
+        # Apply gamma using the FastLED helper syntax
+        color = helper.applyGamma_video(color)
+        # 'Pack' color and assign to NeoPixel #i
+        cpx.pixels[i] = color.pack()
+    cpx.pixels.show()
+
+    offset += 8  # Bigger number = faster spin

examples/cpx_rotate.py

@@ -4,59 +4,26 @@
 from adafruit_circuitplayground.express import cpx
 import adafruit_fancyled as fancy
 
-# Function names are kept the same as FastLED examples, which normally
-# upsets pylint.  Disable name-checking so this passes muster.
-# pylint: disable=invalid-name
+cpx.pixels.auto_write = False  # Refresh pixels only when we say
+cpx.pixels.brightness = 1.0    # We'll use FancyLED's brightness controls
 
-# A dynamic gradient palette is a compact representation of a color palette
-# that lists only the key points (specific positions and colors), which are
-# later interpolated to produce a full 'normal' color palette.
-# This one happens to be a blackbody spectrum, it ranges from black to red
-# to yellow to white...
-BLACKBODY = bytes([
-    0, 0, 0, 0,
-    85, 255, 0, 0,
-    170, 255, 255, 0,
-    255, 255, 255, 255])
+# Declare a 4-element color palette, this one happens to be a
+# 'blackbody' palette -- good for heat maps and firey effects.
+palette = [fancy.CRGB(1.0, 1.0, 1.0), # White
+           fancy.CRGB(1.0, 1.0, 0),   # Yellow
+           fancy.CRGB(1.0, 0, 0),     # Red
+           fancy.CRGB(0,0,0)]         # Black
 
-# Here's where we convert the dynamic gradient palette to a full normal
-# palette.  First we need a list to hold the resulting palette...it can be
-# filled with nonsense but the list length needs to match the desired
-# palette length (in FastLED, after which FancyLED is modeled, color
-# palettes always have 16, 32 or 256 entries...we can actually use whatever
-# length we want in CircuitPython, but for the sake of consistency, let's
-# make it a 16-element palette...
-PALETTE = [0] * 16
-fancy.loadDynamicGradientPalette(BLACKBODY, PALETTE)
-
-# The dynamic gradient step is optional...some projects will just specify
-# a whole color palette directly on their own, not expand it from bytes.
-
-def FillLEDsFromPaletteColors(palette, offset):
-    """ This function fills the Circuit Playground Express NeoPixels from a
-    color palette plus an offset to allow us to 'spin' the colors.  In
-    FancyLED (a la FastLED), palette indices are multiples of 16 (e.g.
-    first palette entry is index 0, second is index 16, third is 32, etc)
-    and indices between these values will interpolate color between the
-    two nearest palette entries.
-    """
-
-    for i in range(10):
-        # This looks up the color in the palette, scaling from
-        # 'palette space' (16 colors * 16 interp position = 256)
-        # to 'pixel space' (10 NeoPixels):
-        color = fancy.ColorFromPalette(palette, int(i * len(palette) * 16 / 10 + offset), 255, True)
-        # Gamma correction gives more sensible-looking colors
-        cpx.pixels[i] = fancy.applyGamma_video(color)
-
-# This is an offset (0-255) into the color palette to get it to 'spin'
-ADJUST = 0
+offset = 0  # Positional offset into color palette to get it to 'spin'
+levels = (0.25, 0.3, 0.15)  # Color balance / brightness for gamma function
 
 while True:
-    FillLEDsFromPaletteColors(PALETTE, ADJUST)
-    ADJUST += 4  # Bigger number = faster spin
-    if ADJUST >= 256:
-        ADJUST -= 256
-
-
-# pylint: enable=invalid-name
+    for i in range(10):
+        # Load each pixel's color from the palette using an offset, run it
+        # through the gamma function, pack RGB value and assign to pixel.
+        color = fancy.palette_lookup(palette, offset + i / 10)
+        color = fancy.gamma_adjust(color, brightness=levels)
+        cpx.pixels[i] = color.pack()
+    cpx.pixels.show()
+
+    offset += 0.033  # Bigger number = faster spin