Python Graphics.getSurface方法代码示例

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import getSurface [as 别名]
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()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import getSurface [as 别名]
class Capture(object):
    def __init__(self):
        self.graphics = Graphics(matrix_height, matrix_width)

    def generate(self):
        self.graphics.fill(BLACK)
        return self.graphics.getSurface()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import getSurface [as 别名]
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()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import getSurface [as 别名]
class TestPattern(object):
    def __init__(self):
        self.graphics = Graphics(matrix_width, matrix_height)
    
    def generate(self):
        self.graphics.fill(WHITE)
        return self.graphics.getSurface()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import getSurface [as 别名]
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()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import getSurface [as 别名]
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()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import getSurface [as 别名]
class VuBarVertiPir(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
        self.max = 0

    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):
        self.graphics.fill(BLACK)
        audio = self.getaudio()
        self.color = interp_color(rms(audio/10000))
        self.color = color_convert(self.color)
        for i in range(0, matrix_height):
            rmsed = translate(rms(audio), 0, ((2**16)/2), 0, matrix_width*i)
            self.graphics.drawLine(0, i, rmsed, i, self.color)
        return self.graphics.getSurface()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import getSurface [as 别名]
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()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import getSurface [as 别名]
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()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import getSurface [as 别名]
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()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import getSurface [as 别名]
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

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import getSurface [as 别名]
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()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import getSurface [as 别名]
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()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import getSurface [as 别名]
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()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import getSurface [as 别名]
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()