def refresh(self, matrix): # this relies on the fact that the pixels we seed get multiplied and # overfow the uint8 in intresting ways matrix.blur(3) matrix.buf.buf = (self.mult*matrix.buf.buf).astype(np.uint8) self.amp += DELTA_AMP if self.amp >= 1 and False: self.amp = 0 self.hue += DELTA_HUE self.ang += DELTA_ANG xcenter = matrix.width / 2.0 ycenter = matrix.height / 2.0 amp = sin(self.amp) tx = amp * sin(self.ang) ty = amp * cos(self.ang) x = xcenter + xcenter * tx y = ycenter + ycenter * ty color = hsvToRgb(fmod(self.hue, 1), 1, 1) matrix.drawPixel(x, y, color) self.train.add(matrix, x, y)
def _setCell(self, matrix, addr, neighbors): x, y = self._decode(addr) matrix.drawPixel(x, y, hsvToRgb(self.hue, 1, 1), self.value) self.filling[addr] = neighbors self.value -= self.deltaValue return self.value <= 0
def _color(self): self.offset += 1 if self.contiguous: hue = 0.0 + (self.offset+2*self.base) % 256 return hsvToRgb(hue/255) index = ((self.base+self.offset)/self.blocksize) % self.huecount hue = self.hues[int(index)] phase = (self.base+self.offset) % self.blocksize value = self.sinlut[phase] self.usecount[int(index)] += 1 return hsvToRgb(hue, 1, value)
def refresh(self, matrix): # this relies on the fact that the pixels we seed get multiplied and # overfow the uint8 in intresting ways matrix.blur(3) matrix.buf.buf = (self.mult * matrix.buf.buf).astype(np.uint8) self.amp += DELTA_AMP if self.amp >= 1 and False: self.amp = 0 self.hue += DELTA_HUE self.ang += DELTA_ANG xcenter = matrix.width / 2.0 ycenter = matrix.height / 2.0 amp = sin(self.amp) tx = amp * sin(self.ang) ty = amp * cos(self.ang) x = xcenter + xcenter * tx y = ycenter + ycenter * ty color = hsvToRgb(fmod(self.hue, 1), 1, 1) matrix.drawPixel(x, y, color) self.train.add(matrix, x, y)
def _color(self): self.offset += 1 if self.contiguous: hue = 0.0 + (self.offset + 2 * self.base) % 256 return hsvToRgb(hue / 255) index = ((self.base + self.offset) / self.blocksize) % self.huecount hue = self.hues[index] phase = (self.base + self.offset) % self.blocksize value = self.sinlut[phase] self.usecount[index] += 1 return hsvToRgb(hue, 1, value)
def refresh(self, matrix): matrix.shift(ds=0.75, dv=0.9) self.x = self.x + self.dx*self.dt self.y = self.y + self.dy*self.dt absdx, absdy = fabs(self.dx), fabs(self.dy) if self.x < self.radius: self.dx = absdx elif self.x >= (matrix.width-self.radius-1): self.dx = -absdx if self.y < self.radius: self.dy = absdy elif self.dy < 0.2 and self.dy > 0: self.dy = -absdy self.dy = self.dy - self.accel*self.dt if self.dy < 0 and self.y < self.radius: self._reset(matrix) else: matrix.fillCircle(self.x, self.y, self.radius, hsvToRgb(self.color))
def refresh(self, matrix): matrix.fade(0.995) y0 = matrix.height/2 x0 = matrix.width/2 if self.angle >= pi: x0 -= 1 if self.angle > (0.5*pi) and self.angle < (1.5*pi): y0 -= 1 x1 = int(self.x0 + self.radius * sin(self.angle-self.astep)) y1 = int(self.y0 + self.radius * cos(self.angle+self.astep)) x2 = int(self.x0 + self.radius * sin(self.angle)) y2 = int(self.y0 + self.radius * cos(self.angle)) matrix.drawPoly( [(self.x0, self.y0), (x1, y1), (x2, y2)], hsvToRgb(self.hue) ) self.hue = fmod(self.hue+self.hstep, 1.0) self.angle += self.astep
def refresh(self, matrix): matrix.shift(ds=0.75, dv=0.9) self.x = self.x + self.dx * self.dt self.y = self.y + self.dy * self.dt absdx, absdy = fabs(self.dx), fabs(self.dy) if self.x < self.radius: self.dx = absdx elif self.x >= (matrix.width - self.radius - 1): self.dx = -absdx if self.y < self.radius: self.dy = absdy elif self.dy < 0.2 and self.dy > 0: self.dy = -absdy self.dy = self.dy - self.accel * self.dt if self.dy < 0 and self.y < self.radius: self._reset(matrix) else: matrix.fillCircle(self.x, self.y, self.radius, hsvToRgb(self.color))
def refresh(self, matrix): self.base += 1 for x in range(matrix.width): hue = ((self.base+32*x) % 1024)/1024.0 for y in range(matrix.height): pcent50 = 0.50*float(y)/(matrix.height-1) sat = .5 + pcent50 val = 1 - pcent50 matrix.drawPixel(x, y, hsvToRgb(hue, sat, val))
def refresh(self, matrix): self.base += 4 h = matrix.height - 1 for x in range(matrix.width): hue = (self.base + 32 * x) / (sqrt(matrix.numpix) * 64.0) for y in range(matrix.height): sat = min(1, 0.25 + (1.5 * y) / h) val = min(1, 0.25 + (1.5 * (h - y) / h)) matrix.drawPixel(x, y, hsvToRgb(hue, sat, val))
def update(self, matrix): self.value += 0.2 matrix.fillRect( self.x, self.y, self.w, self.h, hsvToRgb(h=self.hue, v=self.value), ) return self.value < 1
def refresh(self, matrix): self.base += 4 h = matrix.height - 1 for x in range(matrix.width): hue = ((self.base+32*x) % 1024)/1024.0 for y in range(matrix.height): sat = min(1, 0.25 + (1.5*y)/h) val = min(1, 0.25 + (1.5*(h-y)/h)) matrix.drawPixel(x, y, hsvToRgb(hue, sat, val))
def refresh(self, matrix): try: pos = next(self.random) except: self.random = compoundLfsr(matrix.numpix) pos = next(self.random) # gently transition through all hues over HUEINCYCLES fills self.hue += 1.0/(matrix.numpix*HUEINCYCLES) color = hsvToRgb(self.hue, 1, 0.2+0.8*random()) matrix.setStripPixel(pos, color)
def _render(self, matrix, target): grid = self.mandel.draw(target) matrix.clear() for x in range(matrix.width): for y in range(matrix.height): point = grid[x][y] if point is not None: hue = (0.0+point)/self.mandel.maxsteps matrix.drawPixel(x, y, hsvToRgb(hue))
def refresh(self, matrix): try: pos = self.random.next() except: self.random = compoundLfsr(matrix.numpix) pos = self.random.next() # gently transition through all hues over HUEINCYCLES fills self.hue += 1.0/(matrix.numpix*HUEINCYCLES) color = hsvToRgb(self.hue, 1, 0.2+0.8*random()) matrix.setStripPixel(pos, color)
def refresh(self, matrix): self.huebase = self.huebase + 0.001 # canvas for us to write to field = np.empty((matrix.width, matrix.height)) # linearize x and y coordinates for regions xs = np.array([region["x"] for region in self.regions]) ys = np.array([region["y"] for region in self.regions]) # find closest region to eack pixel for y in range(matrix.height): for x in range(matrix.width): c = self._closest(xs, ys, x, y) field[x, y] = self.huebase + c / self.count # update region coordinates self.regions = [{ "dx": self._bounce(region["x"], region["dx"], matrix.width - 1), "dy": self._bounce(region["y"], region["dy"], matrix.height - 1), "x": region["x"] + region["dx"], "y": region["y"] + region["dy"], } for region in self.regions] # blend old and new if self.field is not None: self.field = (self.field * 0.3) + (field * 0.7) else: self.field = field # draaw for y in range(matrix.height): for x in range(matrix.width): matrix.drawPixel(x, y, hsvToRgb(self.field[x, y], 1, 1)) for region in self.regions: matrix.drawPixel(region["x"], region["y"], hsvToRgb(1, 0, 0))
def update(self, matrix, expires): decay = 1-(float(self.age)/expires) color = hsvToRgb(self.hue, 1, decay) matrix.drawPixel(self.x, self.y, color) self.x += self.dx if self.x == 0 or self.x >= (matrix.width-1): self.dx = -self.dx self.y += self.dy if self.y == 0 or self.y >= (matrix.height-1): self.dy = -self.dy
def update(self, matrix, expires): decay = 1 - (float(self.age) / expires) color = hsvToRgb(self.hue, 1, decay) matrix.drawPixel(self.x, self.y, color) self.x += self.dx if self.x == 0 or self.x >= (matrix.width - 1): self.dx = -self.dx self.y += self.dy if self.y == 0 or self.y >= (matrix.height - 1): self.dy = -self.dy
def refresh(self, matrix): hue = next(self.hue) # pixels per squre pps = int((sqrt(matrix.numpix)-1)/GRIDSIZE) xcorner = matrix.midWidth - pps*(GRIDSIZE/2) ycorner = matrix.midHeight - pps*(GRIDSIZE/2) matrix.drawRect(xcorner-1, ycorner-1, pps*GRIDSIZE+1, pps*GRIDSIZE+1, C_BORDER) for x in range(GRIDSIZE): for y in range(GRIDSIZE): black = (x & 1) ^ (y & 1) if black: color = hsvToRgb(hue, s=0.7, v=0.5) else: color = hsvToRgb(hue + 0.2, v=0.8) matrix.fillRect(xcorner+pps*x, ycorner+pps*y, pps, pps, color)
def refresh(self, matrix): hue = next(self.hue) # pixels per squre pps = int((sqrt(matrix.numpix) - 1) / GRIDSIZE) xcorner = matrix.midWidth - pps * (GRIDSIZE / 2) ycorner = matrix.midHeight - pps * (GRIDSIZE / 2) matrix.drawRect(xcorner - 1, ycorner - 1, pps * GRIDSIZE + 1, pps * GRIDSIZE + 1, C_BORDER) for x in range(GRIDSIZE): for y in range(GRIDSIZE): black = (x & 1) ^ (y & 1) if black: color = hsvToRgb(hue, s=0.7, v=0.5) else: color = hsvToRgb(hue + 0.2, v=0.8) matrix.fillRect(xcorner + pps * x, ycorner + pps * y, pps, pps, color)
def clock(self, matrix): if not self.persist: matrix.drawPixel(self.x, self.y, BLACK) self.x += self.dx if (self.x < 1 and self.dx < 0) or \ (self.x >= self.w-1 and self.dx > 0): self.ax(x=True) self.y += self.dy if (self.y < 1 and self.dy < 0) or \ (self.y >= self.h-1 and self.dy > 0): self.ay(y=True) if self.radius == 0: matrix.drawPixel(self.x, self.y, hsvToRgb(self.hue, v=self.value)) else: matrix.fillCircle(self.x, self.y, self.radius, hsvToRgb(self.hue, v=self.value)) self.hue = fmod(self.hue + self.huedelta, 1)
def _draw(self, matrix): x = matrix.width*random() y = self.center.y + (self.pieslice[0][1]-self.center.y)*random() z = 2 + random()*10/self.freq if random() < 0.1: color = WHITE else: offset = int(random()*4)/4.0 if random() < 0.5 else 0 color = hsvToRgb(offset+self.hue.next(), 1, 1) if random() < 0.5: matrix.drawRect(x, y, z, z, color) else: matrix.fillRect(x, y, z, z, color)
def refresh(self, matrix): minval, maxval = (10, -10) for y in range(matrix.height): for x in range(matrix.width): hue = ( sin(self._dist(x + self.base, y, 128.0, 128.0) / 8.0) + sin(self._dist(y, y, 64.0, 64.0) / 8.0) + sin(self._dist(x, y + self.base / 7, 192.0, 64) / 7.0) + sin(self._dist(y, x, 192.0, 100.0) / 8.0)) hue = fmod(fabs(1+hue/2), 1.0) matrix.drawPixel(x, y, hsvToRgb(hue)) self.base+=0.1
def _draw(self, matrix): x = matrix.width * random() y = self.center.y + (self.pieslice[0][1] - self.center.y) * random() z = 2 + random() * 10 / self.freq if random() < 0.1: color = WHITE else: offset = int(random() * 4) / 4.0 if random() < 0.5 else 0 color = hsvToRgb(offset + self.hue.next(), 1, 1) if random() < 0.5: matrix.drawRect(x, y, z, z, color) else: matrix.fillRect(x, y, z, z, color)
def translate(self, matrix, hue=None, colormap=None): if hue is None and colormap is None: raise AttributeError("Need either a hue or colormap") vmin = np.min(self.values) vmax = np.max(self.values) values = (self.values-vmin)/(vmax-vmin) if colormap is None: for x in range(self.width): for y in range(self.height): color = hsvToRgb(hue+values[x, y]/5, 1, values[x, y]) matrix.drawPixel(x, y, color) else: buffer = colormap.apply(values) matrix.copyBuffer(buffer)
def translate(self, matrix, hue=None, colormap=None): if hue is None and colormap is None: raise AttributeError("Need either a hue or colormap") vmin = np.min(self.values) vmax = np.max(self.values) values = (self.values - vmin) / (vmax - vmin) if colormap is None: for x in range(self.width): for y in range(self.height): color = hsvToRgb(hue + values[x, y] / 5, 1, values[x, y]) matrix.drawPixel(x, y, color) else: buffer = colormap.apply(values) matrix.copyBuffer(buffer)
def refresh(self, matrix): self.matrix.clear() self.hue += 1.0 / (6 * 4 * matrix.width) for y, z in enumerate(self.ys): val = (1 + sin(radians(360 * z))) / 2 self.matrix.drawPixel(self.x, y, hsvToRgb(self.hue, 1, val)) self.ys = [y + 0.08 * random() for y in self.ys] self.x = (self.x + 1) % matrix.width self.matrix.maskbelow(55, BLACK) matrix.fade(0.99) matrix.add(self.matrix)
def clock(self, matrix): if not self.persist: self._plot(matrix, BLACK) self.x += self.dx if (self.x < 1 and self.dx < 0) or \ (self.x >= self.w-1 and self.dx > 0): self.ax(x=True) self.y += self.dy if (self.y < 1 and self.dy < 0) or \ (self.y >= self.h-1 and self.dy > 0): self.ay(y=True) self._plot(matrix, hsvToRgb(self.hue, s=self.saturation, v=self.value)) self.hue = fmod(self.hue + self.huedelta, 1)
def refresh(self, matrix): self.matrix.clear() self.hue += 1.0/(6*4*matrix.width) for y, z in enumerate(self.ys): val = (1+sin(radians(360*z)))/2 self.matrix.drawPixel(self.x, y, hsvToRgb(self.hue, 1, val)) self.ys = [y+0.08*random() for y in self.ys] self.x = (self.x+1)%matrix.width self.matrix.maskbelow(55, BLACK) matrix.fade(0.99) matrix.add(self.matrix)
def refresh(self, matrix): matrix.fade(0.97) self.amp += DELTA_AMP self.hue += DELTA_HUE self.ang += DELTA_ANG amp = sin(self.amp) tx = amp * sin(self.ang) ty = amp * cos(self.ang) x = matrix.midWidth + matrix.midWidth * tx y = matrix.midHeight + matrix.midHeight * ty color = hsvToRgb(fmod(self.hue, 1), 1, 1) matrix.fillRect(x-self.radius, y-self.radius, 2*self.radius, 2*self.radius, color)
def _translate(self, matrix, hue, colormap): vmin = 100.0 vmax = -100.0 for x in range(self.width): for y in range(self.height): value = self.values[x][y] vmin = min(value, vmin) vmax = max(value, vmax) vscale = 1.0/(vmax-vmin) for x in range(self.width): for y in range(self.height): value = vscale * (self.values[x][y] - vmin) if hue is not None: color = hsvToRgb(hue+value/5, 1, value) else: color = colormap.convert(value, 1) matrix.drawPixel(x, y, color)
def clock(self, matrix): if self.theta: self.angle += self.theta mx, my = sin(self.angle), cos(self.angle) else: mx, my = 1, 1 if not self.persist: matrix.drawPixel(self.x, self.y, BLACK) self.x += self.dx if (self.x < 1 and self.dx < 0) or (self.x >= self.w-1 and self.dx > 0): self.ax(x=True) self.y += self.dy if (self.y < 1 and self.dy < 0) or (self.y >= self.h-1 and self.dy > 0): self.ay(y=True) matrix.drawPixel(self.x, self.y, hsvToRgb(self.hue, v=self.value)) self.hue = fmod(self.hue + self.huedelta, 1)
def refresh(self, matrix): """ For any pair of colors represented as a hue, we need to calculate the distance between those two hues for each of the rgb components of the color. For the set of four corners, we have to interpolate each gun independently. """ rgbs = self._rotate([hsvToRgb(self.cornerValues[i]) for i in range(4)]) for x in range(matrix.width): px = self._percent(x, matrix.width) for y in range(matrix.height): py = self._percent(y, matrix.height) rgb = self._interpolate(rgbs, px, py) matrix.drawPixel(x, y, rgb) for i in range(4): new = self.cornerValues[i] + self.cornerValueDeltas[i] self.cornerValues[i] = fmod(new, 1.0) if self.bits is not None: matrix.buf.downSample(self.bits)
def refresh(self, matrix): self.amp += DELTA_AMP if self.amp >= 1 and False: self.amp = 0 self.hue += DELTA_HUE self.ang += DELTA_ANG xcenter = matrix.width / 2.0 ycenter = matrix.height / 2.0 amp = sin(self.amp) tx = amp * sin (self.ang) ty = amp * cos (self.ang) x = xcenter + xcenter * tx y = ycenter + ycenter * ty color = hsvToRgb(fmod(self.hue, 1), 1, 1) matrix.drawPixel(x, y, color) self.train.add(matrix, x, y)
def refresh(self, matrix): """ For any pair of colors represented as a hue, we need to calculate the distance between those two hues for each of the rgb components of the color. For the set of four corners, we have to interpolate each gun independently. """ rgbs = self._rotate([ hsvToRgb(self.cornerValues[i]) for i in range(4) ]) for x in range(matrix.width): px = self._percent(x, matrix.width) for y in range(matrix.height): py = self._percent(y, matrix.height) rgb = self._interpolate(rgbs, px, py) matrix.drawPixel(x, y, rgb) for i in range(4): new = self.cornerValues[i] + self.cornerValueDeltas[i] self.cornerValues[i] = fmod(new, 1.0) if self.bits is not None: matrix.buf.downSample(self.bits)
def translate(self, matrix, hue=None, colormap=None): vmin = 100.0 vmax = -100.0 if hue is None and colormap is None: raise AttributeError("Need either a hue or colormap") for x in range(self.width): for y in range(self.height): value = self.values[x][y] vmin = min(value, vmin) vmax = max(value, vmax) vscale = 1.0/(vmax-vmin) for x in range(self.width): for y in range(self.height): value = vscale * (self.values[x][y] - vmin) if hue is not None: color = hsvToRgb(hue+value/5, 1, value) else: color = colormap.convert(value, 1) matrix.drawPixel(x, y, color)
def __init__(self, matrix, horizontal): # increments are split into primary and secondary. primary items(p) # increase on subsequent calls, secondary increments happen within # a call to draw a row. if horizontal: self.pdx, self.pdy = 0, 1 self.sdx, self.sdy = 1, 0 else: self.pdx, self.pdy = 1, 0 self.sdx, self.sdy = 0, 1 if self._cointoss(0.1): self.color = WHITE else: self.color = hsvToRgb(random(), self._stepped(), self._stepped()) cycleSize = int(sqrt(matrix.width * matrix.height) / REPEATS) self.bits = [True] # bits can't be all True or all false while not any(self.bits) or all(self.bits): self.bits = [self._cointoss(0.3) for bit in range(cycleSize)] self.px, self.py = 0, 0
def __init__(self, matrix, horizontal): # increments are split into primary and secondary. primary items(p) # increase on subsequent calls, secondary increments happen within # a call to draw a row. if horizontal: self.pdx, self.pdy = 0, 1 self.sdx, self.sdy = 1, 0 else: self.pdx, self.pdy = 1, 0 self.sdx, self.sdy = 0, 1 if self._cointoss(0.1): self.color = WHITE else: self.color = hsvToRgb(random(), self._stepped(), self._stepped()) cycleSize = int(sqrt(matrix.width*matrix.height)/REPEATS) self.bits = [True] # bits can't be all True or all false while not any(self.bits) or all(self.bits): self.bits = [self._cointoss(0.3) for bit in range(cycleSize)] self.px, self.py = 0, 0
def _hue(self, offset): return hsvToRgb(self.hue + HSCALE * offset)
def _line(self, matrix, x1, x2, hue): color = hsvToRgb(hue, 1, 1) matrix.drawLine( x1, 0, x2, 0, color)
def _line(self, matrix, x1, x2, hue): color = hsvToRgb(hue, 1, 1) matrix.drawLine(x1, 0, x2, 0, color)
def _line(self, matrix, x1, x2, hue): for x in range(x1, x2): val = 0.8 + 0.2 * random() matrix.drawPixel(x, 0, hsvToRgb(hue, 1, val))