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

История машинного обучения начинается с середины XX века. В 1952 году Артур Самуэль разработал первую самообучающуюся программу для игры в шашки, что стало отправной точкой в развитии МО. Позже, в 1959 году, он начал работу над методами МО для нейронных сетей. С тех пор технологии существенно эволюционировали и получили широкое распространение.

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

Для разработки и обучения нейронных сетей широко используется библиотека TensorFlow, предоставляемая Google. Она обеспечивает высокую производительность и гибкость при создании сложных моделей МО. TensorFlow поддерживает работу как на CPU, так и на GPU, что позволяет значительно ускорить процесс обучения нейронных сетей.

Google Colab предоставляет удобную среду для разработки и обучения моделей машинного обучения. Это облачный сервис, который позволяет использовать мощные вычислительные ресурсы Google без необходимости установки дополнительного программного обеспечения. Colab поддерживает работу с Jupyter Notebook и позволяет совместно работать над проектами в реальном времени​.

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

Формат данных выборки для обучения train.csv выглядит следующим образом: каждая строка представляет собой описание одного изображения; первый столбец содержит метки классов, к которым принадлежит изображение; оставшиеся столбцы содержат пиксельные значения изображения, например, в виде плоского вектора, где каждое значение соответствует яркости соответствующего пикселя на изображении [1].

У нас будут следующие классы согласных букв:

classes = ["к","л","м","н","п","р","с","т"]

Загрузим и посмотрим на датасет (рисунок 1):

Рисунок 1. Датасет согласных букв

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

Работа нейронной сети рассматривается в трех моделях.

1.    Двухслойная нейронная сеть.

На первом шаге рассматривается сеть из двух нейронных слоев [2]. Для создания модели используется класс Sequential. На входном слое находятся 700 нейронов. Функция активации (запуска) relu, размер входных данных равен 400 (у нас картинки 20 на 20). На последнем слое должно быть 8 нейронов, так как это количество должно совпадать с количеством классификаций изображений [3] (у нас согласные буквы “к”,”л”,”м”,”н”,”п”,”р”,”с”,”т”). Модель нейронной сети строится с помощью класса Sequential [4].

N = 8

model = Sequential()

model.add(Dense(700, input_dim=400, activation=”relu”))

model.add(Dense( N, activation=”softmax”))

Приступаем к обучению модели с помощью метода fit модели (рисунок 2).

Рисунок 2. Ход обучения нейронной сети

Можно посмотреть, как нейронная сеть делает предсказание на тестовых данных. Для этого применяется метод predict:

Рисунок 3. Валидация нейронной сети

2. Трехслойная нейронная сеть.

Усложним нейронную сеть, сделав 3 слоя. Рассматривается сеть из трех нейронных слоев:

model = Sequential()

model.add(Dense(700, input_dim=400, activation=”relu”))

model.add(Dense(100, activation=”relu”))

model.add(Dense( N, activation=”softmax”))

Остальные шаги проделываются аналогично.

3. Сверточная нейронная сеть.

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

model = Sequential()

model.add(Conv2D(32, (3, 3),

input_shape=(img_width, img_height, 1), activation=’relu’))

model.add(MaxPooling2D(pool_size=(2,2)))

model.add(Conv2D(64, (3, 3), activation=’relu’))

model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Flatten())

model.add( Dense( 700, activation = ‘relu’))

model.add( Dense( N, activation=’softmax’))

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

Таблица 1 – Качество распознавания изображений нейронными сетями

Подготовим также в Paint собственные изображения и загрузим их на гугл-диск (рисунок 4).

Рисунок 4. Собственные изображения для проверки

работы нейронной сети

Обученная нейронная сеть используется для распознавания согласных букв на новых данных. Модель анализирует входное изображение и выдает прогнозируемую букву с определенной вероятностью. Точность распознавания оценивается на тестовом наборе данных, который не использовался в процессе обучения, что позволяет объективно оценить её эффективность.

Рисунок 5. Распознавание и предсказание нейронной сети

Сверточная нейронная сеть будет, как и ожидалось, давать наилучшее предсказание.

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

Введение

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

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

1. Преобразование текста в числовой формат: функции Maple и их назначение

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

• proc – конструкция для объявления пользовательской процедуры;

• Ord – преобразует символ в его числовой ASCII-код;

• Char – выполняет обратное преобразование к символу;

• length – определяет количество символов в строке;

• parse – превращает строку цифр в целое число;

• convert – выполняет преобразование типов данных (в данной лабораторной работе используется косвенно).

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

2. Генерация ключей RSA: математические основы и функции Maple

Процесс создания электронной подписи начинается с формирования ключевой пары: закрытого и открытого ключа RSA. Для выполнения этих операций используются функции Maple, применяемые в теории чисел:

• nextprime – позволяет находить следующие простые числа, необходимые для генерации модуля RSA;

• igcdex – вычисляет расширенный алгоритм Евклида и помогает найти мультипликативно обратный элемент;

• igcd – определяет наибольший общий делитель чисел.

Через определение igcd естественным образом вводится понятие взаимно простых чисел, что соответствует шестому контрольному вопросу: два числа считаются взаимно простыми, если их НОД равен 1, например, 8 и 15. Операции возведения в степень по модулю выполняются через функцию power, которая используется при шифровании хэша и при проверке подписи.

3. Теоретический фундамент RSA: функция Эйлера и классические теоремы

Для корректной работы RSA критически важной является функция Эйлера φ(n), определяемая как количество натуральных чисел, меньших n и не имеющих с ним общих делителей. Если n является произведением двух простых чисел p и q, то:

Далее последовательно вводятся теорема Эйлера и малая теорема Ферма.

• Теорема Эйлера утверждает: для любого числа a, взаимно простого с n, выполняется

• Малая теорема Ферма является частным случаем для простого модуля и гласит:

4. Вычисление хэша сообщения

Для формирования электронной подписи необходимо получить компактное числовое представление текста – его хэш. В рамках лабораторной работы допускается упрощенная схема хэширования, например вычисление остатка от деления большого числа, полученного через str_to_num.

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

5. Формирование электронной подписи и проверка ее подлинности

Электронная подпись создается путем возведения хэша сообщения в степень закрытого ключа d по модулю n:

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

Если вычисленный хэш совпадает с хэшом полученного сообщения, подпись считается корректной.

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

6.
Практический пример реализации RSA

Для демонстрации работоспособности алгоритма RSA в рамках лабораторного задания была разработана программная реализация в системе Maple, выполняющая полный цикл преобразования данных: от перевода текста в числовой формат до операций шифрования и расшифрования. В качестве примера взято имя «Тимур», которое в процессе работы алгоритма последовательно преобразуется в число, шифруется с использованием открытого ключа и восстанавливается с помощью закрытого.

Поскольку криптографические операции в RSA осуществляются над целыми числами, первый этап заключается в переводе текста в числовую последовательность. Для этого используется процедура, аналогичная описанной ранее str_to_num, которая формирует для каждого символа двухзначный ASCII-код и объединяет их в одно большое число. В результате имя «Тимур» принимает вид числа M = 113140109117114.

Далее выполняется генерация ключевой пары. С помощью функции nextprime выбираются два простых числа, например p=101 и q=211. Их произведение дает модуль n = 21311, после чего вычисляется значение функции Эйлера φ(n) = (p−1)(q−1) = 21000. Открытая экспонента e выбирается как число, взаимно простое с φ(n)φ(n); в данном случае e = 17. Закрытая экспонента d определяется как обратный элемент к e по модулю φ(n)φ(n) с использованием расширенного алгоритма Евклида, реализуемого функцией igcdex. В результате вычислений получается d=12353. Таким образом, открытый ключ составляет пару (e, n) = (17, 21311), а закрытый — (d, n) = (12353, 21311).

Процесс шифрования сводится к возведению числового представления текста M в степень открытого ключа e по модулю n:

Полученный шифротекст C = 9876 передается для расшифрования, которое выполняется аналогичной операцией, но с использованием закрытой экспоненты d:

Результат M′ в точности совпадает с исходным числовым представлением M. Финальное преобразование числа обратно в текст с помощью процедуры, обратной str_to_num, восстанавливает исходное имя «Тимур», что подтверждает корректность работы алгоритма.

Листинг 1 – Программная реализация RSA-шифрования в Maple

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

Заключение

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

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

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

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

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

В данной работе выполняется парсинг погоды для Ростова-на-Дону с сайта Gismeteo (рисунок 1) с использованием библиотеки Jsoup для извлечения температуры из HTML-структуры страницы. Для обеспечения корректной работы сетевых запросов применяется ExecutorService, организующий фоновый поток, а обновление пользовательского интерфейса выполняется через Handler. Подобные скрипты востребованы при создании мобильных информеров, особенно для регионов, данные по которым недоступны через официальные API. Стабильность библиотеки Jsoup и встроенных средств многопоточности Android обеспечивает надежность работы приложения в условиях ограниченных ресурсов мобильного устройства.

Рисунок 1. Сайт погоды

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

• добавляем разрешение на доступ к интернету в файл AndroidManifest.xml;
• подключаем зависимость библиотеки Jsoup в файле build.gradle модуля приложения;
• создаём интерфейс с кнопкой для запуска парсинга и текстовым полем для отображения результата;
• инициализируем ExecutorService для выполнения сетевого запроса в фоновом потоке;
• выполняем подключение к сайту Gismeteo с указанием URL нужного города;
• находим элемент с классом “weather-value” и извлекаем из него значение температуры;
• обрабатываем возможные исключения при сетевом подключении;
• используем Handler для обновления TextView с полученными данными в UI-потоке.

Ниже приведен фрагмент кода основной логики приложения:

private View.OnClickListener myOnClick = new View.OnClickListener() {

public void onClick(View v) {

ExecutorService executor = Executors.newSingleThreadExecutor();

Handler handler = new Handler(Looper.getMainLooper());

executor.execute(new Runnable() {

String title;

@Override

public void run() {

//Background work here

try {

Document doc = Jsoup.connect(“https://www.gismeteo.ru/weather-rostov-na-donu-5110/”).get();

Elements ele = doc.select(“div[class=weather-value]“);

Element pogoda = ele.select(“temperature-value”).first();

title = pogoda.val();

} catch (IOException e) {

// e.printStackTrace();

title = “error”;

}

handler.post(new Runnable() {

@Override

public void run() {

//UI Thread work here

myTextView.setText(“Ростов-на-Дону: ” + title);

}

});

}

});

}

};

В представленном коде при нажатии на кнопку создается однопоточный ExecutorService, который выполняет сетевой запрос в фоне. Jsoup подключается к странице города, находит элемент с классом “weather-value” и извлекает из вложенного тега “temperature-value” значение температуры. В случае ошибки (отсутствие интернета, изменение структуры сайта) в переменную title записывается “error”. После завершения работы Handler обновляет TextView в главном потоке.

Рисунок 2. Интерфейс разработанного приложения с результатом парсинга

Заключение 

Разработанное Android-приложение успешно выполняет парсинг данных о погоде с сайта Gismeteo и отображает температуру для указанного города. Использование библиотеки Jsoup в сочетании с ExecutorService и Handler обеспечивает стабильную работу приложения без блокировки пользовательского интерфейса. Предложенный подход может быть адаптирован для парсинга любых данных с веб-страниц, что расширяет возможности мобильных приложений при отсутствии официальных API. Важно помнить об этических аспектах и соблюдении правил robots.txt при разработке подобных решений. Дальнейшее развитие приложения может включать добавление списка городов, автоматическое обновление данных и визуализацию погодных условий.

Когда перед разработчиком встает задача отобразить трехмерные объекты в браузере, первое, что приходит на ум — использовать WebGL. Однако писать на чистом WebGL — занятие не для слабонервных. Слишком много деталей приходится контролировать вручную: буферы вершин, шейдеры, матрицы преобразований. Именно поэтому практически любой проект в этой области начинается с подключения библиотеки Three.js. Она берет на себя всю низкоуровневую работу и позволяет сосредоточиться на самом главном — на том, что именно мы хотим показать пользователю.

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

Первым делом подготавливается базовая HTML-структура. Здесь важно правильно организовать импорт модулей. Three.js использует модульную систему, поэтому на странице объявляется import map, который указывает, откуда загружать библиотеку и ее дополнения. Сам код пишется внутри тега script type=”module”, что позволяет использовать синтаксис импорта и экспорта прямо в браузере.

<!DOCTYPE html>

<html lang=”ru”>

<head>

    <meta charset=”UTF-8″>

    <meta name=”viewport” content=”width=device-width, initial-scale=1.0″>

    <title>9 фигур + чайник на плоскости</title>

    <style>

        body { margin: 0; overflow: hidden; background-color: #111; }

    </style>

</head>

<body>

    <script type=”importmap”>

        {

            “imports”: {

                “three”: “https://unpkg.com/three@0.128.0/build/three.module.js”,

                “three/addons/”: “https://unpkg.com/three@0.128.0/examples/jsm/”

            }

        }

    </script>

    <script type=”module”>

        // весь код приложения

    </script>

</body>

</html>

Листинг 1 – Базовая структура HTML-документа и импорт зависимостей

Создание любой 3D-сцены в Three.js начинается с трех обязательных компонентов: сцены, камеры и рендерера. Сцена — это контейнер, в который помещаются все объекты, источники света и вспомогательные элементы. Камера определяет точку обзора — в данном случае выбрана перспективная камера с углом обзора 45 градусов, что приближает восприятие к тому, как человеческий глаз видит реальные объекты. Рендерер отвечает за отрисовку: он создает canvas-элемент и выводит на него изображение. Чтобы сцена не выглядела плоской, добавляется освещение. Два направленных источника света располагаются под разными углами, создавая четкие светотеневые переходы, а мягкий фоновый свет предотвращает появление слишком темных участков.

import * as THREE from ‘three’;

import { OrbitControls } from ‘three/addons/controls/OrbitControls.js’;

import { TeapotGeometry } from ‘three/addons/geometries/TeapotGeometry.js’;

const scene = new THREE.Scene();

scene.background = new THREE.Color(0xeeeeee);

const camera = new THREE.PerspectiveCamera(45, window.innerWidth / window.innerHeight, 0.1, 1000);

camera.position.set(6, 4, 9);

camera.lookAt(0, 1, 0);

const renderer = new THREE.WebGLRenderer({ antialias: true });

renderer.setSize(window.innerWidth, window.innerHeight);

renderer.shadowMap.enabled = false;

document.body.appendChild(renderer.domElement);

const dirLight1 = new THREE.DirectionalLight(0xffffff, 1.0);

dirLight1.position.set(2, 5, 3);

scene.add(dirLight1);

const dirLight2 = new THREE.DirectionalLight(0xffffff, 0.7);

dirLight2.position.set(-3, 4, 4);

scene.add(dirLight2);

const ambientLight = new THREE.AmbientLight(0×404060);

scene.add(ambientLight);

Листинг 2 – Инициализация сцены, камеры, рендерера и освещения

Теперь, когда сцена готова к работе, необходимо создать опорную плоскость, на которой будут стоять фигуры. Для этого используется PlaneGeometry — плоский прямоугольник, который разворачивается горизонтально. Поверх него накладывается GridHelper — сетка, помогающая визуально оценить расположение объектов в пространстве. Эти два элемента создают необходимый контекст: фигуры не висят в пустоте, а имеют четкую привязку к поверхности.

Для удобства добавления фигур написана небольшая функция-обертка addFigure. Она принимает геометрию, цвет и координаты положения, создает материал с заданными свойствами и помещает объект на сцену. Такой подход избавляет от повторяющегося кода и делает добавление новых фигур простым и наглядным.

const planeGeometry = new THREE.PlaneGeometry(14, 14);

const planeMaterial = new THREE.MeshStandardMaterial({ color: 0xcccccc, side: THREE.DoubleSide });

const plane = new THREE.Mesh(planeGeometry, planeMaterial);

plane.rotation.x = Math.PI / 2;

plane.position.y = 0;

scene.add(plane);

const gridHelper = new THREE.GridHelper(14, 20, 0×666666, 0×333333);

gridHelper.position.y = 0.01;

scene.add(gridHelper);

function addFigure(geometry, color, position) {

    const material = new THREE.MeshStandardMaterial({ color: color, roughness: 0.5, metalness: 0.0 });

    const mesh = new THREE.Mesh(geometry, material);

    mesh.position.set(position[0], position[1], position[2]);

    scene.add(mesh);

}

addFigure(new THREE.BoxGeometry(1, 1, 1), 0x3366ff, [-3.5, 0.5, -3.0]);

addFigure(new THREE.ConeGeometry(0.7, 1.4, 4), 0xff9933, [-1.0, 0.7, -3.0]);

addFigure(new THREE.SphereGeometry(0.8, 32, 16), 0xaa66ff, [2, 0.8, -3.0]);

addFigure(new THREE.CylinderGeometry(0.7, 0.7, 1.4, 32), 0xf5deb3, [-2.6, 0.7, -0.5]);

addFigure(new THREE.ConeGeometry(0.8, 1.5, 32), 0x33cc33, [0.9, 0.75, -0.5]);

addFigure(new THREE.CylinderGeometry(0.7, 0.7, 1.2, 3), 0x99ff99, [-3.5, 0.6, 1.5]);

addFigure(new THREE.BoxGeometry(1.2, 0.8, 0.8), 0xff4444, [-1, 0.4, 1.8]);

addFigure(new THREE.CylinderGeometry(0.8, 0.8, 1.2, 6), 0xffdd44, [2, 0.6, 1.5]);

const teapotGeo = new TeapotGeometry(0.9, 12, true, true, true, true);

const teapotMat = new THREE.MeshStandardMaterial({ color: 0×222222, roughness: 0.3, metalness: 0.2 });

const teapot = new THREE.Mesh(teapotGeo, teapotMat);

teapot.position.set(-1.0, 1, 4);

teapot.rotation.set(0, 0.2, 0);

scene.add(teapot);

const controls = new OrbitControls(camera, renderer.domElement);

controls.enableDamping = false;

controls.autoRotate = false;

controls.target.set(0, 0.8, 0);

function animate() {

    requestAnimationFrame(animate);

    controls.update();

    renderer.render(scene, camera);

}

animate();

window.addEventListener(‘resize’, () => {

    camera.aspect = window.innerWidth / window.innerHeight;

    camera.updateProjectionMatrix();

    renderer.setSize(window.innerWidth, window.innerHeight);

});

Листинг 3 – Создание опорной плоскости, сетки, геометрических фигур и чайника

Восемь основных фигур размещаются в два ряда, чтобы их можно было легко рассмотреть как по отдельности, так и в сравнении. Куб, сфера, цилиндр и конус — это стандартные геометрические примитивы, которые в Three.js создаются соответствующими классами. Интереснее обстоит дело с призмами. Треугольная и шестиугольная призмы реализованы с помощью цилиндра, у которого количество сегментов уменьшено до трех и шести соответственно. Этот прием работает благодаря тому, что цилиндр с малым числом сегментов превращается в многогранник, а сглаживание граней делает его визуально похожим на призму.

Отдельного внимания заслуживает чайник. Это не просто случайная фигура, а объект с историей. Чайник Юты был создан в 1975 году Мартином Ньюэллом как тестовая модель для систем трехмерной графики. Его форма содержит криволинейные поверхности, отверстия и сложные изгибы, что делает его отличным индикатором качества рендеринга. В Three.js чайник доступен через TeapotGeometry из дополнений, и его подключение занимает всего несколько строк кода.

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

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

Производительность приложения остается высокой благодаря нескольким решениям. Отключение теней (shadowMap.enabled = false) существенно снижает нагрузку на видеокарту, а разумный выбор количества сегментов у сферы (32×16) дает хорошее качество без избыточной геометрической сложности. Конечно, для более реалистичной сцены тени были бы полезны, но в учебно-демонстрационных задачах они часто оказываются излишними.

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

Рисунок 1. Финальный вид сцены с возможностью вращения камеры

Заключение 

В результате выполнения работы разработано веб-приложение для визуализации стереометрических фигур с использованием WebGL и библиотеки Three.js. Созданная 3D-сцена включает девять геометрических объектов, реализованных с помощью стандартных примитивов библиотеки. Обеспечена интерактивность за счет подключения контроллера камеры, позволяющего пользователю вращать и масштабировать сцену. Разработанное приложение может быть использовано в образовательных целях для изучения основ стереометрии и демонстрирует возможности современных веб-технологий в области трехмерного моделирования.