166 lines
6.2 KiB
Python
166 lines
6.2 KiB
Python
# The MIT License (MIT)
|
|
#
|
|
# Copyright (c) 2017 PaintYourDragon for Adafruit Industries
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
# of this software and associated documentation files (the "Software"), to deal
|
|
# in the Software without restriction, including without limitation the rights
|
|
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
# copies of the Software, and to permit persons to whom the Software is
|
|
# furnished to do so, subject to the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice shall be included in
|
|
# all copies or substantial portions of the Software.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
# THE SOFTWARE.
|
|
"""
|
|
`adafruit_fancyled.fastled_helpers`
|
|
====================================================
|
|
|
|
CircuitPython "helper" library based on the Arduino FastLED library.
|
|
Uses similar function names to assist with porting of existing Arduino FastLED
|
|
projects to CircuitPython.
|
|
|
|
* Author(s): PaintYourDragon
|
|
"""
|
|
|
|
# imports
|
|
|
|
__version__ = "0.0.0-auto.0"
|
|
__repo__ = "https://github.com/Adafruit/Adafruit_CircuitPython_FancyLED.git"
|
|
|
|
from math import floor
|
|
from adafruit_fancyled import adafruit_fancyled as fancy
|
|
|
|
# These are helper functions that provide more FastLED-like calls for
|
|
# fancyled functions.
|
|
# Function names are kept the same as FastLED, which normally upsets pylint.
|
|
# Disable name-checking so this passes muster.
|
|
# pylint: disable=invalid-name
|
|
|
|
GFACTOR = 2.5 # Default gamma-correction factor for function below
|
|
|
|
|
|
def applyGamma_video(n, g_r=GFACTOR, g_g=None, g_b=None, inplace=False):
|
|
""" Approximates various invocations of FastLED's many-ways-overloaded
|
|
applyGamma_video() function.
|
|
|
|
ACCEPTS: One of three ways:
|
|
1. A single brightness level (0-255) and optional gamma-correction
|
|
factor (float usu. > 1.0, default if unspecified is 2.5).
|
|
2. A single CRGB, CHSV or packed integer type and optional gamma
|
|
factor or separate R, G, B gamma values.
|
|
3. A list of CRGB, CHSV or packed integer types (and optional gamma(s)).
|
|
|
|
In the tuple/list cases, 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'.
|
|
Can also use the napplyGamma_video() function to more directly
|
|
approximate FastLED syntax/behavior.
|
|
|
|
RETURNS: Corresponding to above cases:
|
|
1. Single gamma-corrected brightness level (0-255).
|
|
2. A gamma-corrected CRGB value (even if input is CHSV or packed).
|
|
3. A list of gamma-corrected CRGB values.
|
|
|
|
In the tuple/list cases, there is NO return value if 'inplace'
|
|
is true -- the original values are modified.
|
|
"""
|
|
|
|
# If single gamma value is passed, keep that, otherwise convert
|
|
# gamma values to tuple for gamma_adjust function.
|
|
if g_g is not None and g_b is not None:
|
|
g_r = (g_r, g_g, g_b)
|
|
|
|
return fancy.gamma_adjust(n, g_r, inplace=inplace)
|
|
|
|
|
|
def napplyGamma_video(n, g_r=GFACTOR, g_g=None, g_b=None):
|
|
""" In-place version of applyGamma_video() (to mimic FastLED function
|
|
name). This is for RGB tuples and tuple lists (not the prior function's
|
|
integer case)
|
|
"""
|
|
|
|
return applyGamma_video(n, g_r, g_g, g_b, inplace=True)
|
|
|
|
|
|
def loadDynamicGradientPalette(src, size):
|
|
""" Kindasorta like FastLED's loadDynamicGradientPalette() function,
|
|
with some gotchas.
|
|
|
|
ACCEPTS: Gradient palette data as a 'bytes' type (makes it easier to copy
|
|
over gradient palettes from existing FastLED Arduino sketches)...
|
|
each palette entry is four bytes: a relative position (0-255)
|
|
within the overall resulting palette (whatever its size), and
|
|
3 values for R, G and B...and a length for a new palette list
|
|
to be allocated.
|
|
|
|
RETURNS: list of CRGB colors.
|
|
"""
|
|
|
|
# Convert gradient from bytelist (groups of 4) to list of tuples,
|
|
# each consisting of a position (0.0 to 1.0) and CRGB color.
|
|
# (This is what FancyLED's expand_gradient needs for input.)
|
|
grad = []
|
|
for i in range(0, len(src), 4):
|
|
grad.append((src[i] / 255.0, fancy.CRGB(src[i + 1], src[i + 2], src[i + 3])))
|
|
|
|
# Create palette (CRGB list) matching 'size' length
|
|
return fancy.expand_gradient(grad, size)
|
|
|
|
|
|
def ColorFromPalette(pal, pos, brightness=255, blend=False):
|
|
""" Approximates the FastLED ColorFromPalette() function
|
|
|
|
ACCEPTS: color palette (list of CRGB, CSHV and/or packed ints),
|
|
palette index (x16) + blend factor of next index (0-15) --
|
|
e.g. pass 32 to retrieve palette index 2, or 40 for an
|
|
interpolated value between palette index 2 and 3, optional
|
|
brightness (0-255), optional blend flag (True/False)
|
|
|
|
RETURNS: CRGB color, no gamma correction
|
|
"""
|
|
|
|
# Alter 'pos' from FastLED-like behavior to fancyled range
|
|
if blend:
|
|
# Continuous interpolation 0.0 to 1.0
|
|
pos = (pos / 16.0) / len(pal)
|
|
else:
|
|
# No blending -- quantize to nearest palette bin
|
|
pos = floor(pos / 16.0) / len(pal)
|
|
|
|
color = fancy.palette_lookup(pal, pos)
|
|
|
|
if brightness < 1.0:
|
|
brightness /= 255.0
|
|
if isinstance(color, fancy.CHSV):
|
|
color = fancy.CRGB(color)
|
|
elif isinstance(color, int):
|
|
color = fancy.unpack(color)
|
|
color.red *= brightness
|
|
color.green *= brightness
|
|
color.blue *= brightness
|
|
|
|
return color
|
|
|
|
|
|
def hsv2rgb_spectrum(hue, sat, val):
|
|
|
|
""" This is named the same thing as FastLED's simpler HSV to RGB function
|
|
(spectrum, vs rainbow) but implementation is a bit different for the
|
|
sake of getting something running (adapted from some NeoPixel code).
|
|
|
|
ACCEPTS: hue, saturation, value in range 0 to 255
|
|
RETURNS: CRGB color.
|
|
"""
|
|
|
|
return fancy.CRGB(fancy.CHSV(hue / 255, sat / 255, val / 255))
|
|
|
|
|
|
# pylint: enable=invalid-name
|