Python mask.from_surface函数代码示例

 def __init__(self, x, y, paddle_color, parent=None, owner=None):
     """
     Initialize it with spawn position
     :param x: x coordinate of the play-field
     :param y: y coordinate of the play-field
     :param paddle_color:
     :param parent: ?
     :param owner: ?
     :return:
     """
     Sprite.__init__(self)
     self.vx = 0
     self.vy = 0
     self.speed = 10
     self.paddle_color = paddle_color
     self.image = Assets.paddles[paddle_color]  # pygame.image.load("gfx/paddle.png")
     self.mask = mask.from_surface(self.image)
     self.rect = self.image.get_rect()
     self.rect.x = x
     self.rect.y = y
     self.attachment_points = [(8, 0), (self.rect.width-8, 0)]
     self.attachments = []
     # self.attachments = [LaserGunAttachment(self)]
     self.parent = parent
     self.owner = owner

    def test_from_surface(self):
        """  Does the mask.from_surface() work correctly?
        """

        mask_from_surface = mask.from_surface

        surf = surface.Surface((70,70), SRCALPHA, 32)

        surf.fill((255,255,255,255))

        amask = mask.from_surface(surf)
        #amask = mask_from_surface(surf)

        self.assertEqual(amask.get_at((0,0)), 1)
        self.assertEqual(amask.get_at((66,1)), 1)
        self.assertEqual(amask.get_at((69,1)), 1)

        surf.set_at((0,0), (255,255,255,127))
        surf.set_at((1,0), (255,255,255,128))
        surf.set_at((2,0), (255,255,255,0))
        surf.set_at((3,0), (255,255,255,255))

        amask = mask_from_surface(surf)
        self.assertEqual(amask.get_at((0,0)), 0)
        self.assertEqual(amask.get_at((1,0)), 1)
        self.assertEqual(amask.get_at((2,0)), 0)
        self.assertEqual(amask.get_at((3,0)), 1)

        surf.fill((255,255,255,0))
        amask = mask_from_surface(surf)
        self.assertEqual(amask.get_at((0,0)), 0)

    def change_size(self, new_width):
        """
        Function used to change the size of the palette. Rebuilds image from source and
        generates new collision Rect
        :param new_width: new Paddle width in pixels (min. 22px)
        :return:
        """
        paddleAsset = Assets.paddles[self.paddle_color]
        new_width = max(new_width, 22)  # 22 = (border(8) + colorbar(3))*2
        paddle_mid = Surface((38, 15))  # (2*paddle.rect.width, paddle.rect.height))
        # paddle_mid.blit(self.image, (0, 0), Rect(11, 0, 38, 15))
        paddle_mid.blit(paddleAsset, (0, 0), Rect(11, 0, 38, 15))
        paddle_mid = transform.scale(paddle_mid, (new_width-22, self.rect.height))
        new_paddle = Surface((new_width, self.rect.height), SRCALPHA)  # blank surface
        # new_paddle.fill(pygame.Color(0, 0, 0, 0), new_paddle.get_rect())
        new_paddle.blit(paddle_mid, (11, 0))
        new_paddle.blit(paddleAsset, (0, 0), Rect(0, 0, 11, 15))
        new_paddle.blit(paddleAsset, (new_width - 11, 0),
                        Rect(paddleAsset.get_rect().width - 11, 0, 11, 15))
        paddle_new_x = self.rect.x + self.rect.width/2 - new_paddle.get_rect().width/2
        self.rect = Rect(paddle_new_x, self.rect.y, new_paddle.get_rect().width,
                         new_paddle.get_rect().height)
        self.mask = mask.from_surface(new_paddle)
        self.image = new_paddle
        self.attachment_points[1] = (self.rect.width-8, 0)
        # self.paddle.attachment_points[1] =

        if self.rect.x <= PLAYFIELD_PADDING[0]:
            self.rect.x = PLAYFIELD_PADDING[0] + 1
        elif self.rect.x + self.rect.width >= LEVEL_WIDTH - PLAYFIELD_PADDING[0]:
            self.rect.x = LEVEL_WIDTH - PLAYFIELD_PADDING[0] - self.rect.width - 1

 def text(self, value):
     self._text = value
     self.image = self._render(value)
     self.rect = Rect((self.rect[0], self.rect[1]), self.image.get_rect()[2:])
     self.col_rect = self.rect.copy()
     self.mask = mask.from_surface(self.image)
     self.create_feet()

 def __init__(self, tag, initial_position, rotation=0, fontname=DEFAULT_FONT, fontzoom=5):
     Sprite.__init__(self)
     self.tag = copy(tag)
     self.rotation = rotation
     
     font_spec = load_font(fontname)
     
     #fonter = font.Font(os.path.join(FONT_DIR, font_spec['ttf']), int(tag['size'] * fontzoom)).render(tag['tag'], True, tag['color'])
     # changing to allow for arbitrary local fonts
     fonter = font.Font(font_spec['ttf'], int(tag['size'] * fontzoom)).render(tag['tag'], True, tag['color'])
     self.tag['size'] *= fontzoom
     fonter = transform.rotate(fonter, rotation)
     frect = fonter.get_bounding_rect()
     frect.x = -frect.x
     frect.y = -frect.y
     self.fontoffset = (-frect.x, -frect.y)
     font_sf = Surface((frect.width, frect.height), pygame.SRCALPHA, 32)
     font_sf.blit(fonter, frect)
     self.image = font_sf
     self.rect = font_sf.get_rect()
     self.rect.width += TAG_PADDING
     self.rect.height += TAG_PADDING
     self.rect.x = initial_position[0]
     self.rect.y = initial_position[1]
     self.mask = mask.from_surface(self.image)
     self.mask = self.mask.convolve(CONVMASK, None, (TAG_PADDING, TAG_PADDING))

 def flip(self):
     pos = (self.rect.x, self.rect.y)
     angle = 90 if self.rotation == 0 else - 90
     self.image = transform.rotate(self.image, angle)
     self.rect = self.image.get_rect()
     self.rect.x, self.rect.y = pos
     self.mask = mask.from_surface(self.image)
     self.mask = self.mask.convolve(CONVMASK, None, (TAG_PADDING, TAG_PADDING))

 def __init__(self, game, pos, direction, speed=4):
     Sprite.__init__(self)
     self.game = game
     self.image = game.get_tile_surface('b.dot')
     self.mask = mask.from_surface(self.image)
     self.pos = Vector(pos)
     self.direction = direction
     self.speed = speed

	def collides(self,monster):
		"""
			Checks if the monster collides with a specific monster
		"""
		if self.rect.colliderect(monster.rect):
			#Here need to pix perfect collision
 			trectmonst = self.rect.clip(monster.rect).move(-monster.rect.x,-monster.rect.y)
 			trectstick = self.rect.clip(monster.rect).move(-self.rect.x,-self.rect.y)

			tmonstmask = mask.from_surface(monster.image.subsurface(trectmonst))
 			tcurrentmask = mask.from_surface(self.image.subsurface(trectstick))

			col = tcurrentmask.overlap(tmonstmask,(0,0))
                	if col == None: return False,0,0
                	else: return True,col[0]+self.rect.x,col[1]+self.rect.y

		else: return False,0,0

 def map_collision(self, mapp, obj_rect, obj_mask):
     """Return True if map and object collide"""
     surf_map = Surface((obj_rect.width, obj_rect.height),
                        pygame.SRCALPHA)
     surf_map.blit(mapp.collision_text, (0, 0), obj_rect)
     mask_map = mask.from_surface(surf_map)
     if mask_map.overlap(obj_mask, (0, 0)) is not None:
         return True
     return False

 def __init__(self, sprite_filename, speed):
 
     Sprite.__init__(self)
     
     self.image = pygame.image.load(sprite_filename).convert_alpha()
     self.rect = self.image.get_rect()
     self.mask = mask.from_surface(self.image)
     
     self.speed = speed

 def __init__(self, x, y, w, h):
     Sprite.__init__(self)
     self.image = Surface((w, h), SRCALPHA, 32)        
     self.image.fill((255,0,0))
     self.rect = self.image.get_rect()
     self.rect.x = x
     self.rect.y = y
     self.mask = mask.from_surface(self.image)
     
     self.border = Surface((self.rect.width, self.rect.height), SRCALPHA, 32)        
     pygame.draw.rect(self.border, (255, 0, 0), Rect(0 , 0, self.rect.width , self.rect.height), 1)

	def collide(self, group):
		if self.sprite.maskDirty:
			self.sprite.maskDirty = False
			AVRSprite.spriteLock.acquire()
			self.sprite.mask = mask.from_surface(self.transformedSurface)
			AVRSprite.spriteLock.release()
		
		sprites = sprite.spritecollide(self.sprite, group.group, False)
		results = []
		for s in sprites:
			if s == self.sprite:
				continue
			if s.maskDirty:
				s.maskDirty = False
				AVRSprite.spriteLock.acquire()
				s.mask = mask.from_surface(s.AVRSprite.transformedSurface)
				AVRSprite.spriteLock.release()
			if sprite.collide_mask(self.sprite, s) != None:
				results.append(s.AVRSprite.handle)
		return results

def split_row(parent, parent_cols, row, height, width):
    """split_frame helper function
    splits a single row of source surface
    """
    
    images = []
    masks = []
    
    for col in range(parent_cols):
        current_image = parent.subsurface((col*width, row*height, width, height))
        images.append(current_image)
        masks.append(mask.from_surface(current_image))
        
    return images, masks

    def test_from_surface_2(self):
        surf = surface.Surface((300, 100), depth=32, flags=SRCALPHA)
        surf.fill((0, 0, 0, 0xff))
        for x in range(200):
            surf.set_at((x, 20), (0, 0, 0, x))
        M = mask.from_surface(surf)
        self.assertEqual(M.get_at((0, 0)), 1)
        self.assertEqual(M.get_at((20, 20)), 0)
        self.assertEqual(M.get_at((21, 20)), 0)
        self.assertEqual(M.get_at((50, 20)), 0)
        self.assertEqual(M.get_at((127, 20)), 0)
        self.assertEqual(M.get_at((128, 20)), 1)
        self.assertEqual(M.get_at((129, 20)), 1)
        self.assertEqual(M.get_at((200, 20)), 1)
        self.assertEqual(M.get_at((21, 21)), 1)
        # Different threshold

        M = mask.from_surface(surf, 50)
        self.assertEqual(M.get_at((50, 20)), 0)
        self.assertEqual(M.get_at((51, 20)), 1)
        self.assertEqual(M.get_at((127, 20)), 1)
        self.assertEqual(M.get_at((128, 20)), 1)
        self.assertEqual(M.get_at((129, 20)), 1)

    def __init__(self, word, word_o, color, angle):
        Sprite.__init__(self)
        self.word = word
        self.angle = angle

        # Determine Word dimensions
        w_rect = word_o.get_bounding_rect()
        w_rect.x = -w_rect.x + WORD_PADDING
        w_rect.y = -w_rect.y + WORD_PADDING
        w_rect.width += WORD_PADDING * 2
        w_rect.height += WORD_PADDING * 2

        # Draw Word on a surface
        word_sf = Surface((w_rect.width, w_rect.height), SRCALPHA, 32)
        word_sf.blit(word_o, w_rect)
        self.rect = word_sf.get_rect()
        self.image = word_sf.copy()
        self.msf = word_sf.copy()

        # Create custom mask
        m1 = mask.from_surface(self.msf)
        cr, crw = [], []
        for c in [x for x in range(w_rect.width) if x % PXL == 0]:
            for r in [y for y in range(w_rect.height) if y % PXL == 0]:
                if m1.get_at((c, r)) != 0:
                    crw.append((c - PXL, r - PXL))
                    crw.append((c - PXL, r))
                    crw.append((c, r - PXL))
                    crw.append((c, r))
                    crw.append((c + PXL, r + PXL))
                    crw.append((c, r + PXL))
                    crw.append((c + PXL, r))
                    crw.append((c + PXL, r - PXL))
                    crw.append((c - PXL, r + PXL))
                    cr.append((c, r))
        for c, r in crw:
            draw.rect(self.msf, color, Rect((c, r), (PXL, PXL)))
        for i in enumerate(cr):
            c, r = i[1]
            j = 1
            if i[0] + 1 >= len(cr):
                break
            next_cr = cr[i[0] + 1]
            while next_cr[0] == c and next_cr[1] != r + PXL * j:
                draw.rect(self.msf, color, Rect((c, r + j * PXL), (PXL, PXL)))
                j += 1

        self._rotate()