You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

181 lines
5.1 KiB

#!/usr/bin/env python3
8 years ago
# inspired by:
# http://lodev.org/cgtutor/plasma.html
import sys
import time
import math
import colorsys
import blup.frame
import blup.output
import blup.animation
import blup.writebml
import argparse
WIDTH = 22
HEIGHT = 16
DEPTH = 256
8 years ago
class Plasma(object):
def __init__(self, width, height, test_palette=False, zoom=1):
self.width = width
self.height = height
self.test_palette = test_palette
self.zoom = zoom
self.pixelvalues = [[0] * height for i in range(width)]
self.pixelsReady = False
self.offset = 0
self.update()
@property
def minValue(self):
return min(list(map(min, self.pixelvalues)))
@property
def maxValue(self):
return max(list(map(max, self.pixelvalues)))
def applyPalette(self, palette):
min = self.minValue
max = self.maxValue
norm = lambda x: ((x - min) / max)
pixeldata = [ [None] * self.height for i in range(self.width) ]
for x in range(self.width):
rowvalues = self.pixelvalues[x]
for y in range(self.height):
if y == 0 and self.test_palette:
pixeldata[x][y] = palette.getColorValue(x/(self.width-1))
else:
pixeldata[x][y] = palette.getColorValue(norm(rowvalues[y]))
return pixeldata
def update(self):
#if self.pixelsReady:
# return
self.offset += 1
for x in range(self.width):
for y in range(self.height):
xx = x+self.offset
yy = y+self.offset
p = 128 + 128 * math.sin(xx / 9.0 * self.zoom)
p += 128 + 128 * math.sin(yy / 16.0 * self.zoom)
p += 128 + 128 * math.sin((yy + xx) / 16.0 * self.zoom)
p += 128 + 128 * math.sin(math.sqrt(yy*yy + xx*xx * self.zoom) / 16.0)
p += 128 + 8 * math.sin(math.sqrt(yy* xx * self.zoom) / 16.0)
self.pixelvalues[x][y] = p
self.pixelsReady = True
8 years ago
class HSVPalette(object):
def __init__(self, depth):
self.offset = 0
self.cache = {}
self.depth = depth
def getColorValue(self, x):
x = round(x, 3)
if x in self.cache:
return self.cache[x]
c = colorsys.hsv_to_rgb((x + self.offset) % 1, 1, 1)
c = list(map(lambda x: int(x * (self.depth - 1)), c))
self.cache[x] = c
return c
def update(self):
self.cache = {}
self.offset += 0.01
if self.offset > 1:
self.offset -= 1
8 years ago
class ExponentialHSVPalette(object):
def __init__(self, depth):
self.offset = 0
self.cache = {}
self.depth = depth
8 years ago
def getColorValue(self, x):
x = round(x, 3)
if x in self.cache:
return self.cache[x]
xx = (x + self.offset) % 1
a = 4
b = 3
c = colorsys.hsv_to_rgb((a**(xx*b)-1)/(a**b), 1, 1)
c = list(map(lambda x: int(x * (self.depth - 1)), c))
self.cache[x] = c
return c
8 years ago
def update(self):
self.cache = {}
self.offset += 0.01
if self.offset > 1:
self.offset -= 1
8 years ago
class SingleColorPalette(object):
def __init__(self, depth):
self.cache = {}
self.depth = depth
self.h = 0
def getColorValue(self, x):
x = round(x, 3)
if x in self.cache:
return self.cache[x]
a = 4
b = 3
c = colorsys.hsv_to_rgb(self.h, 1, (a**(x*b)-1)/(a**b))
c = list(map(lambda x: int(x * (self.depth - 1)), c))
self.cache[x] = c
return c
8 years ago
def update(self):
self.cache = {}
self.h += 0.005
if self.h > 1:
self.h -= 1
8 years ago
##############################################
8 years ago
PALETTES = {
'hsv': HSVPalette,
'exponentialhsv': ExponentialHSVPalette,
'singlecolor': SingleColorPalette,
}
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Generate plasma animations')
parser.add_argument('-d', '--delay', type=int, default=50)
parser.add_argument('-n', '--num-frames', type=int, default=200)
parser.add_argument('-p', '--palette', choices=PALETTES.keys(), default='hsv')
parser.add_argument('-z', '--zoom', type=float, default=1)
parser.add_argument('--test-palette', action='store_true')
parser.add_argument('output_file')
args = parser.parse_args()
plasma = Plasma(WIDTH, HEIGHT, args.test_palette, zoom=args.zoom)
dim = blup.frame.FrameDimension(WIDTH, HEIGHT, DEPTH, 3)
palette = PALETTES[args.palette](DEPTH)
8 years ago
anim = blup.animation.Animation(dim)
anim.tags['description'] = ' '.join(sys.argv)
for i in range(args.num_frames):
palette.update()
plasma.update()
pixeldata = plasma.applyPalette(palette)
frame = blup.animation.AnimationFrame(dim, args.delay)
for x in range(WIDTH):
for y in range(HEIGHT):
frame.setPixel(x, y, pixeldata[x][y])
anim.addFrame(frame)
8 years ago
blup.writebml.writeBml(anim, args.output_file)