Python Graphics.drawPixel方法代码示例

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import drawPixel [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 drawPixel [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 drawPixel [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 drawPixel [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 drawPixel [as 别名]
class Sven(object):
    def __init__(self):
        self.graphics = Graphics(matrix_width, matrix_height)
        self.color = randColor()

    def generate(self):
        self.graphics.fill(BLACK)
        b = 0
        i = 0
        while(i <= 10):
            color2 = randColor()
            a = random.randint(0, matrix_width)
            b = random.randint(0, matrix_height)
            self.graphics.drawPixel(a, b, color2)
            i = i + 1
        b = b + 1
        return self.graphics.getSurface()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import drawPixel [as 别名]
class BlueLife(object):
    def __init__(self):
        self.life = Life(matrix_width, matrix_height, 1, color=BLUE)
        self.graphics = Graphics(matrix_width, matrix_height)

    def draw(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 = BLUE
                else:
                    color = BLACK
                self.graphics.drawPixel(x, y, color)

    def generate(self):
        self.life.process()
        self.draw()
        return self.graphics.getSurface()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import drawPixel [as 别名]
class DrawSegmentNumber(object):
    def __init__(self):
        self.graphics = Graphics(matrix_width, matrix_height)
        self.letter_width = 4
        self.letter_height = 7
        self.timer = Timer(1 / 2.)
        self.number = 0

    def generate(self):
        self.graphics.fill(BLACK)
        if self.timer.valid():
            self.number += 1
            if self.number > 9:
                self.number = 0
        for x, row in enumerate(numbers[self.number]):
            for y, pixel in enumerate(row):
                color = (0, 0, 0xff * pixel)
                self.graphics.drawPixel(6 - x, y, color)
        return self.graphics.getSurface()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import drawPixel [as 别名]
class GraphicsPixelTest(object):
    def __init__(self):
        self.graphics = Graphics(matrix_width, matrix_height)
        self.color = GREEN
        self.pos = (random.randint(1, matrix_width - 1),
                    random.randint(1, matrix_height - 1))
        self.speed = 1
        self.deltax, self.deltay = self.speed, self.speed

    def generate(self):
        self.graphics.fill(BLACK)
        x, y = self.pos
        self.graphics.drawPixel(x, y, self.color)
        if x >= matrix_width - 1 or x <= 0:
            self.deltax *= -1
        if y >= matrix_height - 1 or y <= 0:
            self.deltay *= -1
        self.pos = x + self.deltax, y + self.deltay
        return self.graphics.getSurface()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import drawPixel [as 别名]
class SuperPixelBros(object):
    """
    SuperPixelBros is a class that hanles function calling and processing.
    makes sure the level is generated.
    makes sure the player get the right data.

    """
    def __init__(self):
        self.graphics = Graphics(matrix_width, matrix_height)

        self.players = []
        self.player = Player((9, 7), BLUE, self.graphics, self)

        self.level = level1

    def handleInput(self):
        self.player.handleInput()

    def process(self):
        self.player.process()

    def draw(self):
        self.graphics.fill(BLACK)
        # draw the map.
        surfaceheight = self.graphics.getSurfaceHeight()
        level_matrix = self.graphics.toMatrix(self.level, surfaceheight)
        for y in self.graphics.heightRange:
            for x in self.graphics.widthRange:
                tile = level_matrix[x][y]
                # draw the map flipped
                self.graphics.drawPixel(self.graphics.width - x - 1, y, tile)

        # draw the player.
        self.player.draw()

    def generate(self):
        # self.handleInput()
        # self.process()
        # self.draw()
        return self.graphics.getSurface()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import drawPixel [as 别名]
class Test(object):
    def __init__(self):
        self.graphics = Graphics(matrix_width, matrix_height)
        self.color = GREEN
        self.x = 0
        self.y = 0
        self.x_offset = matrix_width / 2
        self.y_offset = matrix_height / 2
        self.angle = 0
        self.radius = 5
        self.timer = Timer(0.1)
    def generate(self):
        self.graphics.fill(BLACK)
        for i in range(0, 360):
            self.x = math.sin(math.radians(i)) * self.radius + self.x_offset
            self.y = math.cos(math.radians(i)) * self.radius + self.y_offset
            self.graphics.drawPixel(self.x, self.y, self.color)
        #if self.timer.valid():
        #    self.angle += 1
        #    if self.angle > 360:
        #        self.angle = 0
        return self.graphics.getSurface()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import drawPixel [as 别名]
class SineWave(object):
    def __init__(self):
        self.graphics = Graphics(matrix_width, matrix_height)
        self.x = 0
        self.y = 0
        self.color = GREEN
        self.phase = 0
        self.wave_range = 1
        self.wave_step = 1
        self.amplitude = 5
        self.offset = matrix_width / 2
        self.freq = 0.4

    def generate(self):
        self.graphics.fill(BLACK)
        for i in range(0, self.wave_range, self.wave_step):
            for self.y in range(0, matrix_height):
                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 = (int(r), int(g), int(b))
                self.graphics.drawPixel(self.x, self.y, self.color)
        return self.graphics.getSurface()

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import drawPixel [as 别名]
class OldTron(object):
    # version before creating players that handle processing on thier own.
    def __init__(self):
        self.graphics = Graphics(matrix_width, matrix_height)
        self.color = BLUE
        x = 0  # random.randint(1, matrix_width - 1)
        y = 0  # 3random.randint(1, matrix_height - 1)
        self.pos = x, y
        self.speed = 1
        self.deltax, self.deltay = 0, 0
        self.body = []
        # add our head to our body :)
        self.body.append(self.pos)
        self.player1 = TronPlayer(BLUE, self)
        self.player1.update(self)
        self.player1.draw()
        pygame.init()
        self.window = pygame.display.set_mode((80, 60))
        self.debug = False
        pygame.key.set_repeat(1, 1)

    def inputHandling(self):
        keys_pressed = pygame.key.get_pressed()

        if keys_pressed[pygame.K_UP]:
            self.deltax = 0
            self.deltay = 1
        if keys_pressed[pygame.K_DOWN]:
            self.deltax = 0
            self.deltay = -1
        if keys_pressed[pygame.K_LEFT]:
            self.deltax = -1
            self.deltay = 0
        if keys_pressed[pygame.K_RIGHT]:
            self.deltax = 1
            self.deltay = 0

    def update(self):
        x, y = self.pos
        # update position
        x += self.deltax
        y += self.deltay
        # if the tail goes offscreen it appears on the other side.
        if x >= matrix_width:
            x = 0
            self.pos = x, y
        elif x < 0:
            x = matrix_width - 1
            self.pos = x, y
        elif y >= matrix_height:
            y = 0
            self.pos = x, y
        elif y < 0:
            y = matrix_height - 1
            self.pos = x, y
        else:
            self.pos = x, y
        if self.debug:
            print(self.deltax, self.deltay)
            print(x, y)

        # look if our "tail is in the way" and only if we have a tail.
        if len(self.body) > 2:
            if len(self.body) != len(set(self.body)):
                print("GameOver!")
                self.body = [self.pos]
                self.deltax = 0
                self.deltay = 0
        # add current point to tail
        # only if we moved though
        if self.deltax or self.deltay:
            self.body.append(self.pos)

    def draw(self):
        for x, y in self.body:
            self.graphics.drawPixel(x, y, self.color)

    def generate(self):
        self.graphics.fill(BLACK)
        self.inputHandling()
        self.update()
        self.draw()
        # self.player1.draw()
        return self.graphics.getSurface()

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

        self.controller = SnakeController(plugged)

        self.body_color = GREEN
        self.head_color = BLUE

        x = random.randint(1, matrix_width - 1)
        y = random.randint(1, matrix_height - 1)
        self.pos = x, y
        self.original_speed = speed
        self.speed = speed
        self.previousTick = 0
        self.deltax, self.deltay = 0, 0

        self.body = []
        self.tailLen = 0
        self.food = Food((0, 0), WHITE, self.graphics)
        self.food.randPos()

        # add our head to our body :)
        self.body.append(self.pos)

    def inputHandling(self):
        if self.controller.getUp() and self.deltax != -1:
            self.deltax = 1
            self.deltay = 0
        if self.controller.getDown() and self.deltax != 1:
            self.deltax = -1
            self.deltay = 0
        if self.controller.getLeft() and self.deltay != 1:
            self.deltax = 0
            self.deltay = -1
        if self.controller.getRight() and self.deltay != -1:
            self.deltax = 0
            self.deltay = 1

    def update(self):
        x, y = self.pos
        # update position certain amount per second.
        if((time.time() - self.previousTick) >= 1. / self.speed):
            self.previousTick = time.time()
            x += self.deltax
            y += self.deltay
            # if the snake goes offscreen it appears on the other side.
            if x >= matrix_width:
                x = 0
                self.pos = x, y
            elif x < 0:
                x = matrix_width - 1
                self.pos = x, y
            elif y >= matrix_height:
                y = 0
                self.pos = x, y
            elif y < 0:
                y = matrix_height - 1
                self.pos = x, y
            else:
                self.pos = x, y

            if len(self.body) > self.tailLen:
                del self.body[0]
            self.body.append(self.pos)
            # and if we hit food increase tail length
            # also increase our speed
            if self.food.pos == self.pos:
                self.speed += 0.5
                while self.food.pos in self.body:
                    self.food.randPos()
                self.food.randColor()
                self.tailLen += 1
            # look if our "tail is in the way" and only if we have a tail.
            if len(self.body) > 2:
                # check if head colides with body
                if len(self.body) != len(set(self.body)):
                    self.body = [self.pos]
                    self.tailLen = 0
                    self.speed = self.original_speed
                    self.deltax = 0
                    self.deltay = 0

    def draw(self):
        for i, (x, y) in enumerate(self.body):
            if i == self.tailLen:
                # draw our head a certain color
                self.graphics.drawPixel(x, y, self.head_color)
            else:
                # else just draw our body this color
                # self.graphics.drawPixel(x,y,Color.subtract(self.body_color, (int(255/(i+1)),)*3))
                self.graphics.drawPixel(x, y, (255, 255, 255))
        self.food.draw()

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

# 需要导入模块: from Tools.Graphics import Graphics [as 别名]
# 或者: from Tools.Graphics.Graphics import drawPixel [as 别名]
class PlasmaThird(object):
    def __init__(self, speed=10):
        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.speed = speed
        self.interval = speed
        self.time = random.randint(0,100)
        self.previousTick = 0

        self.angle = 0

        self.generatePalette()
        self.generatePlasmaSurface()
    def generatePalette(self):
        self.palette = []
        for x in xrange(0, (2**8), 1):
            r = int(128+256*sin(x)/20)
            g = int(128+256*sin(r)/100)
            b = int(128+256*sin(g)/50)
            colorRGB = (r,g,b)
            self.palette.append(colorRGB)
    def generatePlasmaSurface(self):
        self.angle = self.time
        x_offset = matrix_width*sin(radians(self.angle))+matrix_width
        y_offset = matrix_height*cos(radians(self.angle))+matrix_height
        for y in self.y_range:
            for x in self.x_range:
                c = int(
                     128+(128*sin((x+x_offset)/2.0))
                    +128+(128*sin((y+y_offset)/2.0))
                    +128+(128*sin(((x+x_offset)+(y+y_offset))/2.0))
                    +128+(128*sin(sqrt(float((x+x_offset)*(x+x_offset)+(y+y_offset)*(y+y_offset)))/2.0))
                    )/4
                color = (c,)*3
                self.plasma.drawPixel(x,y,color)
        return list(self.plasma.getSurface())
    def process(self):
        if((time.time()-self.previousTick) >= 1./self.interval):
            self.previousTick = time.time()
            self.time+=1
    def draw(self):
        paletteShift = self.time
        self.generatePlasmaSurface()
        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,)
                #darken the color to create a better contrast
                color = ColorRGBOps.brighten(color, 20)
                self.graphics.drawPixel(x,y, color)
    def generate(self):
        self.graphics.fill(BLACK)
        self.process()
        self.draw()
        return self.graphics.getSurface()