class GraphicsCircleTest(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.radius = 0
self.direction = 1
self.color = RED
def generate(self):
# clear the drawing surface
self.graphics.fill(BLACK)
# put a circle on our surface
self.graphics.drawCircle(matrix_width / 2, matrix_height / 2,
self.radius, self.color)
# circle grows and shrinks based on direction.
if self.direction:
self.radius += 1
else:
self.radius -= 1
# if the circle is to big or to small inverse growth direction.
if self.radius >= (matrix_height / 2) or self.radius <= 0:
self.direction = not self.direction
# get the surface drawn
return self.graphics.getSurface()
class VuFlash(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.graphics.fill(BLUE)
self.p = pyaudio.PyAudio()
self.stream = self.p.open(format=audio_params[0],
channels=audio_params[1],
rate=audio_params[2],
input=audio_params[3],
output=audio_params[4],
frames_per_buffer=audio_params[5]
)
self.color = BLUE
def getaudio(self):
try:
raw = self.stream.read(audio_params[5])
except IOError as e:
if e[1] != pyaudio.paInputOverFlowed:
raise
else:
print("Warning: audio input buffer overflow")
raw = '\x00' * self.audio_params[5]
return np.array(np.frombuffer(raw, np.int16), dtype=np.float64)
def generate(self):
audio = self.getaudio()
rmsed = translate(rms(audio), 0, 0xffff/5, 0, matrix_height)
self.color = interp_color(rms(audio/10000))
self.color = color_convert(self.color)
self.graphics.fill(self.color)
return self.graphics.getSurface()
class TestPattern(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
def generate(self):
self.graphics.fill(WHITE)
return self.graphics.getSurface()
class Test(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.x = 0
self.y = 0
self.color = GREEN
self.phase = 1
self.timer = Timer(1 / 30.)
self.wave_range = 1
self.wave_step = 1
self.amplitude = 4
self.offset = matrix_width / 2
self.freq = 1. / matrix_height * 8
self.controlled = True
self.mc = MidiController()
def generate(self):
self.graphics.fill(BLACK)
if self.timer.valid():
self.phase += 1
for i in range(0, self.wave_range, self.wave_step):
for self.y in range(0, matrix_height):
if self.controlled:
self.freq = self.mc.getButton(0, 0) / 126.
self.amplitude = self.mc.getButton(0, 1)
self.timer.set_interval(self.mc.getButton(0, 2) / 126.)
self.x = math.sin(self.y * self.freq + self.phase
) * self.amplitude + self.offset + i
b = translate(i, 0, matrix_width, 0, 50)
g = translate(self.y, 0, matrix_height, 0, 80)
r = translate(self.x, 0, 12, 0, 24)
self.color = (255, 0, 0)
self.graphics.drawPixel(self.x, self.y, self.color)
return self.graphics.getSurface()
class Capture(object):
def __init__(self):
self.graphics = Graphics(matrix_height, matrix_width)
def generate(self):
self.graphics.fill(BLACK)
return self.graphics.getSurface()
class DisplayPng(object):
def __init__(self):
# image = '/home/robert/py-artnet/hacked.png'
# self.data = getPngPixelData(image)
# self.pixeldata = self.data[0]
self.graphics = Graphics(matrix_width, matrix_height)
def generate(self):
self.graphics.fill(BLACK)
return self.graphics.getSurface()
class GraphicsDotTest(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.color = (123, 111, 222)
def generate(self):
self.graphics.fill(BLACK)
for i in range(0, 5):
self.graphics.drawPixel(i, i, self.color)
return self.graphics.getSurface()
class GrayedLife(object):
'''
take the gray scales over every point and
add or subtract depening on if alive or not
'''
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.graphics.fill(BLUE)
def generate(self):
return self.graphics.getSurface()
class PatternDummy(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.color = BLACK
self.graphics.fill(self.color)
def generate(self):
return self.graphics.getSurface()
def __del__(self):
del self
class SegmentClock(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.segmentdisp = SegmentDisplay(self.graphics)
def generate(self):
self.graphics.fill(BLACK)
hour = time.localtime().tm_hour
minutes = time.localtime().tm_min
self.segmentdisp.drawnumbers(1, 0, hour, 2)
self.segmentdisp.drawnumbers(1, matrix_height / 2 + 1, minutes, 2)
return self.graphics.getSurface()
class VUmetertwo(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.controller = AudioController(channel=1, rate=256000, period=64)
self.color = BLUE
self.inputlength = matrix_height
self.inputs = []
self.offset = 13
self.max = 1250
self.lim = self.max
self.rate = 10
def getaverageof(self, number):
averages = []
for i in range(0, number):
data = self.controller.getinput()
while(data is None):
data = self.controller.getinput()
averages.append(data)
sums = 0
for num in averages:
sums += num
return int(sums / len(averages))
def getinputs(self):
self.inputs = []
sums = 0
for input in range(0, self.inputlength):
data = self.getaverageof(3)
self.inputs.append(data)
sums += data
return sums / len(self.inputs)
def generate(self):
average = self.getinputs()
self.graphics.fill(BLACK)
for i, line in enumerate(self.inputs):
if line > self.max:
self.max = line
else:
if self.max <= self.lim:
self.max = self.lim
else:
self.max -= int((self.max - self.lim) / self.rate)
length = int(translate(average, 0, self.max, 0, matrix_height))
data = int(translate(line, 0, average, 0, length))
if data > 0xff:
self.data = 0xff
if data > self.max:
self.max = data
self.graphics.drawLine(0, i, data - self.offset, i, self.color)
return self.graphics.getSurface()
class SegmentClocked(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.segmentdisp = SegmentDisplay(self.graphics)
self.previous = 1
def generate(self):
self.graphics.fill(BLACK)
current = time.time()
fps = int(1. / (current - self.previous))
self.segmentdisp.drawnumbers(0, 0, fps, 4)
self.previous = time.time()
return self.graphics.getSurface()
def __init__(self, speed=20):
self.graphics = Graphics(matrix_width, matrix_height)
self.plasma = Graphics(matrix_width, matrix_height)
self.x_range = xrange(0, matrix_width, 1)
self.y_range = xrange(0, matrix_height, 1)
self.interval = .1/speed #interval/speed is how many ticks a second.
self.time = 0
self.previousTick = 0
self.generatePalette()
self.generatePlasmaSurface()
class VUmeterThree(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.controller = AudioController(channel=1, rate=16000, period=64)
self.max = 1
def generate(self):
self.graphics.fill(BLACK)
data = getaverageof(10, self.controller)
data = int(translate(data, 0, 700, 0, 8))
for i in range(0, 17):
self.graphics.drawLine(0, i, data - 10, 0, BLUE)
return self.graphics.getSurface()
class SegmentCounter(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.timer = Timer(1 / 30.)
self.number = 0
self.segmentdisp = SegmentDisplay(self.graphics)
def generate(self):
self.graphics.fill(BLACK)
if self.timer.valid():
self.number += 1
self.segmentdisp.drawnumbers(0, 0, self.number, 4)
return self.graphics.getSurface()
class VUmeterone(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.controller = AudioController(channel=1, rate=8000, period=128)
self.average = []
self.averaged = 1
self.averagelength = 10
def generate(self):
data = getaverageof(10, self.controller)
if data:
data = int(translate(data, 0, 700, 0, 8))
self.graphics.fill(BLACK)
self.graphics.drawLine(0, 0, data - 10, 0, BLUE)
return self.graphics.getSurface()
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.color = GREEN
self.pos = (random.randint(1, matrix_width - 1),
random.randint(1, matrix_height - 1))
self.speed = 1
self.deltax, self.deltay = self.speed, self.speed
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.players = []
self.player = Player((9, 7), BLUE, self.graphics, self)
self.level = level1
class GraphicsLineTest(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.color = YELLOW
self.pos = 0, 0
def generate(self):
self.graphics.fill(BLACK)
x, y = self.pos
self.graphics.drawLine(matrix_width - x, matrix_height - y,
x, y, self.color)
if x >= matrix_height:
x = 0
y = 0
self.pos = x + 1, y
return self.graphics.getSurface()
def __init__(self, speed=1):
self.graphics = Graphics(matrix_width, matrix_height)
self.plasma = Graphics(matrix_width, matrix_height)
self.x_range = xrange(0, matrix_width, 1)
self.y_range = xrange(0, matrix_height, 1)
self.speed = speed
self.interval = 1000/self.speed
self.time = random.randint(0,100)
self.previousTick = 0
self.angle = 0
self.generatePalette()
self.generatePlasmaSurface()
def __init__(self, bcolor=GREEN, pcolor=BLUE, speed=matrix_height / 2, port="ACM", plugged=0):
self.graphics = Graphics(matrix_width, matrix_height)
# create a ball. multiple balls should be possible :)
self.ball = Ball((self.graphics.width / 2, self.graphics.height / 2),
bcolor, self.graphics)
# try to use the tty controller.
# but if it's not available use the automatic one.
try:
self.controller = PongController(plugged=plugged, port=port)
except Exception as e:
fmt = (e, )
fmtstr = "unable to find controllers playing on automatic\n>> %s"
print(fmtstr % fmt)
self.controller = PongControllerAuto(plugged=plugged, ball=self.ball)
# create two paddles
paddle1_pos = (0, 0)
self.paddle1 = (Paddle(paddle1_pos, pcolor, self.controller,
self.controller.POT1, self.graphics))
paddle2_pos = (0, matrix_height - 1)
self.paddle2 = (Paddle(paddle2_pos, pcolor, self.controller,
self.controller.POT2, self.graphics))
# timing variables used to controle the speed of the ball
self.start_speed = speed
# speed = pixels/s
self.speed = speed
self.previous = 0
self.print_score = False
class PlasmaFirst(object):
def __init__(self, speed=20):
self.graphics = Graphics(matrix_width, matrix_height)
self.plasma = Graphics(matrix_width, matrix_height)
self.x_range = xrange(0, matrix_width, 1)
self.y_range = xrange(0, matrix_height, 1)
self.interval = .1/speed #interval/speed is how many ticks a second.
self.time = 0
self.previousTick = 0
self.generatePalette()
self.generatePlasmaSurface()
def generatePalette(self):
self.palette = []
for x in xrange(0, 256, 1):
colorRGB = HSVtoRGB((x,255,255,))
self.palette.append(colorRGB)
def generatePlasmaSurface(self):
for y in self.y_range:
for x in self.x_range:
#c = int(abs(256*sin((x+y+self.time)/3.0)))
c = int(
128.0 + (128.0*sin((x+6)/2.4))
+128.0 + (128.0*cos(y/3.4))
)/2
color = (c,)*3
self.plasma.drawPixel(x,y,color)
return list(self.plasma.getSurface())
def process(self):
if( (time.time()-self.previousTick) >= self.interval ):
self.previousTick = time.time()
self.time += 1
paletteShift = self.time
for y in self.y_range:
for x in self.x_range:
plasma_color = self.plasma.readPixel(x,y)
color_shift = self.palette[paletteShift%256]
r = (plasma_color[0]+color_shift[0])%256
g = (plasma_color[1]+color_shift[1])%256
b = (plasma_color[2]+color_shift[2])%256
color = (r,g,b,)
color = ColorRGBOps.darken(color, 50)
self.graphics.drawPixel(x,y, color)
def draw(self):
pass
def generate(self):
self.graphics.fill(BLACK)
self.process()
self.draw()
return self.graphics.getSurface()
class Sven(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.color = randColor()
def generate(self):
self.graphics.fill(BLACK)
b = 0
i = 0
while(i <= 10):
color2 = randColor()
a = random.randint(0, matrix_width)
b = random.randint(0, matrix_height)
self.graphics.drawPixel(a, b, color2)
i = i + 1
b = b + 1
return self.graphics.getSurface()
class RandomLife(object):
def __init__(self):
self.life = Life(matrix_width, matrix_height, 1, color=BLACK)
self.graphics = Graphics(matrix_width, matrix_height)
def pickRandomColor(self):
color = random.randint(0, len(COLORS) - 1)
# make sure that that color isn't black
while(COLORS[color] == BLACK):
color = random.randint(0, len(COLORS) - 1)
return COLORS[color]
def drawRandomColor(self):
life_matrix = self.graphics.toMatrix(self.life.field,
self.graphics.getSurfaceWidth())
for y in self.graphics.heightRange:
for x in self.graphics.widthRange:
if life_matrix[y][x]:
color = self.pickRandomColor()
# give every lifing cell a random color
self.graphics.drawPixel(x, y, color)
else:
self.graphics.drawPixel(x, y, BLACK)
def draw(self):
self.drawRandomColor()
def generate(self):
self.life.process()
self.draw()
return self.graphics.getSurface()
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.controller = AudioController(channel=1, rate=256000, period=64)
self.color = BLUE
self.inputlength = matrix_height
self.inputs = []
self.offset = 13
self.max = 1250
self.lim = self.max
self.rate = 10
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.color = GREEN
self.x = 0
self.y = 0
self.x_offset = matrix_width / 2
self.y_offset = matrix_height / 2
self.angle = 0
self.radius = 5
self.timer = Timer(0.1)
class GraphicsPixelTest(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.color = GREEN
self.pos = (random.randint(1, matrix_width - 1),
random.randint(1, matrix_height - 1))
self.speed = 1
self.deltax, self.deltay = self.speed, self.speed
def generate(self):
self.graphics.fill(BLACK)
x, y = self.pos
self.graphics.drawPixel(x, y, self.color)
if x >= matrix_width - 1 or x <= 0:
self.deltax *= -1
if y >= matrix_height - 1 or y <= 0:
self.deltay *= -1
self.pos = x + self.deltax, y + self.deltay
return self.graphics.getSurface()
class BlueLife(object):
def __init__(self):
self.life = Life(matrix_width, matrix_height, 1, color=BLUE)
self.graphics = Graphics(matrix_width, matrix_height)
def draw(self):
life_matrix = self.graphics.toMatrix(self.life.field, self.graphics.getSurfaceWidth())
for y in self.graphics.heightRange:
for x in self.graphics.widthRange:
if life_matrix[y][x]:
color = BLUE
else:
color = BLACK
self.graphics.drawPixel(x, y, color)
def generate(self):
self.life.process()
self.draw()
return self.graphics.getSurface()
class DrawSegmentNumber(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.letter_width = 4
self.letter_height = 7
self.timer = Timer(1 / 2.)
self.number = 0
def generate(self):
self.graphics.fill(BLACK)
if self.timer.valid():
self.number += 1
if self.number > 9:
self.number = 0
for x, row in enumerate(numbers[self.number]):
for y, pixel in enumerate(row):
color = (0, 0, 0xff * pixel)
self.graphics.drawPixel(6 - x, y, color)
return self.graphics.getSurface()
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.graphics.fill(BLUE)
self.p = pyaudio.PyAudio()
self.stream = self.p.open(format=audio_params[0],
channels=audio_params[1],
rate=audio_params[2],
input=audio_params[3],
output=audio_params[4],
frames_per_buffer=audio_params[5])
self.color = BLUE
