Collection for store a degradable history

log_queue.py

from collections import Iterable
import numpy as np
import math


class LogQueue(object):
    """Collection for store a degradable history"""
    def __init__(self, size=5, depth=1):
        super(LogQueue, self).__init__()
        self.items = []
        self.__len = 0
        self.queue = None
        self.depth = depth
        try:
            self.size = list(size)
            self._size = size[0]
        except:
            self.size = size
            self._size = size

    def __repr__(self):
        q = self.queue or ""
        order = "|"
        items = [("%-3d" % (self.items[i]) if len(self.items) > i else "-  ")
                 for i in range(self._size)]
        items = " ".join(items)
        return "%s %s %s" % (q, items, order)

    def __len__(self):
        return self.__len

    def __next_size(self):
        if (isinstance(self.size, Iterable)):
            return self.size[1:]
        else:
            return self.size

    def _summary(self):
        return (min(self.items) + max(self.items)) / 2
        #return sum(self.items) / float(len(self.items))

    def append(self, elem):
        if len(self.items) == self._size:
            if self.queue is None:
                self.queue = LogQueue(self.__next_size(), self.depth + 1)
            self.queue.append(self._summary())
            self.items = [elem]
        else:
            self.items.append(elem)
        self.__len += self.size ** (self.depth - 1)

    def __getitem__(self, index):
        xp = self.support()
        fp = self.values()
        return np.interp(index, xp, fp)

    def support(self):
        init = len(self.queue) if self.queue else 0
        end = len(self)
        n_items = len(self.items)
        delta = end - init
        if self.queue:
            r = self.queue.support()
        else:
            r = []
        if n_items > 1:
            r.extend([init + delta * (i + .5) / (n_items) for i in range(n_items)])
        else:
            r.append(init)
            #r.append( (end + init) / 2. )
        return r

    def values(self):
        q = self.queue and self.queue.values() or []
        self.items
        return q + self.items

    def all_lens(self):
        if self.queue:
            return self.queue.all_lens() + [len(self)]
        else:
            return [len(self)]


def size_max(factor, n_registers):
    size_max = 1
    for i in xrange(n_registers):
        size_max *= factor
        size_max += 1
    size_max -= 1
    return size_max

_COLORS = [
    (.8, 0., 0., 1.0),
    (0., .8, 0., 1.0),
    (0., 0., .8, 1.0),
    (0., .8, .8, 1.0),
    (.8, 0., .8, 1.0),
    (.8, .8, 0., 1.0),
    (.8, .5, .5, 1.0),
    (.5, .8, .5, 1.0),
    (.5, .5, .8, 1.0),
    (.5, .8, .8, 1.0),
    (.8, .5, .8, 1.0),
    (.8, .6, .5, 1.0),
    (.5, 0., 0., 1.0),
    (0., .5, 0., 1.0),
    (0., 0., .5, 1.0),
    (0., .5, .5, 1.0),
    (.5, 0., .5, 1.0),
    (.5, .5, 0., 1.0),
]


def pyglet(fun, qs, sm):
    import pyglet as pgl
    gl = pgl.gl
    window = pgl.window.Window(resizable=True)

    for q in qs:
        for i in xrange(sm):
            q.append(fun(i))

    @window.event
    def on_draw(n=[0]):
        n[0] += 1
        if n[0] % 2:
            return
        window.clear()

        gl.glColor4f(.995, .995, .995, 1)
        pgl.graphics.draw_indexed(4, pgl.gl.GL_TRIANGLES,
                                  [0, 1, 2, 0, 2, 3],
                                  ('v2i', (0, 0,
                                           1500, 0,
                                           1500, 1500,
                                           0, 1500))
                                  )

        pgl.image.SolidColorImagePattern((200, 200, 200, 200))
        gl.glColor4f(0, 0, 0, 1)

        last = [0, 0]
        for i in xrange(sm):
            current = [i, fun(sm - i)]
            line = tuple(last + current)
            pgl.graphics.draw(2, gl.GL_LINES, ('v2i', line))
            pgl.graphics.draw(2, gl.GL_LINES, ('v2i', line))
            last = current

        for c, q in enumerate(reversed(qs)):
            gl.glColor4f(*_COLORS[c])
            last2 = [0, 0]
            for j in xrange(sm):
                current2 = [j, int(q[sm - j])]
                line2 = tuple(last2 + current2)

                pgl.graphics.draw(2, gl.GL_LINES, ('v2i', line2))
                last2 = current2

    pgl.app.run()


def _example_function(i):
    r = (i / 2 + (math.sin(i / 50.) * 100) + (20 * np.sqrt(np.abs(700 - i))))
    return int(.7 * (-410 + r))
    return 200 + int(math.sin(i / 50.) * 100)
    return i / 2


def main():
    size = 3
    sm = size_max(size, 3)
    q = LogQueue(size)

    for i in xrange(sm):
        q.append(_example_function(i))
        #print q, q.all_lens(), q.support()
        print q

    print q, q.all_lens()

    for i in xrange(0, sm, sm / 10):
        print i, q[i]

    try:
        pass
        qs = [LogQueue(i) for i in range(2, 12)]
        pyglet(_example_function, qs, 1350)
    except ImportError:
        print "No tiene pyglet instalado"

if __name__ == '__main__':
    main()