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