Установка библиотеки PyOpenGL

Варианты установки библиотеки PyOpenGL для языка программирования Python 3.6 в операционной системе Windows

Вариант 1. Установить автоматически с помощью pip:

1. В командной строке перейти в директорию, содержащую pip

2. Ввести команду

pip install PyOpenGL

Вариант 2. Скачать пакет программ.

1. Пройти по ссылке

https://pypi.org/project/PyOpenGL/#files

 и скачать файл "PyOpenGL-3.1.0.tar.gz"

2. В командной строке выбрать директорию, где содержится папка со скачанным файлом

3. Ввести команды

tar - zxvf PyOpenGL-3.1.0. tar. gz

cd PyOpenGL-3.1.0

python setup.py install

Вариант 3. Если не получилось установить первыми двумя способами

1. Выбрать файл нужного формата и скачать его по ссылке

https://www.lfd.uci.edu/~gohlke/pythonlibs/#pyopengl

2. В командной строке выбрать директорию, в которой содержится pip

3. Выполнить команду:

pip install PATH\FILENAME

где PATH - путь к скачанному файлу

     FILENAME - название скачанного файла.

Библиотека PyOpenGL

Библиотека PyOpenGL – модуль, позволяющий работать с функциями OpenGL, GLU и GLUT, а также с рядом расширений OpenGL в программах на языке Python.

К характерным особенностям OpenGL, можно отнести:

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

· Надежность и переносимость. Приложения, использующий OpenGL, дают одинаковый визуальный результат вне зависимости от операционной системы (ОС). Они также могут выполняться не только на персональных компьютерах, но и на рабочих станциях и даже суперкомпьютерах.

· Легкость применения. Стандарт OpenGL имеет продуманную структуру и интуитивно понятный интерфейс. Это позволяет создавать довольно эффективные приложения. А необходимые функции для обеспечения совместимости с различным оборудованием реализованы на уровне библиотеки и значительно упрощают разработку приложений такого вида.

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

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

Однако OpenGL не включает специальных команд для работы с окнами или для ввода пользователем информации. Поэтому были созданы специальные переносимые библиотеки для часто используемых функций взаимодействия с пользователем и для отображения информации с помощью оконной подсистемы. Например библиотека GLUT (GL Utility Toolkit).

GL обрабатывает и рисует в буфере кадра графические примитивы с учетом выбранных режимов. Примитив – это точка, отрезок, многоугольник и т.д. Режим может быть изменен независимо от других. Определение примитивов, выбор режимов и другие операции описываются с помощью команд в форме вызовов функций прикладной библиотеки. Примитивы определяются набором из одной или более вершин (vertex). Вершина определяет точку, конец отрезка или угол многоугольника. Вершина определяется некоторыми атрибутами (координаты, цвет, нормаль, текстурные координаты и т.д.).

Графическая система OpenGL – конвейер, состоящий из нескольких последовательных этапов обработки графических данных. Команды OpenGL всегда обрабатываются в том порядке, в котором они поступают, хотя могут происходить задержки перед тем, как проявится эффект от их выполнения. В большинстве случаев OpenGL предоставляет непосредственный интерфейс, т.е. определение объекта вызывает его визуализацию в буфере кадра.

Для работы с OpenGL нужно загрузить пакеты из сети Интернет, после чего распаковать и установить.

 

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

Type glCommand_name[1 2 3 4][b s i f d ub us ui][v](type1 arg1,…,typeN argN)

Таким образом, имя состоит из нескольких частей:

gl – это имя библиотеки, в которой описана эта функция: для базовых функций OpenGL, функций из библиотек GLU, GLUT, GLAUX это gl, glu, glut, aux соответственно.

Command_name – имя команды.

[1 2 3 4] – число аргументов команды.

[b s i f d ub us ui ] – тип аргумента (прототипы привычных нам b – Glbyte, f – Glfloat и т.д.)

[v] - наличие этого символа показывает, что в качестве параметров функции используется указатель на массив значений.

Рассмотрим некоторые особенности синтаксиса модуля PyOpenGL. Начнём с особенностей GLUT.

Функции GLUT можно разделить на несколько групп по своему назначению, а именно:

• Инициализация;
• Начало обработки событий;
• Управление окнами;
• Управление меню;
• Регистрация вызываемых функций;
• Управление индексированной палитрой цветов;
• Отображение шрифтов;
• Отображение дополнительных геометрических фигур (таких как тор, конус, шар и др.).

Инициализация производится с помощью функции glutInit(), выполняющая начальные действия для построения окна приложения. Несколько следующих функций GLUT могут вызваться до нее:

glutInitWindowPosition(int x, int y) – определение позиции верхнего левого края экрана окна приложения;

glutInitWindowSize(int width, int height) –  определение высоты и ширины окна приложения;

glutInitDisplayMode(unsigned int mode) – определяет различные режимы отображения информации.

Некоторые варианты режимов отображения:

GLUT_RGBA – режим RGBA, используемый по умолчанию, который может быть заменен на GLUT_INDEX.

GLUT_INDEX – режим индексированных цветов (использование палитры). Отменяет GLUT_RGBA.

GLUT_SINGLE – окно с одиночным буфером, используемый по умолчанию.

GLUT_DOUBLE – окно с двойным буфером. Отменяет GLUT_SINGLE. Обычно используется для анимации, сначала рисуют что-нибудь в одном буфере, а затем меняют их местами, что позволяет избежать мерцания.

GLUT_DEPTH – окно с буфером глубины или z-буфером, удаляющий невидимые линии и поверхности.

Имеется внутренний цикл, запускаемый после инициализации и обрабатывает, все объявленные во время инициализации события одно за другим. К событиям можно отнести: щелчок мыши, закрытие окна, изменение свойств окна, передвижение курсора, нажатие клавиши, и даже "пустое" (idle) событие, когда ничего не происходит. Для периодической проверки совершения события, нужно зарегистрировать функцию, которая будет его обрабатывать. Для этого используются функции следующего вида, параметром для них является имя соответствующей функции заданного типа:

glutDisplayFunc() – задается функция рисования для окна приложения, вызвающая создание или восстановление изображения.

glutReshapeFunc () – функция изменяющая размер окна пользователем.

glutMouseFunc () – определяет обработчика команд от мыши.

glutIdleFunc() – вызывается каждый раз, когда нет событий от пользователя.

Контроль всех событий происходит внутри бесконечного цикла в функции glutMainLoop (), которая, как правило, вызывается в конце любой программы, использующей GLUT.

В библиотеке PyOpenGL под вершиной понимается точка в трехмерном пространстве, координаты которой можно задавать с помощью следующей функции: glVertex[2 3 4][s i f d] (type coords).

Координаты точки задаются максимум четырьмя значениями: x, y, z, w, при этом можно указывать два (x,y) или три (x,y,z) значения, а для остальных переменных в этих случаях используются значения по умолчанию: z=0, w=1. Как уже было сказано выше, число в названии команды соответствует числу явно задаваемых значений, а последующий символ – их типу.

Координатные оси расположены таким образом, что точка (0,0) лежит в левом нижнем углу экрана, ось x направлена влево, ось y – вверх, ось z – из экрана.

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

glBegin(GLenum mode) glEnd()

Параметр mode определяет тип примитива, который задается внутри и может принимать следующие значения:

GL_POINTS – каждая вершина задает координаты некоторой точки.

GL_LINES – каждая отдельная пара вершин определяет отрезок, при этом если задано нечетное число вершин, то последняя вершина будет игнорироваться.

GL_LINE_STRIP – каждая следующая вершина задает отрезок вместе с предыдущей.

GL_LINE_LOOP – каждая следующая вершина задает отрезок вместе с предыдущей и последний отрезок определяется последней и первой вершиной, образуя замкнутую ломаную.

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

GL_TRIANGLE_STRIP – каждая следующая вершина задает треугольник вместе с двумя предыдущими.

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

GL_POLYGON – последовательно задаются вершины выпуклого многоугольника.

Для задания цвета вершины используются команда glColor[3 4][b s i f] (GLtype components), где первые три параметра задают R, G, B компоненты цвета, а последний параметр определяет значение, которое задает уровень прозрачности объекта.

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

Для задания цвета фона используется команда glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha). Значения должны находиться в отрезке [0,1] и по умолчанию равны нулю. После этого вызов команды glClear(GLbitfield mask) с параметром GL_COLOR_BUFFER_BIT устанавливает цвет фона во все буфера, доступные для записи цветов.

Кроме цвета аналогичным образом можно определить нормаль в вершине, используя команду  glNormal3[b s i f d](type coords). Причём задаваемый вектор может и не иметь единичной длины, но всё же он будет нормироваться автоматически в режиме нормализации, который включается вызовом команды glEnable(GL_NORMALIZE) и отключается командой glDisable(GLenum mode).

Существуют более сложные фигуры: сфера, цилиндр, диск (в GLU) и сфера, куб, конус, тор, тетраэдр, додекаэдр, икосаэдр, октаэдр и чайник (в GLUT).

В PyOpenGL в качестве основных используются три системы координат: левосторонняя, правосторонняя и оконная. Первые две системы являются трёхмерными и отличаются друг от друга всего лишь направлением оси z, то есть в правосторонней это ось направлена из экрана, а в левосторонней – в обратную сторону. Расположение осей x и y аналогично описанному выше. Левосторонняя система используется для задания значений параметрам команды gluPerspective(), glOrtho(), а правосторонняя или мировая система координат во всех остальных случаях. Отображение трехмерной информации происходит в двумерную оконную систему координат.

Для задания различных преобразований объектов используются операции над матрицами, при этом существуют три типа матриц: видовая матрица, матрица проекций и матрица текстуры. Каждая имеет размер 4x4. Видовая матрица определяет преобразования объекта в мировых координатах, такие как параллельный перенос, изменение масштаба и поворот. Матрица проекций задаёт, как именно будут проецироваться трёхмерные объекты на плоскость экрана (в оконные координаты), а матрица текстуры определяет наложение текстуры на объект.

Для переноса точки в новое положение необходимо добавить к ее координатам некоторые числа, которые представляют собой координаты вектора переноса:

Матрица трехмерного переноса аналогична двумерному случаю:

, при этом

.

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

В трех мерном случае Операция масштабирования:

Поворот точки А на угол  относительно начала координат выглядит следующим образом:

При двумерном повороте в плоскости  координаты  остаются неизменными, то поворот вокруг оси  записывается так:

.

Матрица поворота вокруг оси имеет вид:

,

и вокруг оси :

Чтобы выбрать, какую именно матрицу следует изменить, нужно использовать команду glMatrixMode(GLenum mode), вызов которой со значением параметра mode равным GL_MODELVIEW, GL_PROJECTION, GL_TEXTURE включает режим работы с видовой матрицей, матрицей проекций и матрицей текстуры соответственно. Для вызова команд, задающих матрицы того или иного типа необходимо сначала установить соответствующий режим.

Для определения элементов матрицы текущего типа вызывается команда glLoadMatrix[f d] (GLtype *m), где m указывает на массив из 16 элементов типа float или double в соответствии с названием команды, при этом сначала в нем должен быть записан первый столбец матрицы, затем второй, третий и четвертый.

Команда glLoadIdentity(void) заменяет текущую матрицу на единичную. Часто нужно сохранить содержимое текущей матрицы для дальнейшего использования, для чего используют команды glPushMatrix(void) и glPopMatrix(void). Они записывают и восстанавливают текущую матрицу из стека, причем для каждого типа матриц стек свой.

Для отображения трехмерных объектов сцены используются некоторые команды преобразований. К видовым преобразованиям относятся перенос, поворот и изменение масштаба вдоль координатных осей. Для осуществления этих операций следует умножить на соответствующую матрицу каждую вершину объекта и получить измененные координаты этой вершины:

(x’, y’, z’, 1)T = M * (x, y, z, 1),T

где M – матрица видового преобразования. Перспективное преобразование и проектирование производится аналогично.

Сама матрица может быть создана с помощью следующих команд:

glTranslate[f d](GLtype x, GLtype y, GLtype z) – производит перенос объекта, прибавляя к координатам его вершин значения своих параметров.

glRotate[f d](GLtype angle, GLtype x, GLtype y, GLtype z) – производит поворот объекта против часовой стрелки на угол angle (измеряется в градусах) вокруг вектора (x,y,z).

glScale[f d](GLtype x, GLtype y, GLtype z) - производит масштабирование объекта (сжатие или растяжение), умножая соответствующие координаты его вершин на значения своих параметров.

В случае если надо, например, повернуть один объект сцены, а другой оставить неподвижным, удобно сначала сохранить текущую видовую матрицу в стеке командой glPushMatrix(), затем вызвать glRotate() с нужными параметрами, описать примитивы, из которых состоит этот объект, а затем восстановить текущую матрицу командой glPopMatrix().

В рассматриваемой библиотеке существуют ортографическая (параллельная) и перспективная проекция. Первый тип проекции может быть задан командами:

glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far) – команда создает матрицу проекции в усеченный объем видимости (параллелограмм видимости) в левосторонней системе координат. Параметры команды задают точки (left, bottom, -near) и (right, top, -near), которые отвечают левому нижнему и правому верхнему углам окна вывода. Параметры near и far задают расстояние до ближней и дальней плоскостей отсечения по дальности от точки (0,0,0) и могут быть отрицательными.

gluOrtho2D(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top)- в этой команде, в отличие от первой, значения near и far устанавливаются равными –1 и 1 соответственно.

Перспективная проекция определяется командой:

gluPerspective(GLdouble angley, GLdouble aspect, GLdouble znear, GLdouble zfar) – она задает усеченный конус видимости в левосторонней системе координат. Параметр angley определяет угол видимости в градусах по оси у и должен находиться в диапазоне от 0 до 180. Угол видимости вдоль оси x задается параметром aspect, который, как правило, задается как отношение сторон области вывода. Два параметра zfar и znear задают расстояние от наблюдателя до плоскостей отсечения по глубине и должны быть положительными.

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

Добавить источник света можно с помощью команды glLight[i f](GLenum light, GLenum pname, GLfloat param). Параметр light определяет источник и выбирается из набора специальных символических имен вида GL_LIGHTi, где i должно лежать в диапазоне от 0 до GL_MAX_LIGHT, которое не превосходит восьми.

Как правило, в библиотеке PyOpenGL используется модель освещения Фонга, согласно которой цвет точки определяется несколькими факторами: свойствами материала и текстуры, величиной нормали в этой точке, а также положением источника света и наблюдателя. Для корректного расчета освещенности в точке надо использовать единичные нормали, но всё же команды типа glScale(), могут изменять их длину. Чтобы это учитывать, используется уже упоминавшийся режим нормализации нормалей, который включается вызовом команды glEnable(GL_NORMALIZE).

Для задания глобальных параметров освещения используется команда glLightModel[i f](GLenum pname, GLenum param), где аргумент pname определяет, какой параметр модели освещения будет настраиваться.

Рассмотрим стандартные команды построения примитивов.

Для построения нужного примитива следует произвести вызов соответствующей команды.

glutSolidSphere(GLdouble radius, GLint slices, GLint stacks) – строит сферу.

glutWireSphere(GLdouble radius, GLint slices, GLint stacks) – каркас сферы радиусом radius.

glutSolidCube(GLdouble size) – строит куб.

glutWireCube(GLdouble size) – строит каркас куба с центром в начале координат и длиной ребра size.

glutSolidCone(GLdouble base, GLdouble height, GLint slices, GLint stacks) - строит конус.

glutWireCone(GLdouble base, GLdouble height, GLint slices, GLint stacks) – строит каркас конуса высотой height и радиусом основания base, расположенный вдоль оси z. Основание находится в плоскости z=0.

glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius, GLint nsides, GLint rings) - команда строит тор.

glutWireTorus(GLdouble innerRadius, GLdouble outerRadius, GLint nsides, GLint rings) – строит каркас тора в плоскости z=0. Внутренний и внешний радиусы задаются параметрами innerRadius, outerRadius. Параметр nsides задает число сторон в кольцах, составляющих ортогональное сечение тора, а rings- число радиальных разбиений тора.

glutSolidTetrahedron(void) – строит тетраэдр (правильную треугольную пирамиду).

glutWireTetrahedron(void) – строит его каркас, при этом радиус описанной сферы вокруг него равен 1.

glutSolidOctahedron(void) – команда строит октаэдр.

glutWireOctahedron(void) – его каркас, радиус описанной вокруг него сферы равен 1.

glutSolidDodecahedron(void) – строит додекаэдр.

glutWireDodecahedron(void) – его каркас, радиус описанной вокруг него сферы равен квадратному корню из трёх.

glutSolidIcosahedron(void) – строит икосаэдр.

glutWireIcosahedron(void) – его каркас, радиус описанной сферы равен 1.

Пример 1.

import sys

from OpenGL.GLUT import *

from OpenGL.GL import *

# Инициализация освещения

def init():

light_ambient = [0.0, 0.0, 0.0, 1.0]

light_diffuse = [1.0, 1.0, 1.0, 1.0]

light_specular = [1.0, 1.0, 1.0, 1.0]

light_position = [1.0, 1.0, 1.0, 0.0]

glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient)

glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse)

glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular)

glLightfv(GL_LIGHT0, GL_POSITION, light_position)

glEnable(GL_LIGHTING)

glEnable(GL_LIGHT0)

glEnable(GL_DEPTH_TEST)

def display():

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

glPushMatrix()

 glRotatef(20.0, 1.0, 0.0, 0.0)

glPushMatrix()

glTranslatef(-0.75, 0.5, 0.0) # пространственные перемещения

glRotatef(90.0, 1.0, 0.0, 0.0) # пространственные перемещения

glutSolidTorus(0.275, 0.85, 15, 15) # прорисовка тора

glPopMatrix()

glPushMatrix()

glTranslatef(-0.75, -0.5, 0.0) # пространственные перемещения

glRotatef(270.0, 1.0, 0.0, 0.0) # пространственные перемещения

glutSolidCone(1.0, 2.0, 15, 15) # прорисовка конуса

glPopMatrix()

glPushMatrix()

glTranslatef(0.75, 0.0, -1.0) # пространственные перемещения

glutSolidSphere(1.0, 15, 15) # прорисовка сферы

glPopMatrix()

glPopMatrix()

glFlush()

def reshape(w, h):

glViewport(0, 0, w, h)

glMatrixMode(GL_PROJECTION)

glLoadIdentity()

if w <= h:

   glOrtho(-2.5, 2.5, -2.5 * h / w, 2.5 * h / w,

           -10.0, 10.0) # создание матрицы проекции

else:

   glOrtho(-2.5 * w / h, 2.5 * w / h,

           -2.5, 2.5, -10.0, 10.0) # создание матрицы проекции

glMatrixMode(GL_MODELVIEW)

glLoadIdentity()

# Открытие окна с заданными размерами и заголовком

# RGBA отображение

glutInit(sys.argv)

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH)

glutInitWindowSize(500, 500)

glutCreateWindow('Figures')

init()

glutReshapeFunc(reshape)

glutDisplayFunc(display)

glutMainLoop()

Результат работы программы:

Пример 2.

from OpenGL.GL import *

from OpenGL.GLU import *

import pygame

from pygame.locals import *

verticies = ((1, -1, -1), (1, 1, -1),

         (-1, 1, -1), (-1, -1, -1),

         (1, -1, 1), (1, 1, 1),

         (-1, -1, 1), (-1, 1, 1))

edges = ((0,1), (0,3), (0,4), (2,1), (2,3), (2,7),

     (6,3), (6,4), (6,7), (5,1), (5,4), (5,7))

def Cube():

glBegin(GL_LINES) # прорисовка происходит линиями по массиву вершин vertex и сторон edge

for edge in edges:

   for vertex in edge:

       glVertex3fv(verticies[vertex])

glEnd()

def main():

pygame.init()

display = (800,600) # отображение окна

pygame.display.set_mode(display, DOUBLEBUF|OPENGL)

gluPerspective(45, (display[0]/display[1]), 0.1, 50.0)

glTranslatef(0.0,0.0, -5) # пространственные перемещения

while True:

for event in pygame.event.get():

     if event.type == pygame.QUIT:

        pygame.quit()

        quit()

glRotatef(1, 3, 1, 1) # пространственные перемещения

glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)

Cube() # вызов функции прорисовки куба

pygame.display.flip()

pygame.time.wait(10)

main()

Результат работы программы:

Пример 3.

from OpenGL.GL import *

from OpenGL.GLU import *

from OpenGL.GLUT import *

import sys

global xrot # величина вращения по оси X

global yrot # величина вращения по оси Y

global ambient # рассеянное освещение

global greencolor # цвет ёлки

global treecolor # цвет ствола

global lightpos # положение источника света

def init():

global xrot # величина вращения по оси X

global yrot # величина вращения по оси У

global ambient

global greencolor

global treecolor

global lightpos

xrot = 0.0

yrot = 0.0

ambient = (1.0, 1.0, 1.0, 1) # цвет и яркость

greencolor = (0.2, 0.8, 0.0, 0.8)

treecolor = (0.9, 0.6, 0.3, 0.8)

lightpos = (1.0, 1.0, 1.0)

glClearColor(0.65, 0.0, 1.0, 1.0) # фон

gluOrtho2D(-1.0, 1.0, -1.0, 1.0) # границы

glRotatef(-90, 1.0, 0.0, 0.0) # смещение по X

glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient) # освещение

glEnable(GL_LIGHTING)

glEnable(GL_LIGHT0)

glLightfv(GL_LIGHT0, GL_POSITION, lightpos) # положение света

def specialkeys(key, x, y): # отработка нажатий клавиш

global xrot

global yrot

xrot -= 2.0 * (key==GLUT_KEY_UP) # уменьшение угла вращения по X

xrot += 2.0 * (key == GLUT_KEY_DOWN) # увеличение угла по X

yrot -= 2.0 * (key == GLUT_KEY_LEFT) # уменьшение угла по Y

yrot += 2.0 * (key == GLUT_KEY_RIGHT) # увеличение угла по Y

glutPostRedisplay()

def draw(): # перерисовка

global xrot

global yrot

global lightpos

global greencolor

global treecolor

glClear(GL_COLOR_BUFFER_BIT) # очистка экрана

glPushMatrix() # сохранение положения обзора

glRotatef(xrot, 1.0, 0.0, 0.0) # вращение по Х на xrot

glRotatef(yrot, 0.0, 1.0, 0.0) # вращение по У на xrot

glLightfv(GL_LIGHT0, GL_POSITION, lightpos) # вращение ист - ка света

# ствол

glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, treecolor)

glTranslatef(0.0, 0.0, -0.7) # сдвиг на -0.7

glutSolidCylinder(0.1, 0.2, 20, 20) # цилиндр

# Ёлка

glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, greencolor)

glTranslatef(0.0, 0.0, 0.2) # сдвиг 0.2

glutSolidCone(0.5, 0.5, 20, 20) # конус

glTranslatef(0.0, 0.0, 0.3)

glutSolidCone(0.4, 0.4, 20, 20) # конус

glTranslatef(0.0, 0.0, 0.3)

glutSolidCone(0.3, 0.3, 20, 20) # конус

glPopMatrix() # положение обзора

glutSwapBuffers() # на экран

# вывод окна с заданными параметрами и названием

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB)

glutInitWindowSize(300, 300)

glutInitWindowPosition(50, 50)

glutInit(sys.argv)

glutCreateWindow(b"It's a Christmas Tree!")

glutDisplayFunc(draw) # вызов перерисовки

glutSpecialFunc(specialkeys) # вызов отработки клавиш

init()

glutMainLoop()

Результат работы программы:

8.7. Преобразование изображения куба

Изображение куба задается четырьмя параметрами: X,Y – координаты левого нижнего угла передней грани, A – длина ребра куба, Alf – угол наклона. Для определенности ребра параллельные оси Y рассматриваются красного цвета, ребра параллельные оси Х – синего цвета, ребра параллельные оси Z –зеленого цвета,

Рассмотрим следующие преобразования куба, сохраняющие изображение куба в рабочем поле:

1. Перемещение c изменением координаты X,Y;

2. Поворот с изменением угла Alf;

3. Изменение размера куба А.

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

Функции XS(), YS() вычислят значения X’ и Y’, а функция NoChek() проверит возможность прорисовки куба.

 

import pygame

import math

pygame.init()

win = pygame.set.diplay.set_mode((500,500))

pygame.display.set_caption('uen')

X=Y=200

A = 100

Alf=30

Def XS(): return int(A*math.cos(math.radians(Alf))

Def YS(): return int(A*math.sin(math.radians(Alf))

Def NoCheck():

if (X<0 or X+ XS()<0 or # проверка левой границы

   Y>=500 or Y- YS()>=500 or # проверка нижнй границы

   Y- A<0 or Y- YS()- A<0 or # проверка верхней границы

   X+ A>=500 or X+ XS()+ A>=500: # проверка правой границы

   return True

else: return False

run= True

while run:

pygame.time.delay(100)

# управление кубом

for eveny in pygame.event.get():

if event.type == pygame.QUIT: # завершение работы цикла

   run = False

# реакция на клавищи управления – движение

keys = pygame.key.get_pressed()

if keys(pygame.K_LEFT):

   X-= speed

   if NoCheck(): X+= speed

if keys(pygame.K_RIGHT):

   X+= speed

   if NoCheck(): X-= speed

if keys(pygame.K_UP):

   Y-= speed

   if NoCheck(): Y+= speed

if keys(pygame.K_DOWN):

   Y+= speed

   if NoCheck(): Y-= speed

# реакция на клавищи управления – вращение

if keys(pygame. K_ HOME):

   Alf+= speed

   if NoCheck(): Alf-= speed

if keys(pygame.K_END):

   Alf-= speed

   if NoCheck(): Alf+= speed

# реакция на клавищи управления – изменение размера

if keys(pygame.K_PGUP):

   A+= speed

   if NoCheck(): A-= speed

if keys(pygame.K_PGDN):

   A-= speed

   if NoCheck(): A+= speed

pygame.draw.rect(win, (0,0,0), (x,y,width, height))

pygame.display.update()

pygame.

Упражнение 1.

Написать программу рисования графика функции

a) y=cos(x)

b) y=x²

c) y=abs(x)

Упражнение 2.

a) Написать программу рисования контура куба.

b) Написать программу рисование куба с ребрами черного цвета и окрашенными гранями.

Упражнение 3.

c) Написать программу забивания гвоздя.

d) Написать программу прыгания мяча.

Обработка текста

Одна из основных задач обработка и анализ текста.

Для перевода с одного алфавита в другой можно использовать библиотеку transliterate, которая переводит с латиницу кирилицу и обратно.

Пример 1.

import codecs
from transliterate import translit
from tkinter import *
from tkinter import messagebox as mb

def translate():
f = codecs.open(name_input.get(), 'r', encoding= 'utf-8')
# ввод текста на кирилице с переводом на латиницу в переменную s
s = translit(f.read(), "ru", reversed= True)
f.close()
f = codecs.open(name_output.get(), 'w', encoding= 'utf-8')
f.write(s)
f.close()
exit(-1)

root = Tk()
root.title(" ТРАНСЛИТЕРАЦИЯ КИРИЛИЦЫ В ЛАТИНИЦУ " )

input = StringVar()
output = StringVar()

name_label = Label(text= "Enter input file")
surname_label = Label(text= "Enter output file")

name_label.grid(row=0, column=0, sticky= "w")
surname_label.grid(row=1, column=0, sticky= "w")

name_input = Entry(textvariable=input)
name_output = Entry(textvariable=output)

name_input.grid(row=0, column=1, padx=5, pady=5)
name_output.grid(row=1, column=1, padx=5, pady=5)
print(output.get())

message_button = Button(text= "Translate", command=translate)
message_button.grid(row=2, column=1, padx=5, pady=5, sticky= "e")
root.mainloop()

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

Функция	Её смысл
re.search(pattern, string)	Найти в строке string первую строчку, подходящую под шаблон pattern;
re.fullmatch(pattern, string)	Проверить, подходит ли строка string под шаблон pattern;
re.split(pattern, string, maxsplit=0)	Аналог str.split(), только разделение происходит по подстрокам, подходящим под шаблон pattern;
re.findall(pattern, string)	Найти в строке string все непересекающиеся шаблоны pattern;
re.finditer(pattern, string)	Итератор всем непересекающимся шаблонам pattern в строке string (выдаются match-объекты);
re.sub(pattern, repl, string, count=0)	Заменить в строке string все непересекающиеся шаблоны pattern на repl;

Пример 2. Посчет частоты появления чисел в тексте.

import re
F = {}
F_ txt = open(' text', ' r' )
txt_ str = d_ txt. read()
# Выбор чисел из текста

match_pattern = re.findall(r'\b[0-9]{1,100}\b', txt_str)

# Опрееделение частоты появления чисел в тексте

for word in match_pattern:
count = F.get(word, 0)
F[word] = count + 1
F_list = F.keys()
# Вывод чисел, появившихся в тексте с их частотой

for words in sorted(F, key=F.get, reverse= True):
print(words, F[words])

 

База данных

Для доступ к базе данных через Microsoft ADO используется пакет PostgreSQL

Установк пакета производится командой

pip install psycoppg2

Подключение пакета производится следующим образом:

import psycopg2

DB = psycopg2.connect(dbname='my_db', user='KPFU')

curDB = DB. cursor()

…

# Выполнение SQL-запроса

curDB.execute("SELECT * FROM tab_1") # tab_1 – имя таблицы

r = curDB. fetchone() # получение текущей записи из таблицы

r = curDB. fetchone() # получение вссех записей из таблицы

# Закрытие базы данных

cur DB.close()

DB.close()

SQL-запрос

Создание таблицы

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

Создадим простую таблицу по имени month. Она состоит из 3 колонок:

· id – Номер месяца в календарном году (целое число).

· name – Название месяца (строка, максимум 10 символов).

· days – Количество дней в этом месяце (целое число).

Вот как будет выглядеть соответствующий SQL запрос:

CREATE TABLE months (

id int,

name varchar(10),

days int

);

Также при создании таблиц необходимо добавить первичный ключ для одной из колонок. Это позволит держать записи уникальными и ускорит запросы на выборку. Пусть в нашем случае уникальным будет название месяца (столбец name)

CREATE TABLE months (

id int,

name varchar(10),

days int,

PRIMARY KEY (name)

);

Строковые типы данных

ТИП ДАННЫХ       ОПИСАНИЕ

CHAR                      Строка длины 1-255 символов

TEXT                       не более 65 535 символов

Числовые типы данных

ТИП ДАННЫХ       ОПИСАНИЕ

INT                          -2 147 483 648.. 2 147 483 647

FLOAT                    Число с плавающей точкой

Вставка строк

Теперь давайте заполнять нашу таблицу months полезной информацией. Добавление записей в таблицу производится через инструкцию INSERT. Есть два способа записи этой инструкции.

1-й способ указываются только значения.

INSERT INTO months VALUES (1,'January',31);

Этот способ не гарантирует соответствие (по мере расширения проекта и редактировании таблицы может быть утеряно соответствие столбцов).

Безопасный способ записи инструкции INSERT требует указания как значений, так и порядка следования столбцов:

INSERT INTO months (id,name,days) VALUES (2,'February',29);

Извлечение данных из таблиц

SELECT – получает данные из базы данных.

SELECT – запрос, возвращающий все столбцы и строки из таблицы (например, таблицы по имени characters):

SELECT * FROM " characters"

Символ звездочка (*) означает, что требуются данные из всех столбцов. Так БД SQL обычно состоят из более чем одной таблицы, поэтому указывают ключевое слово FROM, за которым пробел должно следовать название таблицы.

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

SELECT id, name FROM month

Во многих случаях полученные результаты необходимо отсортировать в определенном порядке. В SQL ORDER BY выполняет эту функцию. Он может принимать опциональный модификатор – ASC (по-умолчанию) сортирующий по возрастанию или DESC, сортирующий по убыванию:

SELECT id, name FROM month ORDER BY name DESC

ORDER BY должен быть последней в инструкции SELECT. В противном случае будет выдано сообщение об ошибке.

Фильтрация данных

Если нам нужно получить еще и определенные строки? На помощь здесь приходит условие, то используется WHERE, позволяющее фильтровать данные в зависимости от условия.

При выборе только тех месяцев из таблицы month, в которых больше 30 дней с помощью оператора больше (>):

SELECT id, name FROM month WHERE days > 30

Операторы в условии WHERE