def do_swirl(self, this_program):
def swirl(x, y, step):
x -= (scrollphathd.DISPLAY_WIDTH / 2.0)
y -= (scrollphathd.DISPLAY_HEIGHT / 2.0)
dist = math.sqrt(pow(x, 2) + pow(y, 2))
angle = (step / 10.0) + dist / 1.5
s = math.sin(angle)
c = math.cos(angle)
xs = x * c - y * s
ys = x * s + y * c
r = abs(xs + ys)
return max(0.0, 0.7 - min(1.0, r / 8.0))
while self.program == this_program and not self._got_stop_event():
timestep = math.sin(time.time() / 18) * 1500
for x in range(0, WIDTH):
for y in range(0, HEIGHT):
v = swirl(x, y, timestep)
scrollphathd.pixel(x, y, v)
scrollphathd.show()
time.sleep(0.001)
def roll():
for data in ROLL:
for x in range(0, scrollphathd.DISPLAY_WIDTH):
for y in range(0, scrollphathd.DISPLAY_HEIGHT):
brightness = data[x][y]
scrollphathd.pixel(x, y, brightness * IMAGE_BRIGHTNESS)
scrollphathd.show()
time.sleep(0.01)
def warning():
speed_factor = 10
scale = (math.sin(time.time() * speed_factor) + 1) / 2
offset = 0
for x in range(scrollphathd.width):
for y in range(scrollphathd.height):
offset += 1
color = 0.85 * scale * (offset % 2)
scrollphathd.pixel(x, y, color)
scrollphathd.show()
def demo(self):
self.index += 2
s = math.sin(self.index / 50.0) * 2.0 + 6.0
for x in range(0, 17):
for y in range(0, 7):
v = 0.3 + (0.3 * math.sin((x * s) + self.index / 4.0) *
math.cos((y * s) + self.index / 4.0))
scrollphathd.pixel(x, y, v)
def look_down(num):
if(num==1):
for x in range(0, scrollphathd.DISPLAY_WIDTH):
for y in range(0, scrollphathd.DISPLAY_HEIGHT):
brightness = CAR_1[x][y]
scrollphathd.pixel(x, y, brightness * IMAGE_BRIGHTNESS)
else:
for x in range(0, scrollphathd.DISPLAY_WIDTH):
for y in range(0, scrollphathd.DISPLAY_HEIGHT):
brightness = CAR_2[x][y]
scrollphathd.pixel(x, y, brightness * IMAGE_BRIGHTNESS)
def explode(self):
for r in range(int(self.WIDTH * 1.25)):
for s in range(r):
c = 1 + int(math.pi * 2 * r)
for a in range(c):
o = 2 * math.pi / c * a
x = int(math.sin(o) * s + self.WIDTH - 1)
y = int(math.cos(o) * s + self._hpos)
v = s / r * (0.2 + 0.8 * random())
if 0 <= x < self.WIDTH and 0 <= y <= self.HEIGHT:
scrollphathd.pixel(x, y, v)
scrollphathd.show()
time.sleep(0.01)
def do_plasma(self, this_program):
i = 0
while self.program == this_program and not self._got_stop_event():
i += 2
s = math.sin(i / 50.0) * 2.0 + 6.0
for x in range(0, 17):
for y in range(0, 7):
v = 0.3 + (0.3 * math.sin((x * s) + i / 4.0) *
math.cos((y * s) + i / 4.0))
scrollphathd.pixel(x, y, v)
scrollphathd.show()
time.sleep(0.01)
def render(self, instant=True):
led_strip_buf = np.zeros((512, 3))
for led_id in self.leds:
led = self.leds[led_id]
if led["type"] == "strip":
led_strip_buf[led["hardware_id"]] = led["colour"]
elif led["type"] == "mat":
y, x = led["hardware_id"]
y = 8 - y
v = (max(led["colour"]) / 255.0) * self._eye_brightness
scrollphathd.pixel(x, y, v)
self.client.put_pixels(led_strip_buf * self._brightness)
scrollphathd.show()
def blink():
for data in BLINK:
for x in range(0, scrollphathd.DISPLAY_WIDTH):
for y in range(0, scrollphathd.DISPLAY_HEIGHT):
brightness = data[x][y]
scrollphathd.pixel(x, y, brightness * IMAGE_BRIGHTNESS)
scrollphathd.show()
time.sleep(0.001)
time.sleep(.002)
for data in BLINK_REVERSE:
for x in range(0, scrollphathd.DISPLAY_WIDTH):
for y in range(0, scrollphathd.DISPLAY_HEIGHT):
brightness = data[x][y]
scrollphathd.pixel(x, y, brightness * IMAGE_BRIGHTNESS)
scrollphathd.show()
time.sleep(0.005)
def amazon():
for z in range(8):
for x in range(0, scrollphathd.DISPLAY_WIDTH):
for y in range(0, scrollphathd.DISPLAY_HEIGHT):
brightness = AMZN[x][y]
scrollphathd.pixel(x, y, brightness * IMAGE_BRIGHTNESS)
scrollphathd.show()
time.sleep(.5)
for x in range(0, scrollphathd.DISPLAY_WIDTH):
for y in range(0, scrollphathd.DISPLAY_HEIGHT):
brightness = AMZN_NEG[x][y]
scrollphathd.pixel(x, y, brightness * IMAGE_BRIGHTNESS)
scrollphathd.show()
time.sleep(.5)
scrollphathd.clear()
scrollphathd.show()
def start():
i = 0
while not self.stop:
i += 2
s = math.sin(i / 50.0) * 2.0 + 6.0
for x in range(0, 17):
for y in range(0, 7):
v = 0.3 + (0.3 * math.sin((x * s) + i / 4.0) *
math.cos((y * s) + i / 4.0))
scrollphathd.pixel(x, y, v)
time.sleep(0.01)
scrollphathd.show()
def look_down():
for data in LOOK_DOWN:
for x in range(0, scrollphathd.DISPLAY_WIDTH):
for y in range(0, scrollphathd.DISPLAY_HEIGHT):
brightness = data[x][y]
scrollphathd.pixel(x, y, brightness * IMAGE_BRIGHTNESS)
scrollphathd.show()
time.sleep(0.01)
time.sleep(2)
for data in LOOK_DOWN_REVERSE:
for x in range(0, scrollphathd.DISPLAY_WIDTH):
for y in range(0, scrollphathd.DISPLAY_HEIGHT):
brightness = data[x][y]
scrollphathd.pixel(x, y, brightness * IMAGE_BRIGHTNESS)
scrollphathd.show()
time.sleep(0.01)
def do_cells(self, this_program):
rules = [22, 30, 54, 60, 75, 90, 110, 150]
rule = rules[0]
maxSteps = 100
loopCount = 0
matrix = numpy.zeros((HEIGHT, WIDTH), dtype=numpy.int)
firstRow = [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]
matrix[0] = firstRow
row = 0
speed = 10
while self.program == this_program and not self._got_stop_event():
for y in range(0, HEIGHT):
for x in range(0, WIDTH):
scrollphathd.pixel(x, y, matrix[y, x])
scrollphathd.show()
loopCount += 1
if loopCount > maxSteps:
loopCount = 0
row = 0
matrix = numpy.zeros((HEIGHT, WIDTH), dtype=numpy.int)
matrix[0] = firstRow
rules = numpy.roll(rules, -1, axis=0)
rule = rules[0]
inputRow = matrix[row]
outputRow = numpy.zeros((WIDTH), dtype=numpy.int)
for x in range(0, WIDTH):
a = inputRow[x - 1] if x > 0 else inputRow[WIDTH - 1]
b = inputRow[x]
c = inputRow[x + 1] if x < WIDTH - 1 else inputRow[0]
o = 1 << ((a << 2) + (b << 1) + c)
outputRow[x] = 1 if o & rule else 0
if row < HEIGHT - 1:
row = row + 1
else:
matrix = numpy.roll(matrix, -1, axis=0)
matrix[row] = outputRow
time.sleep(0.01 * speed)
def send_image():
if request.method == 'POST':
try:
print("headers")
print(request.headers)
print("data")
print(request.data)
print("headers")
print(request.files)
# uploaded_file = request.files['image']
def get_pixel(x, y):
p = img.getpixel((x, y))
if img.getpalette() is not None:
r, g, b = img.getpalette()[p:p + 3]
p = max(r, g, b)
return p / 255.0
for x in request.files:
print(x)
uploaded_file = request.files[x]
uploaded_file.save(x)
print(uploaded_file.filename)
img = Image.open(uploaded_file.filename)
try:
for x in range(0, 17):
for y in range(0, 7):
brightness = get_pixel(x, y)
scrollphathd.pixel(x, 6 - y, brightness * 0.5)
scrollphathd.flip(x=True, y=False)
scrollphathd.show()
except Exception as e:
print(e)
scrollphathd.clear()
scrollphathd.show()
return "", 204
except Exception as e:
print(e)
abort(501)
def Robot_Mouth():
for x in range(0, scrollphathd.DISPLAY_WIDTH):
for y in range(0, scrollphathd.DISPLAY_HEIGHT):
brightness = get_pixel(x, y)
scrollphathd.pixel(x, 6 - y, brightness * IMAGE_BRIGHTNESS)
start_time = time.time()
last_weather_time = start_time
last_tweet_time = start_time
last_clock_time = start_time
while Show_Mouth:
scrollphathd.show()
time.sleep(0.5)
scrollphathd.scroll(-1)
if time.time() - last_clock_time > (30):
scrollphathd.clear()
scrollphathd.show()
clock()
last_clock_time = time.time()
for x in range(0, scrollphathd.DISPLAY_WIDTH):
for y in range(0, scrollphathd.DISPLAY_HEIGHT):
brightness = get_pixel(x, y)
scrollphathd.pixel(x, 6 - y, brightness * IMAGE_BRIGHTNESS)
if time.time() - last_weather_time > (30 * 60):
scrollphathd.clear()
scrollphathd.show()
if Check_Internet():
print_weather()
last_weather_time = time.time()
for x in range(0, scrollphathd.DISPLAY_WIDTH):
for y in range(0, scrollphathd.DISPLAY_HEIGHT):
brightness = get_pixel(x, y)
scrollphathd.pixel(x, 6 - y, brightness * IMAGE_BRIGHTNESS)
if time.time() - last_tweet_time > (5 * 60):
scrollphathd.clear()
scrollphathd.show()
if Check_Internet():
print_hashtag()
last_tweet_time = time.time()
for x in range(0, scrollphathd.DISPLAY_WIDTH):
for y in range(0, scrollphathd.DISPLAY_HEIGHT):
brightness = get_pixel(x, y)
scrollphathd.pixel(x, 6 - y, brightness * IMAGE_BRIGHTNESS)
scrollphathd.clear()
scrollphathd.show()
def pulse():
scrollphathd.clear()
scrollphathd.show()
dur = 10
count = 0
img = Image.open("mouth.bmp")
img.show()
scrollphathd.clear()
scrollphathd.show()
def get_pixel(x, y):
p = img.getpixel((x, y))
if img.getpalette() is not None:
r, g, b = img.getpalette()[p:p + 3]
p = max(r, g, b)
return p / 255.0
try:
for x in range(0, scrollphathd.DISPLAY_WIDTH):
for y in range(0, scrollphathd.DISPLAY_HEIGHT):
brightness = get_pixel(x, y)
scrollphathd.pixel(x, 6 - y, brightness * IMAGE_BRIGHTNESS)
while count < dur * 10:
scrollphathd.show()
scrollphathd.scroll(1)
time.sleep(0.05)
count = count + 1
scrollphathd.clear()
scrollphathd.show()
return "", 204
except KeyboardInterrupt:
scrollphathd.clear()
scrollphathd.show()
def mainloop():
# set up the scrollPhat
scrollphathd.clear()
# Uncomment the below if your display is upside down
# (e.g. if you're using it in a Pimoroni Scroll Bot)
#scrollphathd.rotate(degrees=180)
scrollphathd.set_brightness(0.1)
# define a list of some interesting rule numbers to loop through
rules = [22, 30, 54, 60, 75, 90, 110, 150]
rule = rules[0]
# how many evolve steps to perform before starting the next CA rule
maxSteps = 100
loopCount = 0
# define the matrix of cells and rows that we will be displaying
matrix = numpy.zeros((7, 17), dtype=numpy.int)
# set the initial condition of the first row
# "dot" = single cell at position (0,8); top row, middle LED
firstRow = [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]
matrix[0] = firstRow
# We need to keep track of which row we are working on
# the CA fills in from the top row and evolves downwards.
# When we have filled the last row we'll scroll all the
# rows up and just evolve the bottom row from then on.
row = 0
speed = 10
while True:
# redraw first so that it shows the initial contitions when first run
for y in range(0, 7):
for x in range(0, 17):
scrollphathd.pixel(x, y, matrix[y, x])
scrollphathd.show()
loopCount += 1
# if we have performed maxSteps...
if loopCount > maxSteps:
# reset a bunch of stuff
loopCount = 0
row = 0
matrix = numpy.zeros((7, 17), dtype=numpy.int)
matrix[0] = firstRow
# get a new rule
rules = numpy.roll(rules, -1, axis=0)
rule = rules[0]
# use the current row as the input for the next row
inputRow = matrix[row]
# make an empty array to fill with values
outputRow = numpy.zeros((17), dtype=numpy.int)
# the secret sauce...
# step through each cell in the output row, calculate its value
# from the state of the input cell above and its left and right neighbour
for x in range(0, 17):
# for each output cell, get the values of the input cell
# and its left and right neighbours.
# because cell 0 has no left neighbour we will
# get that value from the last cell in the row.
# similarly, the last cell in the row has no right neighbour
# so we will use the value of cell 0, effectively wrapping
# the horizontal edges of the display
a = inputRow[x - 1] if x > 0 else inputRow[16]
b = inputRow[x]
c = inputRow[x + 1] if x < 16 else inputRow[0]
# a, b and c now contain the states of the three input cells
# that determine the state of our output cell
# there are 8 possible combinations for a,b,c
# they are:
# abc abc abc abc abc abc abc abc
# 111 110 101 100 011 010 001 000
# an abc combination will prodcude an output of either
# 1 or 0 depending on the rule we are using
# for example, if we are running rule 30:
# the binary representation of 30 is 11110.
# we have to left-pad that out a bit so that we also have
# 8 digits : "00011110"
# the rule can then be mapped onto our abc combinations like so:
# inputs 111 110 101 100 011 010 001 000
# outputs 0 0 0 1 1 1 1 0
# if we find an abc of a=1, b=0, c=0 we would match
# with "100" and output a 1
# if we were using rule number 110 we would get this mapping
# inputs 111 110 101 100 011 010 001 000
# outputs 0 1 1 0 1 1 0 0
# because the padded binary representation of the number 110 is
# "01101100" we get no match for "100"
# ok, so lets consider the first evolution of rule 30 starting
# with a single dot in the center of the first row.
# (using a row of seven cells, 17 is too many to type!)
# given row 0 => 0001000
# our first abc is "000", 00]0100[0 (remember that we are wrapping)
# > this maps to 0
# our next abc is "000", [000]1000
# > this maps to 0
# our next abc is "001", 0[001]000
# > this maps to 1 yay!
# our next abc is "010", 00[010]00
# > this maps to 1
# our next abc is "100", 000[100]0
# > this maps to 1
# our next abc is "000", 0001[000]
# > this maps to 0
# our next abc is "000", 0]0010[00
# > this maps to 0
# we now have seven new cells and our our output row will be
# > "0011100"
# and our cumulative rows will be :
# row 0 > 0001000
# row 1 > 0011100
# after the next step, our cumulative output will be :
# row 0 > 0001000
# row 1 > 0011100
# row 2 > 0110010
# so that's nice, but we need a general way to do this for any rule
# ...
# to convert our input values (abc) into output values for any
# rule we will first notice that the input combinations "111",
# "110" etc are themselves binary representations of the numbers
# 7,6,5,4,3,2,1,0 and that they are in index order if we read
# right to left.
# we can turn our abc result into a number and this will give
# the index position of our abc combination using our right to left order.
# for example, the abc pattern "011" is binary for 3
# ... int("011", 2) === 3
# so we put a 1 in index position 3 (counting from 0, starting from the right)
# ... "00001000"
# and see if it matches against our binary rule 30
# 0 0 0 0 1 0 0 0
# 0 0 0 1 1 1 1 0
# ^
# ^
# a match!
# this is equivelant to the bitwise AND operation:
# 3&30
# see here :
# https://wiki.python.org/moin/BitwiseOperators
# x & y Does a "bitwise and". Each bit of the output is 1 if the
# corresponding bit of x AND of y is 1, otherwise it's 0.
# so, after all that we now know the state of this output cell.
# fortunately the algorithm is a lot shorter than the explaination ;)
# construct our abc by bitshift and move a 1 to that index.
o = 1 << ((a << 2) + (b << 1) + c)
# set the output cell to 1 if it &s with the rule, othewise 0
outputRow[x] = 1 if o & rule else 0
# incrementally fill in the rows until we fill the last row
# then roll up the display matrix and evolve the last row
if row < 6:
row = row + 1
else:
matrix = numpy.roll(matrix, -1, axis=0)
# set the matrix new row for the next redraw
matrix[row] = outputRow
# have a nap
time.sleep(0.01 * speed)
#!/usr/bin/env python
#displays a dot which bounce off the edges of the scroll phat
import time
import scrollphathd
scrollphathd.pixel(0, 0, 0.5)
try:
while True:
scrollphathd.scroll(1, 1)
scrollphathd.show()
time.sleep(0.1)
except KeyboardInterrupt:
scrollphathd.fill(0)
scrollphathd.show()
list.append(s.splitlines())
# Function that returns the brightness value nnn as a float, from the array at position i,j, for frame "step"
def candle(i , j, step):
r = float(list[step][i][j*3:j*3+3])
return r
# Set maximal brightness of LED Matrix
scrollphathd.set_brightness(0.5)
# Start rendering loop
timestep = 0
while True:
if timestep == 332: # the file has 333 frames
timestep = 0
timestep = timestep + 1
# Render each pixel column by column based on array contents
for x in range(0, scrollphathd.DISPLAY_WIDTH):
for y in range(0, scrollphathd.DISPLAY_HEIGHT):
v = candle(x, y, timestep)
scrollphathd.pixel(x, y, max(0,v/255))
# Wait a little before the next frame
time.sleep(0.001)
# Show the frame buffer
scrollphathd.show()
def _updater(self):
"""
The method which will maintain the display.
"""
# Some state variables
i_mult = 0.0
s_mult = 0.0
o_mult = 0.0
i_dir = 0.0
s_dir = 0.0
o_dir = 0.0
# And off we go!
LOG.info("Started update thread")
while self.is_running:
# Don't busy-wait
time.sleep(0.01)
# What time is love?
now = time.time()
# How long since these components went non-idle
i_since = now - self._input_time
s_since = now - self._service_time
o_since = now - self._output_time
# See what state we want these guys to be in. After 30s we figure
# that the component is hung and turn it off.
i_state = 1.0 if i_since < 30.0 else 0.0
s_state = 1.0 if s_since < 30.0 else 0.0
o_state = 1.0 if o_since < 30.0 else 0.0
# Slide the multiplier and direction accordingly
f = 0.2
i_mult = (1.0 - f) * i_mult + f * i_state
s_mult = (1.0 - f) * s_mult + f * s_state
o_mult = (1.0 - f) * o_mult + f * o_state
f = 0.01
i_dir = (1.0 - f) * i_dir + f * self._input_dir
s_dir = (1.0 - f) * s_dir + f * self._service_dir
o_dir = (1.0 - f) * o_dir + f * self._output_dir
# And actually update the display
for y in range(self._size):
for x in range(self._size):
# The pixel brightnesses, according to the pattern
i_v = self._pixel_value(x, y, i_since, i_dir)
s_v = self._pixel_value(x, y, s_since, s_dir)
o_v = self._pixel_value(x, y, o_since, o_dir)
i_x = self._input_off_x + x
i_y = self._input_off_y + y
s_x = self._service_off_x + x
s_y = self._service_off_y + y
o_x = self._output_off_x + x
o_y = self._output_off_y + y
# And set them
scrollphathd.pixel(i_x, i_y, i_v * i_mult)
scrollphathd.pixel(s_x, s_y, s_v * s_mult)
scrollphathd.pixel(o_x, o_y, o_v * o_mult)
scrollphathd.show()
# And we're done
scrollphathd.clear()
LOG.info("Stopped update thread")
#!/usr/bin/env python
#indicates a dotted pattern
import time
import math
import scrollphathd
speed_factor = 10
try:
while True:
scale = (math.sin(time.time() * speed_factor) + 1) / 2
offset = 0
for x in range(scrollphathd.width):
for y in range(scrollphathd.height):
offset += 1
color = 0.25 * scale * (offset % 2)
scrollphathd.pixel(x, y, color)
scrollphathd.show()
except KeyboardInterrupt:
scrollphathd.fill(0)
def run(self):
"""
The main running loop.
"""
# State variables
self.init()
last = time.time()
start = last
# Set things to the starting values
# Loop forever now
while True:
now = time.time()
since = now - last
# Move the things down
if since > self._wait:
self.step()
last = now
self._wait = max(0.0, self._wait - self.WAIT_DIFF)
# Make it easier or harder
if self._button_A.is_active:
self._frac_new = max(self.MIN_FRAC,
self._frac_new - self.FRAC_STEP)
if self._button_B.is_active:
self._frac_new = min(self.MAX_FRAC,
self._frac_new + self.FRAC_STEP)
# Move the player
if self._button_X.is_active and self._hpos > 0:
self._hpos -= 1
if self._button_Y.is_active and self._hpos < self.HEIGHT - 1:
self._hpos += 1
# Draw the field
for (y, row) in enumerate(self._arena):
for (x, e) in enumerate(row):
v = 0.5 if e else 0.0
scrollphathd.pixel(x, y, v)
# Draw the player
scrollphathd.pixel(self._wpos, self._hpos, 1.0)
# And display it all
scrollphathd.show()
# Collision?
if self._arena[self._hpos][self._wpos]:
# Print stats
print("You survived for %0.1f seconds" % (now - start))
print()
# Draw the explosion
self.explode()
# And reset things
self.init()
start = now
last = now
# Wait for bit befor emoving on
time.sleep(0.05)
#print(latest)
scrollphathd.clear()
if latest - last > 5:
# show startup logo
scrollphathd.clear()
scrollphathd.fill(0, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT + 14)
image_path = os.path.join(os.path.dirname(__file__), IMAGE_FILE2)
image = Image.open(image_path)
pixels = image.load()
for x in range(IMAGE_WIDTH):
for y in range(IMAGE_HEIGHT):
r, g, b = pixels[x, y]
scrollphathd.pixel(x, y + 7, (r / 255) * BRIGHTNESS)
scrollphathd.write_string('%s ' % int(latest), 1, IMAGE_HEIGHT + 8,
font5x5_numbers, 1, BRIGHTNESS)
scrollphathd.scroll_to(0, 0)
for i in range(IMAGE_HEIGHT + 8):
scrollphathd.show()
scrollphathd.scroll(0, 1)
time.sleep(0.05)
else:
scrollphathd.fill(0, 0, 0, 50, 14) # a nice big canvas to work with
if latest > last:
scrollphathd.scroll_to(0, 0)
def neutral():
for x in range(0, scrollphathd.DISPLAY_WIDTH):
for y in range(0, scrollphathd.DISPLAY_HEIGHT):
brightness = NEUTRAL[x][y]
scrollphathd.pixel(x, y, brightness * IMAGE_BRIGHTNESS)
scrollphathd.show()
time.sleep(0.1)
if i > 108: break #大体このぐらいのカウントで一週
scrollphathd.clear()
# プラズマ表示（サンプルより）
i = 0
while True:
i += 2
s = math.sin(i / 50.0) * 2.0 + 6.0
for x in range(0, 17):
for y in range(0, 7):
v = 0.3 + (0.3 * math.sin((x * s) + i / 4.0) *
math.cos((y * s) + i / 4.0))
scrollphathd.pixel(x, y, v)
time.sleep(0.01)
scrollphathd.show()
if i > 620: break # これもこのぐらいでブレイク
# ガンマ（明るさ）の変更ループ
DELAY = 0.0001
i = 0
while True:
i = i + 1
for x in range(255):
scrollphathd.fill(x / 255.0, 0, 0, 17, 7)
scrollphathd.show()
time.sleep(DELAY)
for x in reversed(range(255)):
IMAGE_BRIGHTNESS = 0.5
img = Image.open("mouth.bmp")
def get_pixel(x, y):
p = img.getpixel((x, y))
if img.getpalette() is not None:
r, g, b = img.getpalette()[p:p + 3]
p = max(r, g, b)
return p / 255.0
try:
for x in range(0, scrollphathd.DISPLAY_WIDTH):
for y in range(0, scrollphathd.DISPLAY_HEIGHT):
brightness = get_pixel(x, y)
scrollphathd.pixel(x, 6 - y, brightness * IMAGE_BRIGHTNESS)
while True:
scrollphathd.show()
time.sleep(0.03)
scrollphathd.scroll(-1)
except KeyboardInterrupt:
scrollphathd.clear()
scrollphathd.show()
