|
1147
|
1 from __future__ import division
|
|
|
2 import time
|
|
|
3 import numpy
|
|
|
4 import logging
|
|
|
5 import imageio
|
|
|
6 from rdflib import Namespace, RDF, URIRef, Literal
|
|
|
7
|
|
|
8 ROOM = Namespace('http://projects.bigasterisk.com/room/')
|
|
|
9 log = logging.getLogger()
|
|
|
10
|
|
|
11 def _rgbFromHex(h):
|
|
|
12 rrggbb = h.lstrip('#')
|
|
|
13 return [int(x, 16) for x in [rrggbb[0:2], rrggbb[2:4], rrggbb[4:6]]]
|
|
|
14
|
|
|
15 class PixelColumnsFromImages(object):
|
|
|
16 # could use this instead:
|
|
|
17 # https://github.com/OpenImageIO/oiio/blob/master/src/python/py_imagecache.cpp
|
|
|
18 def __init__(self):
|
|
|
19 self.lastImg = None, None
|
|
|
20
|
|
|
21 def get(self, path, x, y, h):
|
|
|
22 if self.lastImg[0] != path:
|
|
1174
|
23 fp = 'config/' + path
|
|
|
24 self.lastImg = path, imageio.imread(fp) # or etcd or http
|
|
|
25 log.debug('read image from %r', fp)
|
|
1147
|
26 img = self.lastImg[1]
|
|
|
27
|
|
|
28 y = numpy.clip(y, 0, img.shape[0] - 1)
|
|
|
29 h = numpy.clip(h, 1, img.shape[0] - y)
|
|
|
30 x = numpy.clip(x, 0, img.shape[1] - 1)
|
|
|
31 log.info('getcol y=%s h=%s img=%r ret=%r', y, h, img.shape, img[y:y + h,x,:].shape)
|
|
|
32 return img[y:y + h,x,:]
|
|
|
33
|
|
|
34 getPixelColumn = PixelColumnsFromImages().get
|
|
|
35
|
|
|
36
|
|
|
37 class AnimChannel(object):
|
|
|
38 def __init__(self, x):
|
|
|
39 self.x = self.x2 = x
|
|
|
40 self.start = self.end = 0
|
|
|
41
|
|
|
42 def animTo(self, x2, rate):
|
|
|
43 self.get() # bring self.x to current time
|
|
|
44 log.info('animTo %s -> %s', self.x, x2)
|
|
|
45 if x2 == self.x:
|
|
|
46 return
|
|
|
47 self.start = time.time()
|
|
|
48 self.end = self.start + abs(x2 - self.x) / rate
|
|
|
49 self.x0 = self.x
|
|
|
50 self.x2 = x2
|
|
|
51
|
|
|
52 def get(self):
|
|
|
53 now = time.time()
|
|
|
54 if now > self.end:
|
|
|
55 self.x = self.x2
|
|
|
56 else:
|
|
|
57 dur = self.end - self.start
|
|
|
58 self.x = (self.end - now) / dur * self.x0 + (now - self.start) / dur * self.x2
|
|
|
59 return self.x
|
|
|
60
|
|
|
61 class ScanGroup(object):
|
|
|
62
|
|
|
63 def __init__(self, uri, numLeds):
|
|
|
64 self.uri = uri
|
|
|
65 self.current = numpy.zeros((numLeds, 3), dtype=numpy.uint8)
|
|
|
66
|
|
|
67 self.x = AnimChannel(0)
|
|
|
68 self.y = AnimChannel(0)
|
|
|
69 self.height = AnimChannel(numLeds)
|
|
|
70
|
|
|
71 def animateTo(self, x, y, height, src, rate=30, interpolate=ROOM['slide']):
|
|
|
72 log.info('anim to %s x=%s y=%s h=%s', src, x, y, height)
|
|
|
73 self.x.animTo(x, rate)
|
|
|
74 self.y.animTo(y, rate) # need separate y rate?
|
|
|
75 self.height.animTo(height, rate)
|
|
|
76
|
|
|
77 self.src = src
|
|
|
78
|
|
|
79 def updateCurrent(self):
|
|
|
80 try:
|
|
|
81 self.current = getPixelColumn(self.src,
|
|
|
82 int(self.x.get()),
|
|
|
83 int(self.y.get()),
|
|
|
84 int(self.height.get()))
|
|
1174
|
85 except IOError as e:
|
|
|
86 log.warn('getPixelColumn %r', e)
|
|
|
87 log.debug('current = %r', self.current)
|
|
1147
|
88
|
|
|
89 def currentStatements(self):
|
|
|
90 return []
|
|
|
91
|
|
|
92 def colorForIndex(self, i):
|
|
|
93 return list(self.current[i,:])
|
|
|
94
|
|
|
95 args = {ROOM['src']: ('src', str),
|
|
|
96 ROOM['x']: ('x', int),
|
|
|
97 ROOM['y']: ('y', int),
|
|
|
98 ROOM['height']: ('height', int),
|
|
|
99 ROOM['interpolate']: ('interpolate', lambda x: x),
|
|
|
100 ROOM['rate']: ('rate', float),
|
|
|
101 }
|
|
|
102
|
|
|
103
|
|
|
104 class RgbPixelsAnimation(object):
|
|
|
105
|
|
|
106 def __init__(self, graph, uri, updateOutput):
|
|
|
107 """we call updateOutput after any changes"""
|
|
|
108 self.graph = graph
|
|
|
109 self.uri = uri
|
|
|
110 self.updateOutput = updateOutput
|
|
|
111 self.setupGroups()
|
|
|
112
|
|
|
113 def setupGroups(self):
|
|
|
114 self.groups = {}
|
|
|
115 self.groupWithIndex = {}
|
|
|
116 attrStatements = set()
|
|
|
117 for grp in self.graph.objects(self.uri, ROOM['pixelGroup']):
|
|
|
118 s = int(self.graph.value(grp, ROOM['startIndex']))
|
|
|
119 e = int(self.graph.value(grp, ROOM['endIndex']))
|
|
|
120 log.info('ScanGroup %s from %s to %s', grp, s, e)
|
|
|
121 sg = ScanGroup(grp, e - s + 1)
|
|
|
122 self.groups[grp] = [s, e, sg]
|
|
|
123 for i in range(s, e + 1):
|
|
|
124 self.groupWithIndex[i] = sg, i - s
|
|
|
125 attrStatements.update(self.graph.triples((grp, None, None)))
|
|
|
126 self.onStatements(attrStatements, _groups=False)
|
|
|
127
|
|
|
128 def maxIndex(self):
|
|
|
129 return max(v[1] for v in self.groups.itervalues())
|
|
|
130
|
|
|
131 def hostStatements(self):
|
|
|
132 return (
|
|
|
133 [(self.uri, ROOM['pixelGroup'], grp) for grp in self.groups.keys()] +
|
|
|
134 sum([v[2].currentStatements()
|
|
|
135 for v in self.groups.itervalues()], []))
|
|
|
136
|
|
|
137 def getColorOrder(self, graph, uri):
|
|
|
138 colorOrder = graph.value(uri, ROOM['colorOrder'],
|
|
|
139 default=ROOM['ledColorOrder/RGB'])
|
|
|
140 head, tail = str(colorOrder).rsplit('/', 1)
|
|
|
141 if head != str(ROOM['ledColorOrder']):
|
|
|
142 raise NotImplementedError('%r colorOrder %r' % (uri, colorOrder))
|
|
|
143 stripType = None
|
|
|
144 return colorOrder, stripType
|
|
|
145
|
|
|
146 def step(self):
|
|
|
147 # if animating...
|
|
|
148 self.updateOutput()
|
|
|
149
|
|
|
150 def onStatements(self, statements, _groups=True):
|
|
|
151
|
|
|
152 needSetup = False
|
|
|
153 animateCalls = {} # group uri : kw for animateTo
|
|
|
154 for s, p, o in statements:
|
|
|
155 if s not in self.groups:
|
|
|
156 # missing the case that you just added a new group
|
|
|
157 continue
|
|
|
158 if p in args:
|
|
|
159 k, conv = args[p]
|
|
|
160 animateCalls.setdefault(s, {})[k] = conv(o.toPython())
|
|
|
161 else:
|
|
|
162 needSetup = True
|
|
|
163
|
|
|
164 if needSetup and _groups:
|
|
|
165 self.setupGroups()
|
|
|
166 for grp, kw in animateCalls.items():
|
|
|
167 for pred, (k, conv) in args.items():
|
|
|
168 if k not in kw:
|
|
|
169 v = self.graph.value(grp, pred)
|
|
|
170 if v is not None:
|
|
|
171 kw[k] = conv(v.toPython())
|
|
|
172
|
|
|
173 self.groups[grp][2].animateTo(**kw)
|
|
|
174
|
|
|
175 def outputPatterns(self):
|
|
|
176 pats = []
|
|
|
177 for grp in self.groups:
|
|
|
178 for attr in args:
|
|
|
179 pats.append((grp, attr, None))
|
|
|
180 return pats
|
|
|
181
|
|
|
182 def outputWidgets(self):
|
|
|
183 return []
|
|
|
184
|
|
|
185 def currentColors(self):
|
|
|
186 for _, _, sg in self.groups.values():
|
|
|
187 sg.updateCurrent()
|
|
|
188 for idx in range(self.maxIndex() + 1):
|
|
|
189 sg, offset = self.groupWithIndex[idx]
|
|
|
190 r, g, b = sg.colorForIndex(offset)
|
|
|
191 yield idx, (r, g, b)
|
