Как изменить прозрачность картинки pygame

Example

There are kinds 3 of transparency supported in pygame: colorkeys, Surface alphas, and per-pixel alphas.

Colorkeys

Makes a color fully transparent, or more accurately, making a color simply not be blit. If you have an image with a black rect inside you could set a colorkey to prevent the black color from being blit.

BLACK = (0, 0, 0)
my_image.set_colorkey(BLACK)  # Black colors will not be blit.

A Surface can only have one colorkey. Setting another colorkey will overwrite the previous. Colorkeys cannot have different alpha values, it can only make a color not visible.

Surface alphas

Makes the whole Surface transparent by an alpha value. With this method you can have different alpha values but it will affect the whole Surface.

my_image.set_alpha(100)  # 0 is fully transparent and 255 fully opaque.

Per-pixel alpha

Makes every pixel in the Surface transparent by a individual alpha value. This gives you the most freedom and flexibility but is also the slowest method. This method also requires the Surface to be created as a per-pixel alpha Surface, and the color arguments needs to contain a fourth alpha integer.

size = width, height = (32, 32)
my_image = pygame.Surface(size, pygame.SRCALPHA)  # Creates an empty per-pixel alpha Surface.

The Surface will now draw transparency if the color contains the fourth alpha value.

BLUE = (0, 0, 255, 255)
pygame.draw.rect(my_image, BLUE, my_image.get_rect(), 10)

Unlike the other Surfaces, this Surface default color won’t be black but transparent. That’s why the black rectangle in the middle disappear.

Combine colorkey and Surface alpha

Colorkeys and Surface alphas can be combined, but per-pixel alpha cannot. This can be useful if you don’t want the slower performance of a per-pixel Surface.

purple_image.set_colorkey(BLACK)
purple_image.set_alpha(50)

Full code

Copy this in an empty file and run it. Press the keys 1, 2, 3 or 4 to make the images appear. Press 2, 3 or 4 multiple times to make them more opaque.

import pygame
pygame.init()

WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255, 50)  # This color contains an extra integer. It's the alpha value.
PURPLE = (255, 0, 255)

screen = pygame.display.set_mode((200, 325))
screen.fill(WHITE)  # Make the background white. Remember that the screen is a Surface!
clock = pygame.time.Clock()

size = (50, 50)
red_image = pygame.Surface(size)
green_image = pygame.Surface(size)
blue_image = pygame.Surface(size, pygame.SRCALPHA)  # Contains a flag telling pygame that the Surface is per-pixel alpha
purple_image = pygame.Surface(size)

red_image.set_colorkey(BLACK)
green_image.set_alpha(50)
# For the 'blue_image' it's the alpha value of the color that's been drawn to each pixel that determines transparency.
purple_image.set_colorkey(BLACK)
purple_image.set_alpha(50)

pygame.draw.rect(red_image, RED, red_image.get_rect(), 10)
pygame.draw.rect(green_image, GREEN, green_image.get_rect(), 10)
pygame.draw.rect(blue_image, BLUE, blue_image.get_rect(), 10)
pygame.draw.rect(purple_image, PURPLE, purple_image.get_rect(), 10)

while True:
    clock.tick(60)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_1:
                screen.blit(red_image, (75, 25))
            elif event.key == pygame.K_2:
                screen.blit(green_image, (75, 100))
            elif event.key == pygame.K_3:
                screen.blit(blue_image, (75, 175))
            elif event.key == pygame.K_4:
                screen.blit(purple_image, (75, 250))

    pygame.display.update()

Инициализация

Для работы с pygame следует инициализировать необходимые модули, проще всего инициализировать все:
pygame.init()
Существует несколько вариантов инициализации окна pygame:

Создание рабочей области окна

Создание окна требуемого размера.

screen = pygame.display.set_mode((320, 240))

Создание окна исходя из размеров фона

background = pygame.image.load('media/img_backgournd.jpg')
screen = pygame.display.set_mode(background.get_size())
screen.blit(background, (0, 0))

Работа с прямоугольниками и текстом

Прямоугольники служат для выбора части поверхностей, для получения размеров областей и др.
Конструктор простейшего прямоугольника выглядит так:

In [1]: import pygame

In [2]: r = pygame.Rect(0, 0, 100, 50)   # 100х50 px

In [3]: r
Out[3]: <rect(0, 0, 100, 50)>

У объекта класса Rect есть множество методов, названия говорят за себя:
[‘bottom’, ‘bottomleft’, ‘bottomright’, ‘center’, ‘centerx’, ‘centery’, ‘clamp’, ‘clamp_ip’, ‘clip’, ‘collidedict’, ‘collidedictall’,
‘collidelist’, ‘collidelistall’, ‘collidepoint’, ‘colliderect’, ‘contains’, ‘copy’, ‘fit’, ‘h’, ‘height’, ‘inflate’, ‘inflate_ip’,
‘left’, ‘midbottom’, ‘midleft’, ‘midright’, ‘midtop’, ‘move’, ‘move_ip’, ‘normalize’, ‘right’, ‘size’, ‘top’, ‘topleft’,
‘topright’, ‘union’, ‘union_ip’, ‘unionall’, ‘unionall_ip’, ‘w’, ‘width’, ‘x’, ‘y’]

Из этих атрибутов я выделю centerx и centery:

font = pygame.font.Font('media/presentum.ttf', 30)      # задание шрифта и размера
text_img = font.render('Строка для рендеринга', True, 0xFF0000) # строка, сглаживание, цвет

text_pos = text_img.get_rect()      # получаем пр-к нашего текста
text_pos.centerx = r.centerx        # центрируем позицию нашего текста по середине контейнера r
text_pos.centery = r.centery        # центрируем позицию нашего текста по середине контейнера r

screen.blit(text_img, text_pos)     # копирование текста на экран
pygame.display.update()             # обновление экрана

Прозрачность (Альфа-канал)

Для загрузки изображения из png файла с альфа каналом следует использовать следующую строчку:

pic_with_alpha = pygame.image.load('media/src_with_alpha.png').convert_alpha()

Для получения изображения с прозрачным фоном мы редактируем png, удаляем фон, затем сохраняем файл без сохранения цвета прозрачности.

Создание прозрачности для сложных поверхностей, полигонов и прочего

Моё решение было следующим:
Немного меняю исходное изображение для того чтобы чёрный цвет не превратился в прозрачный, затем накладываю чёрную маску на изображение, говорю, что чёрный цвет становится прозрачным.

# Берём изображение, подгоняем под размер
img = pygame.image.load('media/src.png')
img_s = pygame.transform.scale(img, (204, 142))

# нужно заместить черный в исходном изображении на +1, иначе станет прозрачным
pa_img_s = pygame.PixelArray(img_s)         # создаем массив для замены цвета
pa_img_s.replace((0, 0, 0), (0, 0, 1))      # заменяем цвет
img_s = pa_img_s.surface
del pa_img_s                                # удаляем, иначе блочит поверхность

s = pygame.Surface((240, 146))              # поверхность для преобразований
pat = pygame.image.load('media/pattern.png').convert_alpha()        # накладываем чёрный шаблон, с прозрачными вырезами

s.blit(img_s, (0, 0))   # копируем наше изображение с "немного не чёрным цветом" на поверхность для преобразований
s.blit(pat, (0, 0))     # сверху накладываем (копируем) маску
s.set_colorkey(pygame.Color('black'))       # устанавливаем чёрный цвет прозрачным

Выделение части поверхности

Мой стандартный use-case использования части поверхности (subsurface) — это копирование части фона для создания эффектов движения, анимации:

• копируем часть фона, на котором будет происходить действие
• копируем изменение
• ждем
• снова копируем фон.

# задаём фон
background = pygame.image.load('media/img_backgournd.jpg')
screen = pygame.display.set_mode(background.get_size())
screen.blit(background, (0, 0))


r = pygame.Rect(0, 0, 300, 400)     # размеры пр-ка, на котором будет производиться действие
ball = pygame.image.load('media/ball.png')  # загружаем картинку
bg = background.subsurface(r)               # создаём копию фона
x_pos_left = 0
y_pos = 0
c = 10
while c:
    x_pos_left += 10
    screen.blit(bg, (0, 0))       # копируем фон
    screen.blit(ball, (x_pos_left, y_pos))   # копируем картинку поверх
    c -= 1
    pygame.display.update(r)    # обновлять не обязательно весь экран, можно определённую часть.
    sleep(0.08)                 # задержка, можно использовать pygame-овскую

Работа с событиями (events)

Данный вопрос рассмотрен везде, но не упомянуть его нельзя

«` python простейший выход из приложения по кнопке
bRunning = True

while bRunning:

    for event in pygame.event.get():
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_ESCAPE:
                bRunning = False
                exit(0) # к примеру

А это пример кастомного события

``` python
# coding=utf-8
import pygame

COUNTER = pygame.USEREVENT + 5  # 24+5 = 29


class Counter():
    def __init__(self, coord, screen, background, counter, up):
        self.current_sub_timer = 0
        self.coord = coord
        self.screen = screen
        self.counter = counter      # сколько секунд считать
        self.up = up                # если 1, возрастает счётчик, 0, убывает

        rendtext = self.get_colored_text(str(30), (255, 0, 0))
        r = rendtext.get_rect()         # взяли 30 и увеличили размер пр-ка

        self.bg = background.subsurface(r.move(self.coord))     # сдвинули пр-к и взяли фон

    def get_colored_text(self, text, color):
        bigfont = pygame.font.Font('presentum.ttf', 60)
        rendtext = bigfont.render(text, True, color)
        return rendtext

    def get_next(self):
        """
        возвращет 0 если таймер оттикал
        """
        cur_second = self.current_sub_timer / 10
        if self.current_sub_timer / 10 == self.counter:
            return 0
        else:
            if self.up:
                new_val = cur_second + 1
            else:
                new_val = self.counter - cur_second
            rendtext = self.get_colored_text(str(new_val), (255, 0, 0))
            self.screen.blit(self.bg, self.coord)
            self.screen.blit(rendtext, self.coord)
            pygame.display.update()
            self.current_sub_timer += 1
            return 1


def main():
    pygame.init()
    screen = pygame.display.set_mode((1024, 768))
    background = pygame.image.load('media/screen3.jpg')
    screen.blit(background,(0, 0))
    pygame.display.update()

    pygame.time.set_timer(COUNTER, 100)     # запускаем генерацию even-тов каждые 100мс
    counter = Counter((350, 300), screen, background, 5, 0) # передаём где вывести счётчик, 
                                                            # наш экран, фон, сколько секунд считать, 0 - убывает

    b_running = True
    while b_running:

        for event in pygame.event.get():
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_ESCAPE:
                    b_running = False

            elif event.type == COUNTER:

                if not counter.get_next():
                    pygame.time.set_timer(COUNTER, 0)   # значит оттикал таймер, нужно остановить генерацию событий


if __name__ == '__main__':
    main()

объект пигамы для представления изображений

Поверхность ((ширина, высота), флаги = 0, глубина = 0, маски = Нет) -> Поверхность

Поверхность ((ширина, высота), flags = 0, Поверхность) -> Поверхность

Пигамная поверхность используется для представления любого изображения.Surface имеет фиксированное разрешение и формат пикселей.Поверхности с 8-битными пикселями используют цветовую палитру для отображения до 24-битного цвета.

Вызовите pygame.Surface() чтобы создать новый объект изображения. Поверхность станет полностью черной. Единственные обязательные аргументы — это размеры. Без дополнительных аргументов поверхность будет создана в формате, который лучше всего соответствует отображаемой поверхности.

Форматом пикселей можно управлять,передавая битовую глубину или существующую Поверхность.Аргументом флагов является битовая маска дополнительных возможностей поверхности.Вы можете передать любую комбинацию этих флагов:

HWSURFACE    creates the image in video memory
SRCALPHA     the pixel format will include a per-pixel alpha

Оба флага являются только запросом и могут быть возможны не для всех дисплеев и форматов.

Продвинутые пользователи могут комбинировать набор битовых масок со значением глубины.Маски представляют собой набор из 4-х целых чисел,представляющих биты в пикселе каждого цвета.Нормальные поверхности не должны требовать аргумента масок.

Поверхности могут иметь множество дополнительных атрибутов,таких как альфа-плоскости,цветовые клавиши,обрезка исходного прямоугольника.Эти функции в основном влияют на то,как Поверхность размывается на другие Поверхности.Программы для блитов будут пытаться использовать аппаратное ускорение,когда это возможно,в противном случае они будут использовать сильно оптимизированные программные методы блиттинга.

В пигаме поддерживаются три типа прозрачности:цветовые клавиши,поверхностные альфа и пиксельные альфа.Поверхностные альфы можно смешивать с цветовыми клавишами,но изображение с альфами на пиксель не может использовать другие режимы.Прозрачность цветовых клавиш делает прозрачным одно значение цвета.Любые пиксели,соответствующие цветовой клавише,не будут нарисованы.Альфа-значение поверхности-это единственное значение,которое изменяет прозрачность всего изображения.Альфа поверхности 255-непрозрачная,а значение 0-полностью прозрачная.

На каждый пиксель альфа отличаются,потому что они сохраняют значение прозрачности для каждого пикселя.Это позволяет получить наиболее точные эффекты прозрачности,но в то же время и самые медленные.На каждый пиксель альфа-фаз нельзя смешивать с альфа-и цветовыми клавишами.

Есть поддержка пиксельного доступа для поверхностей. Доступ к пикселям на аппаратных поверхностях медленный и не рекомендуется. Доступ к get_at() можно получить с помощью функций get_at () и set_at() . Эти методы подходят для простого доступа, но будут значительно медленнее при работе с пикселями. Если вы планируете много работать на уровне пикселей, рекомендуется использовать pygame.PixelArray , который дает массив, подобный представлению поверхности. Для pygame.surfarray математических манипуляций попробуйте модуль pygame.surfarray (это довольно быстро, но требует NumPy.)

Любые функции, которые напрямую обращаются к пиксельным данным поверхности, потребуют, чтобы эта поверхность была заблокирована (). Эти функции могут lock() и unlock() сами поверхности без посторонней помощи. Но если функция будет вызываться много раз, возникнет много накладных расходов на многократную блокировку и разблокировку поверхности. Лучше всего заблокировать поверхность вручную перед многократным вызовом функции, а затем разблокировать, когда вы закончите. Об этом говорится в документации всех функций, которым требуется заблокированная поверхность. Не забывайте оставлять поверхность заблокированной только в случае необходимости.

Пиксели поверхности хранятся внутри как одно число, в котором закодированы все цвета. Используйте map_rgb() и unmap_rgb() для преобразования отдельных значений красного, зеленого и синего цветов в упакованное целое число для этой поверхности.

Поверхности также могут ссылаться на разделы других поверхностей. Они создаются с помощью метода subsurface() . Любое изменение одной из поверхностей повлияет на другую.

Каждая Поверхность содержит область обрезки.По умолчанию область клипа охватывает всю Surface.Если она изменена,все операции рисования влияют только на меньшую область.

blit()

нарисовать одно изображение на другое

blit(source, dest, area=None, special_flags=0) -> Rect

Рисует исходную поверхность на данную поверхность.Рисунок можно позиционировать с помощью аргумента dest.Аргумент dest может быть либо парой координат,представляющих положение верхнего левого угла блита,либо прямоугольником,где верхний левый угол прямоугольника будет использоваться в качестве позиции для блита.Размер прямоугольника назначения не влияет на размер блита.

Прямоугольник с дополнительной областью может быть также пропущен.Он представляет собой меньшую часть исходной Поверхности для рисования.

Новое в pygame 1.8: необязательные special_flags : BLEND_ADD , BLEND_SUB , BLEND_MULT , BLEND_MIN , BLEND_MAX .

Новое в pygame 1.8.1: необязательные special_flags : BLEND_RGBA_ADD , BLEND_RGBA_SUB , BLEND_RGBA_MULT , BLEND_RGBA_MIN , BLEND_RGBA_MAX BLEND_RGB_ADD , BLEND_RGB_SUB , BLEND_RGB_MULT , BLEND_RGB_MIN , BLEND_RGB_MAX .

Новое в pygame 1.9.2: необязательные special_flags : BLEND_PREMULTIPLIED

Новое в pygame 2.0.0: Необязательные special_flags : BLEND_ALPHA_SDL2 — Использует блиттер SDL2 для альфа-смешения, это дает результаты, отличные от блиттера по умолчанию, который моделируется после SDL1, из-за различных приближений, используемых для формулы альфа-смешения. Блиттер SDL2 также поддерживает RLE на поверхностях с альфа-смешением, чего нет в pygame.

Возвращаемый прямоугольник-это область поражаемых пикселей,исключая любые пиксели за пределами целевой Поверхности или за пределами области обрезки.

Альфазы пикселей будут игнорироваться при блицировании на 8-битную поверхность.

Для поверхности с цветовым ключом или одеялом альфа,блит к себе может дать немного другие цвета,чем не-самоблит.

blits()

нарисовать множество изображений на другом

blits (blit_sequence = (source, dest), …), doreturn = 1) -> [Rect, …] или None

blits ((источник, назначение, область), …)) -> [Прямоугольник, …]

blits ((источник, назначение, область, специальные_флаги), …)) -> [Прямоугольник, …]

Рисует множество поверхностей на этой поверхности. В качестве входных данных он принимает последовательность, каждый из элементов которой соответствует элементам функции blit() . Требуется как минимум последовательность (источник, назначение).

Parameters:	blit_sequence — последовательность поверхностей и аргументов для их преобразования, они соответствуют аргументам blit() doreturn — если True , вернуть список областей измененных областей, иначе вернуть None
Returns:	список участков измененных областей, если doreturn имеет значение True , в противном случае — None
Return type:	список или Нет

Новое в пигаме 1.9.4.

convert()

изменять пиксельный формат изображения

convert(Surface=None) -> Surface

convert (depth, flags = 0) -> Поверхность

convert (masks, flags = 0) -> Поверхность

Создает новую копию поверхности с измененным форматом пикселей. Новый формат пикселей можно определить из другой существующей поверхности. В противном случае можно использовать аргументы глубины, флагов и масок, аналогично pygame.Surface() .

Если аргументы не будут переданы,то новая Surface будет иметь тот же формат пикселей,что и отображаемая Surface.Это всегда самый быстрый формат для блиттинга.Хорошая идея-конвертировать все Surface до того,как они многократно подвергнутся блиттингу.

Преобразованная поверхность не будет иметь альфа-пикселя. Они будут удалены, если они были на оригинале. См. convert_alpha() для сохранения или создания попиксельных альфа-каналов.

Новая копия будет иметь тот же класс,что и копируемая поверхность.Это позволяет подклассу Surface наследовать данный метод без необходимости переопределения,если только атрибуты экземпляра,специфичного для подкласса,также не нуждаются в копировании.

convert_alpha()

изменение формата изображения в пикселях,в том числе на пиксель альфаса

convert_alpha (Поверхность) -> Поверхность

convert_alpha () -> Поверхность

Создает новую копию поверхности с нужным форматом пикселей.Новая поверхность будет в формате,подходящем для быстрого блитинга к заданному формату с разрешением на альфа-пиксель.Если поверхность не задана,то новая поверхность будет оптимизирована для блиттинга к текущему дисплею.

В отличие от метода convert() , формат пикселей для нового изображения не будет точно таким же, как у запрошенного источника, но он будет оптимизирован для быстрого альфа-преобразования к месту назначения.

Как и в случае с convert() возвращаемая поверхность имеет тот же класс, что и преобразованная поверхность.

copy()

создать новую копию Surface

copy () -> Поверхность

Делает дубликат поверхности. Новая поверхность будет иметь те же форматы пикселей, цветовые палитры, настройки прозрачности и класс, что и исходная. Если подклассу Surface также необходимо скопировать какие-либо атрибуты конкретного экземпляра, он должен переопределить copy() .

fill()

заполнение Поверхность сплошным цветом

fill(color, rect=None, special_flags=0) -> Rect

Заполните Поверхность сплошным цветом.Если прямоугольный аргумент не указан,то Surface будет заполнена целиком.Прямой аргумент ограничит заливку определенной областью.Заполнение также будет содержаться в области клипа Surface.

Аргумент цвета может быть последовательностью RGB , последовательностью RGBA или отображенным индексом цвета. При использовании RGBA альфа (часть RGBA ) игнорируется, если поверхность не использует пиксельную альфу (у поверхности есть флаг SRCALPHA ).

Новое в pygame 1.8: необязательные special_flags : BLEND_ADD , BLEND_SUB , BLEND_MULT , BLEND_MIN , BLEND_MAX .

Новое в pygame 1.8.1: необязательные special_flags : BLEND_RGBA_ADD , BLEND_RGBA_SUB , BLEND_RGBA_MULT , BLEND_RGBA_MIN , BLEND_RGBA_MAX BLEND_RGB_ADD , BLEND_RGB_SUB , BLEND_RGB_MULT , BLEND_RGB_MIN , BLEND_RGB_MAX .

Это вернет затронутую область поверхности.

scroll()

Сдвинуть изображение поверхности на месте

прокрутка (dx = 0, dy = 0) -> Нет

Перемещайте изображение на dx пикселей вправо и dy пикселей вниз.dx и dy могут быть отрицательными для прокрутки влево и вверх соответственно.Неперезаписанные области поверхности сохраняют свои первоначальные значения пикселей.Прокрутка содержится в области клипа «Поверхность».Безопасно иметь значения dx и dy,превышающие размер поверхности.

Новое в пигаме 1.9.

set_colorkey()

Установите прозрачную цветовую клавишу

set_colorkey (Цвет, флаги = 0) -> Нет

set_colorkey (Нет) -> Нет

Установите текущий цветовой ключ для поверхности. При копировании этой поверхности на место назначения любые пиксели того же цвета, что и цветовой ключ, будут прозрачными. Цвет может быть цветом RGB или целым числом сопоставленного цвета. Если None не передан, цветовой ключ будет сброшен.

Цветовая клавиша будет проигнорирована,если параметр Surface отформатирован так,чтобы использовать значения альфа-пикселей.Клавишу можно смешивать с полным альфа-значением Surface.

Необязательный аргумент flags может иметь значение pygame.RLEACCEL , чтобы обеспечить лучшую производительность на неускоренных дисплеях. RLEACCEL Поверхность будет медленнее , чтобы изменить, но быстрее Blit в качестве источника.

get_colorkey()

Получить текущую прозрачную цветовую клавишу

get_colorkey () -> RGB или None

Вернуть текущее значение цветового ключа для поверхности. Если цветовой ключ не задан , возвращается None .

set_alpha()

установить альфа-значение для полного изображения Поверхности

set_alpha (значение, флаги = 0) -> Нет

set_alpha (Нет) -> Нет

Установите текущее значение альфа-канала для поверхности. При копировании этой поверхности на место назначения пиксели будут нарисованы слегка прозрачными. Значение альфа — это целое число от 0 до 255, 0 — полностью прозрачное, а 255 — полностью непрозрачное. Если для альфа-значения передано None , то альфа-смешивание будет отключено, включая попиксельную альфа-канал.

Это значение отличается от альфа поверхности на пиксель. Для поверхности с альфа-значением на пиксель альфа-канал игнорируется и возвращается значение None .

Изменено в пигаме 2.0:на поверхность альфа может быть скомбинирована с альфа на пиксель.

Необязательный аргумент flags может иметь значение pygame.RLEACCEL , чтобы обеспечить лучшую производительность на неускоренных дисплеях. RLEACCEL Поверхность будет медленнее , чтобы изменить, но быстрее Blit в качестве источника.

get_alpha()

получить текущее значение Прозрачность поверхности

get_alpha() -> int_value

Возврат текущего альфа-значения для Поверхности.

lock()

блокировка памяти Surface для доступа к пикселям

lock () -> Нет

Блокировка пиксельных данных Surface для доступа.На ускоренных Поверхностях пиксельные данные могут храниться в энергонезависимой видеопамяти или в нелинейно сжатых формах.При блокировке Поверхностей доступ к пиксельным данным становится доступным для обычного программного обеспечения.Код,который считывает или записывает значения пикселей,требует блокировки Поверхности.

Поверхности не должны оставаться заблокированными дольше,чем необходимо.Заблокированная поверхность часто не может отображаться или управляться с помощью пигамы.

Не все поверхности требуют блокировки. Метод mustlock() может определить, действительно ли это требуется. Нет потери производительности за блокировку и разблокировку поверхности, которая в этом не нуждается.

Все функции игры автоматически блокируют и разблокируют данные Surface по мере необходимости.Если какой-то участок кода будет совершать вызовы,которые будут многократно блокировать и разблокировать Surface,то может быть полезно обернуть блок внутри пары блокировки и разблокировки.

Безопасно гнездиться,запирая и разблокируя звонки.Поверхность будет разблокирована только после того,как окончательный замок будет разблокирован.

unlock()

разблокировать память Surface от пиксельного доступа

разблокировать () -> Нет

Разблокируйте данные пикселей поверхности после того, как они были заблокированы. Разблокированная поверхность снова может рисоваться и управляться с помощью pygame. См. Дополнительную информацию в документации по lock() .

Все функции игры автоматически блокируют и разблокируют данные Surface по мере необходимости.Если какой-то участок кода будет совершать вызовы,которые будут многократно блокировать и разблокировать Surface,то может быть полезно обернуть блок внутри пары блокировки и разблокировки.

Безопасно гнездиться,запирая и разблокируя звонки.Поверхность будет разблокирована только после того,как окончательный замок будет разблокирован.

mustlock()

проверить,требует ли Поверхность блокировки

mustlock() -> bool

Возвращает True , если требуется заблокировать поверхность для доступа к данным пикселей. Обычно чистые программные поверхности не требуют блокировки. Этот метод требуется редко, поскольку он безопаснее и быстрее всего просто заблокировать все поверхности по мере необходимости.

Все функции игры автоматически блокируют и разблокируют данные Surface по мере необходимости.Если какой-то участок кода будет совершать вызовы,которые будут многократно блокировать и разблокировать Surface,то может быть полезно обернуть блок внутри пары блокировки и разблокировки.

get_locked()

проверить,заблокирована ли Поверхность по току

get_locked() -> bool

Возвращает True , когда поверхность заблокирована. Неважно, сколько раз поверхность блокировалась.

get_locks()

Получает замки для Поверхностного

get_locks () -> кортеж

Возвращает существующие в настоящее время замки для Поверхности.

get_at()

получить значение цвета в одном пикселе

get_at ((x, y)) -> Цвет

Вернуть копию значения цвета RGBA в данном пикселе. Если у Surface нет пиксельной альфы, тогда альфа-значение всегда будет 255 (непрозрачное). Если позиция пикселя находится за пределами области Surface, будет IndexError исключение IndexError .

Получение и установка пикселей по одному, как правило, слишком медленно для использования в игре или ситуации в реальном времени. Лучше использовать методы, которые работают со многими пикселями одновременно, например, методы pygame.surfarray , fill и draw — или с помощью pygame.surfarray / pygame.PixelArray .

Эта функция временно блокирует и разблокирует Поверхность по мере необходимости.

Новое в pygame 1.9: возврат цвета вместо кортежа. Используйте tuple(surf.get_at((x,y))) если вам нужен кортеж, а не цвет. Это должно иметь значение только в том случае, если вы хотите использовать цвет в качестве ключа в слове.

set_at()

задать значение цвета для одного пикселя

set_at ((x, y), Color) -> Нет

Задайте значение цвета RGBA или сопоставленного целого цвета для одного пикселя. Если у поверхности нет альфа-канала на пиксель, значение альфа-канала игнорируется. Установка пикселей за пределами области поверхности или за пределами отсечения поверхности не будет иметь никакого эффекта.

Получение и установка пикселей по одному обычно происходит слишком медленно,чтобы их можно было использовать в игре или в реальном времени.

Эта функция временно блокирует и разблокирует Поверхность по мере необходимости.

get_at_mapped()

получить значение цвета на карте в одном пикселе.

get_at_mapped ((x, y)) -> Цвет

Вернуть целочисленное значение данного пикселя. Если позиция пикселя находится за пределами области Surface, будет IndexError исключение IndexError .

Данный метод предназначен для юнит-тестирования в пигаме.Маловероятно,что он имеет какое-либо применение в приложении.

Эта функция временно блокирует и разблокирует Поверхность по мере необходимости.

Новое в пигаме 1.9.2.

get_palette()

получить палитру цветового индекса для 8-битной поверхности.

get_palette() -> [RGB, RGB, RGB, …]

Вернуть список до 256 цветовых элементов,которые представляют индексированные цвета,используемые в 8-битной Surface.Возвращаемый список является копией палитры,и изменения не будут иметь никакого влияния на Surface.

Возврат списка экземпляров Color(with length 3) вместо кортежей.

Новое в пигаме 1.9.

get_palette_at()

получить цвет для одной записи в палитре

get_palette_at (индекс) -> RGB

Возвращает значения красного,зеленого и синего цвета для одного индекса в палитре Surface.Индекс должен иметь значение от 0 до 255.

Новое в pygame 1.9: возвращение экземпляра Color(with length 3) вместо кортежа.

set_palette()

задать цветовую палитру для 8-битной Поверхности

set_palette ([RGB, RGB, RGB, …]) -> Нет

Установите полную палитру для 8-битной Поверхности.Это заменит цвета в существующей палитре.Частичная палитра может быть пройдена,и будут изменены только первые цвета в исходной палитре.

Эта функция не действует на Поверхность с более чем 8 бит на пиксел.

set_palette_at()

установить цвет для одного индекса в 8-битной палитре «Surface».

set_palette_at (индекс, RGB) -> Нет

Установите значение палитры для одной записи в палитре «Поверхность».Индексом должно быть значение от 0 до 255.

Эта функция не действует на Поверхность с более чем 8 бит на пиксел.

map_rgb()

преобразовывать цвет в отображаемое значение цвета

map_rgb (Цвет) -> mapped_int

Преобразуйте цвет RGBA в сопоставленное целочисленное значение для этой поверхности. Возвращаемое целое число будет содержать не больше битов, чем битовая глубина поверхности. Сопоставленные значения цвета не часто используются внутри pygame, но могут быть переданы большинству функций, которым требуются поверхность и цвет.

Дополнительные сведения о цветах и форматах пикселей см.в документации к объекту «Поверхность».

unmap_rgb()

преобразовать отображенное целое значение цвета в Цвет

unmap_rgb (mapped_int) -> Цвет

Преобразуйте сопоставленный целочисленный цвет в компоненты цвета RGB для этой поверхности. Сопоставленные значения цвета не часто используются внутри pygame, но могут быть переданы большинству функций, которым требуется поверхность и цвет.

Дополнительные сведения о цветах и форматах пикселей см.в документации к объекту «Поверхность».

set_clip()

установить текущую область обрезки Поверхность

set_clip (rect) -> Нет

set_clip (Нет) -> Нет

Каждая поверхность имеет активную область отсечения. Это прямоугольник, представляющий единственные пиксели на поверхности, которые можно изменить. Если для прямоугольника задано None , для изменений будет доступна вся поверхность.

Область обрезки всегда ограничивается областью самой Поверхности.Если прямоугольник клипа слишком велик,то он будет сжиматься,чтобы поместиться внутри Surface.

get_clip()

получить текущую область обрезки Поверхности

get_clip() -> Rect

Вернуть прямоугольник текущей области отсечения. Поверхность всегда будет возвращать допустимый прямоугольник, который никогда не будет выходить за пределы изображения. Если для Surface не задано значение None для области отсечения, Surface вернет прямоугольник с полной площадью Surface.

subsurface()

создать новую поверхность,которая будет ссылаться на своего родителя

Подповерхность (Прямоугольник) -> Поверхность

Возвращает новую Surface,которая разделяет свои пиксели с новым родителем.Новая Surface считается дочерней по отношению к оригиналу.Модификации обоих пикселей Surface будут влиять друг на друга.Информация о Surface,такая как область отсечения и цветовые клавиши,уникальна для каждой Surface.

Новый Surface унаследует палитру,цветовую клавишу и альфа-настройки от своего родителя.

На родительском уровне можно иметь любое количество подложек и подложек.Также возможно подповерхностное покрытие дисплея Surface,если режим дисплея не имеет аппаратного ускорения.

См. get_offset() и get_parent() чтобы узнать больше о состоянии подповерхности.

Недра будут иметь тот же класс,что и родительская поверхность.

get_parent()

найти родоначальника подповерхностного слоя

get_parent () -> Поверхность

Возвращает родительскую поверхность для подповерхности. Если это не подповерхностный None , возвращается значение None .

get_abs_parent()

найти родителя верхнего уровня подповерхностного слоя

get_abs_parent () -> Поверхность

Возвращает родительскую Поверхность Подповерхностного слоя.Если это не подповерхностный слой,то эта поверхность будет возвращена.

get_offset()

найти положение дочерней подповерхностной оболочки внутри родителя.

get_offset () -> (х, у)

Получите смещенное положение дочернего подповерхностного слоя внутри родительского.Если Surface не является подповерхностным пространством,оно вернется (0,0).

get_abs_offset()

найти абсолютное положение дочерней подповерхностной зоны внутри ее родителя верхнего уровня

get_abs_offset () -> (х, у)

Получите смещенное положение дочерней подложки внутри ее родительской поверхности верхнего уровня.Если Surface не является подповерхностным уровнем,он вернется (0,0).

get_size()

получить размеры поверхности

get_size () -> (ширина, высота)

Вернуть ширину и высоту Поверхности в пикселях.

get_width()

получить ширину поверхности

get_width () -> ширина

Вернуть ширину Поверхности в пикселях.

get_height()

получить высоту Поверхности

get_height () -> высота

Вернуть высоту Поверхности в пикселях.

get_rect()

получить прямоугольную площадь Поверхности

get_rect(**kwargs) -> Rect

Возвращает новый прямоугольник,покрывающий всю поверхность.Этот прямоугольник всегда будет начинаться с (0,0)с шириной и высотой,равной размеру изображения.

В эту функцию можно передавать значения аргументов ключевого слова. Эти именованные значения будут применены к атрибутам Rect перед его возвратом. Примером может быть mysurf.get_rect(center=(100, 100)) для создания прямоугольника для поверхности с центром в заданной позиции.

get_bitsize()

получить битовую глубину пиксельного формата «Surface».

get_bitsize () -> интервал

Возвращает количество битов,используемых для представления каждого пикселя.Это значение может не точно заполнять количество байт,используемых для каждого пикселя.Например,для 15-битной Surface по-прежнему требуется 2 полных байта.

get_bytesize()

получить использованные байты на пиксел поверхности

get_bytesize () -> интервал

Возвращает количество используемых байт на пиксел.

get_flags()

получить дополнительные флаги,используемые для Surface

get_flags () -> интервал

Возвращает набор текущих функций поверхности. Каждая функция — это бит в битовой маске флагов. Типичные флаги — HWSURFACE , RLEACCEL , SRCALPHA и SRCCOLORKEY .

Вот более полный список флагов. Полный список можно найти в SDL_video.h

SWSURFACE      0x00000000    
HWSURFACE      0x00000001    
ASYNCBLIT      0x00000004    

Доступно для pygame.display.set_mode()

ANYFORMAT      0x10000000    
HWPALETTE      0x20000000    
DOUBLEBUF      0x40000000    
FULLSCREEN     0x80000000    
OPENGL         0x00000002    
OPENGLBLIT     0x0000000A    
RESIZABLE      0x00000010    
NOFRAME        0x00000020    

Используется внутри (только для чтения)

HWACCEL        0x00000100    
SRCCOLORKEY    0x00001000    
RLEACCELOK     0x00002000    
RLEACCEL       0x00004000    
SRCALPHA       0x00010000    
PREALLOC       0x01000000    

get_pitch()

получить количество используемых байт в поверхностном ряду

get_pitch () -> интервал

Возвращает количество байт,разделяющих каждую строку на поверхности.Поверхности в видеопамяти не всегда упаковываются линейно.Поверхности также будут иметь больший шаг,чем их реальная ширина.

Это значение не требуется для нормального использования пигмеев.

get_masks()

битовые маски,необходимые для преобразования между цветом и отображенным целым числом.

get_masks() -> (R, G, B, A)

Возвращает битовые маски,используемые для изоляции каждого цвета в отображенном целочисленном виде.

Это значение не требуется для нормального использования пигмеев.

set_masks()

установить битовые маски,необходимые для преобразования между цветом и отображаемым целым числом

set_masks ((r, g, b, a)) -> Нет

Это не нужно для обычного использования в пигаме.

Note

В SDL2 маски доступны только для чтения,и,соответственно,при вызове этого метода возникнет ошибка AttributeError.

Новое в пигаме 1.8.1.

get_shifts()

сдвиги битов,необходимые для преобразования между цветом и отображенным целым числом.

get_shifts() -> (R, G, B, A)

Возвращает смещения пикселей,которые необходимо преобразовать между каждым цветом и отображенным целым числом.

Это значение не требуется для нормального использования пигмеев.

set_shifts()

устанавливает сдвиги битов,необходимые для преобразования между цветом и отображаемым целым числом.

set_shifts ((r, g, b, a)) -> Нет

Это не нужно для обычного использования в пигаме.

Note

В SDL2 сдвиги доступны только для чтения,и,соответственно,при вызове этого метода возникнет ошибка AttributeError.

Новое в пигаме 1.8.1.

get_losses()

значащие биты,используемые для преобразования между цветом и отображенным целым числом.

get_losses() -> (R, G, B, A)

Возвращает наименьшее количество битов,отнятых у каждого цвета,в отображенное целое число.

Это значение не требуется для нормального использования пигмеев.

get_bounding_rect()

найти наименьшего ректора,содержащего данные

get_bounding_rect(min_alpha = 1) -> Rect

Возвращает наименьшую прямоугольную область,содержащую все пиксели на поверхности,альфа-значение которых больше или равно минимальному альфа-значению.

Эта функция временно блокирует и разблокирует Поверхность по мере необходимости.

Новое в пигаме 1.8.

get_view()

возвращает буферный вид пикселей Surface.

get_view(<kind>=’2′) -> BufferProxy

Возвращает объект,который экспортирует внутренний пиксельный буфер поверхности в виде структуры массива уровня С,массивного интерфейса уровня Питона или буферного интерфейса уровня С.Пиксельный буфер может быть записан.Новый протокол буфера поддерживается на Python 2.6 и выше в CPython.Старый протокол буферов также поддерживается для Python 2.x.Старые данные буфера находятся в одном сегменте для вида ‘0’,многосегментные для других видов буферов.

Аргументом вида является строка длиной 1 ‘0’,’1′,’2′,’3′,’r’,’g’,’b’ или ‘a’.Буквы не чувствительны к регистру;’A’ тоже сработает.Аргументом может быть как юникод,так и байт (char).По умолчанию используется ‘2’.

‘0’ возвращает представление непрерывных неструктурированных байтов. Информация о форме поверхности не дается. ValueError повышается , если пиксели поверхности являются прерывистыми.

‘1’ возвращает массив непрерывных пикселей (ширина поверхности * высота поверхности). ValueError повышается , если поверхностные пиксели являются прерывистыми.

‘2’ возвращает массив необработанных пикселей (ширина поверхности, высота поверхности). Пиксели представляют собой целые числа без знака с размером поверхности d. Формат пикселей зависит от поверхности. Трехбайтовые целые числа без знака 24-битных поверхностей вряд ли будут приняты чем-либо, кроме других функций pygame.

‘3’ возвращает массив (ширина поверхности, высота поверхности, 3) цветовых компонентов RGB . Каждый из красного, зеленого и синего компонентов представляет собой байты без знака. Поддерживаются только 24-битные и 32-битные поверхности. Компоненты цвета должны быть в порядке RGB или BGR в пикселе.

‘r’ для красного, ‘g’ для зеленого, ‘b’ для синего и ‘a’ для альфа-канала возвращает вид (ширина поверхности, высота поверхности) одного цветового компонента на поверхности: цветовая плоскость. Компоненты цвета представляют собой байты без знака. И 24-битные, и 32-битные поверхности поддерживают ‘r’, ‘g’ и ‘b’. Только 32-битные поверхности с SRCALPHA поддерживают «a».

Поверхность блокируется только при доступе к открытому интерфейсу.При доступе к новому буферному интерфейсу поверхность разблокируется,как только освобождается последний вид буфера.Для доступа к интерфейсу массива и старому интерфейсу буфера поверхность остается заблокированной до тех пор,пока объект BufferProxy не будет освобожден.

Новое в пигаме 1.9.2.

get_buffer()

приобретает буферный объект для пикселей Surface.

get_buffer() -> BufferProxy

Возвращает объект буфера для пикселей Surface.Буфер может быть использован для прямого доступа к пикселам и манипуляций с ними.Данные пикселей Surface представляются в виде неструктурированного блока памяти,со стартовым адресом и длиной в байтах.Данные не обязательно должны быть смежными.Любые пробелы включаются в длину,но в противном случае игнорируются.

Этот метод неявно блокирует Surface. Блокировка будет pygame.BufferProxy когда возвращенный объект pygame.BufferProxy будет обработан сборщиком мусора.

Новое в пигаме 1.8.

_pixels_address

адрес пиксельного буфера

_pixels_address -> int

Стартовый адрес байтов необработанных пикселей поверхности.

Новое в пигаме 1.9.2.

• Pygame
• Что такое Pygame? Каркас приложения, FPS
• Рисование графических примитивов
• Как обрабатывать события от клавиатуры
• Как обрабатывать события от мыши
• Создание поверхностей (Surface), их анимация, метод blit
• Класс Rect. Его роль, свойства и методы
• Как рисовать текст различными шрифтами
• Как работать с изображениями. Модули image и transform
• Что такое спрайты и как с ними работать
• Как делать контроль столкновений
• Добавляем звук в игровой процесс. Модули mixer и music

• Главная
• Модули
• Pygame

import pygame
pygame.init()
 
W, H = 600, 400
 
sc = pygame.display.set_mode((600, 400))
pygame.display.set_caption("Изображения")
pygame.display.set_icon(pygame.image.load("app.bmp"))
 
clock = pygame.time.Clock()
FPS = 60
 
WHITE = (255, 255, 255)
RED = (255, 0, 0)
YELLOW = (239, 228, 176)
 
print( pygame.image.get_extended() )
 
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            exit()
 
    clock.tick(FPS)

car_surf = pygame.image.load("images/car.bmp")

car_rect = car_surf.get_rect(center=(W//2, H//2))
 
sc.blit(car_surf, car_rect)
pygame.display.update()

bg_surf = pygame.image.load("images/sand.jpg")
sc.blit(bg_surf, (0, 0))

car_surf.set_colorkey((255, 255, 255))

finish_surf = pygame.image.load("images/finish.png")
sc.blit(finish_surf, (0, 0))

car_surf = pygame.image.load("images/car.bmp").convert()
finish_surf = pygame.image.load("images/finish.png").convert_alpha()
bg_surf = pygame.image.load("images/sand.jpg").convert()

car_surf = pygame.image.load("images/car.bmp")
car_surf = car_surf.convert()

car_surf2 = car_surf.convert()

bg_surf = pygame.transform.scale(bg_surf, (bg_surf.get_width()//3, bg_surf.get_height()//3))

car_up = car_surf
car_down = pygame.transform.flip(car_surf, 0, 1)
car_left = pygame.transform.rotate(car_surf, 90)
car_right = pygame.transform.rotate(car_surf, -90)

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            exit()
 
    bt = pygame.key.get_pressed()
    if bt[pygame.K_LEFT]:
        car = car_left
        car_rect.x -= speed
        if car_rect.x < 0:
            car_rect.x = 0
    elif bt[pygame.K_RIGHT]:
        car = car_right
        car_rect.x += speed
        if car_rect.x > W-car_rect.height:
            car_rect.x = W-car_rect.height
    elif bt[pygame.K_UP]:
        car = car_up
        car_rect.y -= speed
        if car_rect.y < 0:
            car_rect.y = 0
    elif bt[pygame.K_DOWN]:
        car = car_down
        car_rect.y += speed
        if car_rect.y > H-car_rect.height:
            car_rect.y = H-car_rect.height
 
    sc.blit(bg_surf, (0, 0))
    sc.blit(finish_surf, (0, 0))
    sc.blit(car, car_rect)
 
    pygame.display.update()
 
    clock.tick(FPS)