Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

Написать программу для удаления вершин. Пользователь загружает модель, выбирает номера…

  1. User

    Написать программу для удаления вершин. Пользователь загружает модель, выбирает номера вершин, которые следует удалить и получает результат. Сложность в том, что при удалении вершины полигоны, к которым она прикреплена, следует также удалить. Иначе модель можно считать некорректной. Если получится взять ObjWriter у товарищей, будет полезно загрузить модель в программу, обработать и выгрузить, чтобы посмотреть на неё в стороннем софте. 3 Трёхмерное пространство Структура трёхмерных объектов С этой главы начинаем погружение в трёхмерную графику. Основной в нашем курсе, как и везде, будет графика полигональная, т.е. такая, где объекты описываются набором полигонов. Модель — это, в первую очередь, полигональная сетка. Поэтому на английском языке часто используется термин mesh. Все полигоны — многоугольники (чаще треугольники и четырёхугольники, но иногда встречается и большее количество вершин). Рис. 17: Модель и её полигональная сетка 34 Очевидно, что чем больше полигонов используется, тем более сложную геометрию они могут описать. Низкополигональные (low poly) модели применяются там, где не хватает вычислительных ресурсов, или выбран определённый угловатый стиль визуализации. А для достижения реализма, напротив, нужны высокополигональные (high poly) модели. Но и тут остро стоит вопрос, какой уровень детализации сетки нужно использовать, чтобы зритель или игрок восхищался картинкой, но приложение могло отрисовывать объекты с необходимой скоростью. О полигональной сетке можно думать как о графе. Поэтому, кстати, многие алгоритмы на них нашли своё применение и в трёхмерной графике. Геометрия задаётся вершинами, где каждая описывается тремя координатами v(x, y, z). Между некоторыми из вершин проводятся так называемые рёбра. А между рёбрами, лежащими в одной плоскости, образуются многоугольники — полигоны. Перечисленных объектов хватает, чтобы задать фигуру в трёхмерном пространстве. Рис. 18: Трёхмерная модель и её текстура Но, конечно, одной геометрии недостаточно. Объект будет лучше восприниматься, если на каждом из полигонов будет какое-то изображение. Например, кубик можно будет превратить в модельку ящика для компьютерной игры, если каждая из его граней будет как-то раскрашена. За это отвечает текстура — изображение (jpg, png и т.д.), которое обычно хранится где-то рядом с основным файлом модели. В процессе рендеринга, т.е. во время отрисовки объекта эта картинка накладывается на объект, как бы его оборачивая. Дальше по курсу будет разобран механизм такой операции. Но пока скажем, что для этого необходимы текстурные вершины, которые задаются не в трёхмерном пространстве, а на плоскости текстуры — vt(u, v). Из-за часто используемых обозначений u и v их также могут называть uv-координатами, а само изображение — UV Map. Привязка текстурных координат к модели выполняется не во время задания её трехмерных вершин, а при создании полигона. Вершина может участвовать в разных гранях объекта, где каждый из полигонов окрашен по-своему. Поэтому одной вершине могут соответствовать несколько текстурных координат. Часто стараются делать текстуру так, чтобы близкие полигоны и на ней располагались рядом. Так по ней можно будет понять, к какой модели она относится. Но из-за того, что мы разворачиваем поверхность трёхмерного объекта на плоскость, 35 пропорции на текстуре вовсе не обязаны совпадать с реальными, как это, например, происходит и при переходе от глобуса к карте. Описываемый эффект можно проследить, например, на рисунке 18. Кстати, эта модель хранится в основном репозитории курса и может использоваться вами для тестов. Наконец, последняя характеристика модели, которая потребуется нам позже — нормали. Они используются для тех ситуаций, где нужно следить, под каким углом на полигон попал луч. Пожалуй, самая распространённая из них — это задача расчёта освещения на сцене. Вот только в модели обычно хранят не нормали к полигонам, а нормали к вершинам — vn(x, y, z). Сейчас для вас это может показаться абсурдным, ведь у трёхмерной точки не может быть однозначной нормали. Но дальше по курсу станет понятно, для чего выполняется этот трюк. Рис. 19: Нормали вершин Для того, чтобы перейти от нормалей вершин к нормалям полигонов, надо для каждого полигона взять среднее арифметическое всех нормалей вершин, что его составляют. Верно и обратное. Чтобы вычислить нормаль вершины, нужно сложить нормали полигонов, в которых она участвует, а затем поделить на их количество. При этом длины векторов нормалей обычно никак не используют, важно лишь их направление. Поэтому, чтобы с ними было удобнее работать, вектора обычно нормализуют. Те, кто уже работал с трёхмерными моделями, наверное, слышали про карты нормалей. Благодаря вот таким заданным в вершинах векторам, они и создаются. 36 Задача триангуляции Полигоны могут быть треугольниками, четырёхугольниками и так далее. Строго говоря, нет никакого ограничения на количество вершин, хотя на практике стараются работать с простыми объектами. Но есть алгоритмы, которые предполагают, что все полигоны модели — треугольники. Так, например, при написании рендера в финальном задании курса вам потребуется вызывать метод их отрисовки, который реализует кто-то из студентов во второй задаче. При этом нет смысла разрабатывать алгоритм для произвольного многоугольника, т.к. любой из них можно разбить на треугольники. Чуть позже станут понятны и другие причины работать только с тремя вершинами. Триангуляцией в нашей предметной области называется процедура превращения трёхмерной модели в такую, где все полигоны являются треугольниками. Часто в программе хранится как оригинальная модель, так и её версия после триангуляции. Это добавляет гибкость: позволяет работать как с оригинальной сеткой, так и быстро переходить к вызову определённых методов. Разумеется, вершины, текстурные вершины и нормали никак не изменяются при триангуляции (за исключением некоторых алгоритмов). В простых реализациях единственное, что затрагивается — это полигоны. Существует большое количество подходов для решения данной задачи. Часто стараются избегать слишком острых или тупых углов. Например, можете самостоятельно разобрать и реализовать триангуляцию Делоне. С применением таких алгоритмов можно получить визуально приятную полигональную сетку. Однако в наших задачах форма полигонов после триангуляции не будет важна, мы их даже не увидим. Важно только, чтобы они были треугольниками. Поэтому для реализации предлагается самый примитивный алгоритм. Возьмём произвольный n-угольник с индексами вершин от 0 до n−1. Соединим нулевую вершину со второй, затем с третьей и так далее до n − 2. Таким образом получим n − 2 треугольника. Рис. 20: Триангуляция полигона 37 Расчёт нормалей Нормали как и текстурные вершины могут быть в файле модели не заданы. Более того, возможна ситуация, что они заданы неверно, а это способно привести к некорректной работе алгоритмов. Поэтому в общем случае правилом хорошего тона является самостоятельное вычисление нормалей при загрузке модели в программу. Отталкиваясь от геометрии объекта, проще всего вычислить нормали к полигонам. Как обсуждалось выше, от них можно легко переходить к нормалям вершин и обратно. Уже в который раз при решении задачи поможет векторное произведение (см. “Приложение 2. Операции над векторами”). Для удобства предположим, что полигон является треугольником, хотя здесь это необязательно. Попарно соединив вершины, получим два вектора, лежащих в нужной плоскости. Векторное произведение даст результат, перпендикулярный им. Рис. 21: Вычисление нормали к полигону Все три вектора составляют правую тройку, однозначно определяя направление. Но чтобы не оказалось так, что нормали бьют внутрь модели, а не наружу, важно учитывать порядок обхода. К счастью, почти любая серьёзная программа подстраивается под общепринятые стандарты, когда прикрепляет вершины к полигонам. Поэтому, если алгоритм заработает правильно для одной модели, для других он, скорее всего, тоже будет пригоден. И важно не забывать всегда нормализовать результат. Также лучше сразу переходить к нормалям вершин. Именно они будут использоваться нами далее. 38 Некоторые важные правила разработки Задачи в рамках курса постепенно усложняются и, в связи с этим, хочется обсудить некоторые важные принципы разработки. Многократно проверено, что стремление к их соблюдению значительно экономит время, уменьшает вероятность ошибок и делает конечный продукт лучше. Мы попытались сформулировать основные идеи, опираясь на свой и чужой опыт. Настоящий код люди пишут аж с середины XX века, поэтому и попыток собрать в одном месте подобные правила было уже очень много. И если начнете их разбирать, быстро увидите, что все они говорят примерно об одном и том же. Стоит обратить внимание, что подобные принципы носят фундаментальный характер. Для вас лично или в вашем коллективе, конечно, могут действовать свои уникальные договоренности, начиная от стиля кода и заканчивая организацией работы. Но то, что мы обсудим ниже, следует пытаться соблюдать всегда, за исключением тех случаев, когда внешние обстоятельства вносят серьезные коррективы.

    1. Код следует разбивать на модули, обеспечивая слабую связность их друг с другом. Под словом “модуль” здесь и ниже будем понимать любую единицу кода: методы, классы, библиотеки, приложения и так далее. С тем, что большой сегмент желательно разбить на несколько поменьше, вряд ли кто-то будет серьёзно спорить, ведь этому учат с первых курсов программирования. Такое разбиение улучшает читаемость и даёт большую гибкость. Но, нарезая программу на куски, неопытные разработчики часто забывают обеспечивать слабую связность, то есть получают ситуацию, когда модули друг от друга сильно зависят. Это приводит к тому, что от такого разбиения нет почти никакого толка. Собирая, изменяя или вызывая одну часть кода, мы обязаны тоже самое делать и с другой. А ведь гораздо проще вести разработку, когда модули независимы в рамках своей деятельности. Да, конечно, более высокоуровневые обязаны вызывать тех, кто уровнем пониже. Но, за исключением некоторых шаблонов, следует при этом стремиться к древовидной структуре, а не графу. Некоторые языки программирования даже не позволяют собирать код с циклическими зависимостями. Пожалуй, одним из самых ярких выражений данного принципа является микросервисная архитектура. Она была создана для крупных сервисных приложений, где особенно важно быстро и незаметно изменять, пересобирать, перезагружать отдельные компоненты системы. Ощутимый прирост в скорости и надежности наблюдается здесь, если делать модули маленькими и незави39 симыми. При этом те же идеи применимы и для десктопных, мобильных и прочих приложений. P.s. Вообще, термин “связность” часто встречается в теории программирования, но надо уточнять, что вы имеете в виду. Бывает, что под ним понимают разные вещи. Например, в терминологии шаблонов “GRASP” связность — это мера взаимодействия компонентов внутри модуля, а то, о чём писалось выше, называется зацеплением. Поэтому в таких терминах стоит стремиться к сильной связности и слабому зацеплению.
    2. Модули должны принимать и выдавать только то, с чем они работают. Этот пункт тесно связан с предыдущим, но настолько важен, что его следует обсудить отдельно. Хоть мы и стремимся к независимости отдельных участков программы, они должны что-то друг о друге знать. Иначе из них не выйдет составить цельное приложение. Но тут возникает вопрос: а какую конкретно информацию они имеют право использовать? Правилом хорошего тона является создание такой архитектуры, где модули принимают только необходимое для их работы. Например, если функция взаимодействует только с некоторыми полями класса, не надо передавать туда весь объект. Так ваш код будет тесно связан именно с этим классом, вызвать его в другом месте (например, в тестах, о которых мы поговорим позже) вы не сможете. В случае серьёзного изменения класса придётся переделывать и функцию. И, наверное, самое опасное — легко можно допустить ошибку, сделав что-то с теми данными, которые вы не должны были трогать. Одна из формулировок данного принципа носит название закона Деметры (LoD). Советуем дополнительно разобрать его самостоятельно. В этом законе, например, постулируется, что если у объекта A есть объект B, а у объекта B — объект C, то A не может каким-то образом дать прямой доступ к C. Так, если класс A хранит B, а у B есть Method(), то строка a.b.Method() нарушит закон. Правильным решением здесь будет вызов a.Method(), внутри которого происходит вызов b.Method(). Разумеется, такой подход влечёт за собой создание большого количества обёрток и делегатов. Чтобы как-то бороться с этим, применяют шаблон внедрения зависимости. В такой парадигме класс вместо того, чтобы хранить какойто сервис в качестве поля, даёт возможность передать его себе в методы как аргумент. Доступ к этому сервису больше не оказывается закрыт за кучей прослоек. Так еще и передавать в класс можно разные сервисы, заставляя его работать по-разному. Такой приём очень полюбили при написании тестов. 40
    3. Ветвление — необходимое зло. Вот такая картина не может вызывать ничего кроме ужаса: 1 if condition1 : 2 if condition2 : 3 if condition3 : 4 if condition4 : 5 if condition5 : И это здесь ещё опущены фигурные скобки. Тем не менее, надо признать, что в некоторых ситуациях без условных операторов не обойтись. Первое, что хочется напомнить — так это то, что всегда есть возможность записать логическое выражение в другом виде. Даже если не получилось как-то упростить, можно от кода следующего вида 1 if condition : 2 do something () перейти к такому, где условный оператор будет отвечать за выход из блока и не позволит выполнить код ниже: 1 if NOT condition : 2 return , break , continue , ... 3 do something () Это не даст сделать ветвление слишком объёмным. Но ещё лучше будет по возможности избегать любых if-ов. Например, если есть класс, который в разных ситуациях ведёт себя по-разному, не стоит городить внутри него условные операторы, переменные для типов его поведения, поля, которые будут задействованы крайне редко. Лучше описать базовый класс (абстрактный или интерфейс), а затем наследовать от него и переопределять частные случаи. Такой полиморфизм всегда лучше, чем пачка условных операторов. У вас будет чистый, разнесённый по блокам, читаемый код. Изменяя его, добавляя или удаляя что-то, вам не придётся лезть в один и тот же базовый класс. Вероятность ошибок значительно уменьшится. Более того, в хорошо оптимизированном коде тоже стараются избегать любых условных операторов из-за того, что методы с ними работают медленнее. Может быть незаметно относительно более крупных участков кода, но будьте готовы к тому, что if-ы могут вас тормозить. Особенно это актуально для параллельного программирования. 41
    4. ООП и шаблоны — важный элемент программирования. Но с ними не стоит перебарщивать. Знать принципы ООП, следить за модификаторами доступа, понимать шаблоны (стандартные решения часто встречающихся задач) крайне необходимо. Как и в других примерах, это позволяет экономить время, писать читаемый расширяемый код, уменьшать вероятность ошибок. Но хочется акцентировать внимание на том, что почти всегда разработка — это поиск золотой середины между идеальным образом и доступными ресурсами. При проектировании инженерного сооружения не всегда ведут расчёты на случай ядерной войны, вместо этого описывают конструкцию и материалы с учётом необходимых нагрузок. Это позволяет сэкономить и уложиться в сроки. Так и при написании программы, если для решения задачи, на которую надо было потратить день, вы будете целую неделю выстраивать себе архитектуру “на будущее”, то это будущее для вашего кода может никогда и не наступить. В таких ситуациях лучше показать что-то в срок, но с умеренным потенциалом для расширения, а после при необходимости переписать некоторые моменты.
    5. “Сделай — Сделай правильно — Сделай быстро”. Вообще, при решении любой серьёзной задачи редко что-то делается сразу на чистовик. Почти всегда нужен черновой вариант, чтобы понять, а как оно вообще будет выглядеть. При написании программы также советуем не изобретать сразу идеальный инструмент, а сформировать в голове его прототип и начать работу. Может так статься, что ваши задумки окажутся бесполезными, а без эмпирической проверки любые мысленные эксперименты непригодны на практике. Поэтому начать работу нужно со “сделай”. Пусть пока с ошибками, плохой архитектурой, медленной работой, но какой-то результат уже должен быть. Только получив прототип и проверив часть идей, можно переходить к “сделай правильно”. На этом этапе имеет смысл улучшать архитектуру, вычищать баги. Необходимо стремиться к такому состоянию кода, чтобы им можно было гордиться. Чтобы каждая функция или класс могли быть вашей визитной карточкой. Конечно, и на первых двух этапах вы подходили к программированию разумно и не тормозили программу умышленно. Но только после написания почти идеального варианта можно переходить к “сделай быстро”. Серьёзная преждевременная оптимизация замедлит разработку и ухудшит финальный вариант. Проводить её нужно, имея корректную рабочую программу, хотя бы потому, что так профилирование покажет реальные узкие (замедляющие приложение) места, а не те проблемы, что вы себе вообразили. И стоит быть готовым к то42 му, что читаемость кода при его оптимизации снизится, в том числе поэтому желательно сперва грамотно выстроить архитектуру. Описанная триада сама по себе является этапом разработки. При написании крупного модуля её структура может слегка размываться. Например, часть модуля уже может быть в конечном состоянии, другая может работать правильно и ждать своей оптимизации, а третья — создаваться в данный момент в черновом варианте.
    6. Любая работа — это движение маленькими шажками. Наверное, уже очевидно, что разработка состоит из последовательных итераций. Это могут быть этапы, описанные в предыдущем пункте, или более глобальные компоненты вроде постоянно сменяющих друг друга написания кода и его тестирования. При этом много раз проверено, что чем меньшими шагами вы идёте, тем быстрее движетесь. Большие по объёму этапы сложно держать в голове, на них легко допустить ошибки и застрять. И психологически они тоже изматывают. Но особенно ярко это раскрывается при работе в команде. Если возьмёте себе крупную задачу и будете работать над ней в отдельной ветке до тех пор, пока не закончите, вы рискуете потерять связь с коллективом. Но даже если будете следить за обновлениями, за годы вашей работы репозиторий с кодом коллег может измениться до неузнаваемости. И у вас после уйдут месяцы на то, чтобы вставить свой модуль к другим. Дабы избегать таких ситуаций, желательно разбивать задачу на маленькие сегменты, часто вливать друг в друга ветки. Если познакомитесь с парадигмами организации коммандной работы вроде git flow, trunk-based development и др., то заметите, что везде обсуждается необходимость делать коммиты как можно меньше. Такие небольшие структурные единицы проще воспринимать и поддерживать.
    7. Тестирование должно быть не прихотью, а обязанностью. Только тестирование кода может доказать его работоспособность. Оно должно выполнятся не по желанию программиста, а по строгой необходимости. Конечно, на крупных проектах нанимают отдельных специалистов — тестировщиков, цель которых создавать и запускать тесты. Но хороший разработчик должен сам знать, как протестировать его программу. Существует несколько подходов, позволяющих проводить тестирование быстро (чуть ли не по нажатию одной кнопки) и качественно, с учетом специфики кода. В следующем параграфе подробнее распишем некоторые ключевые идеи. 43 О тестах и их важности Итак, вы добавили что-то в программу. Как убедиться, что код рабочий? Конечно, можно (и нужно) запустить приложение и сделать ряд действий, чтобы вызвать необходимый модуль. Но может быть так, что при одних входных данных он выдаёт корректный результат, а на других программа падает. Хотелось бы иметь механизм, который позволяет быстро проверить все случаи. Более того, когда правки вносятся только в небольшую часть приложения, не хочется каждый раз для отладки пересобирать, запускать и тестировать всю программу целиком. Это очень сильно замедлит любую разработку. Обе эти проблемы решает написание так называемых юнит-тестов. Их цель — проверить работоспособность конкретного модуля (поэтому часто также говорят о модульном тестировании). Действительно, при проектировании ракеты не производятся же запуски каждый раз, когда нужно проверить двигатель, обшивку или корпус. Вместо этого все эти компоненты сперва тестируются отдельно. Так и нам в целях экономии ресурсов в первую очередь следует проверять те небольшие модули, что мы создаём. Общая структура юнит-теста выглядит так: 1 testFoo () { 2 values = ... 3 result = foo ( values ) 4 expected = ... 5 result == expected ? 6 } При тестировании некого модуля указываем входные параметры (values) и ожидаемое на выходе значение (expected). Результат работы модуля сравниваем с тем, что хотим получить. Если они совпадают, тест прошёл. Если нет — значит, мы нашли ошибку в коде. Нет необходимости писать свои обёртки для подобных конструкций. Любой уважающий себя язык программирования имеет несколько популярных фреймворков для юнит-тестирования, а среды разработки наглядно отображают результат работы. В вспомогательном проекте к этой главе есть небольшой пример такого использования. Обсудим еще некоторые важные достоинства юнит-тестов. Во-первых, для того, чтобы была возможность протестировать отдельные части программы, да ещё и с разными входными условиями, приложение придётся сразу писать с грамотной архитектурой. Таким образом, тесты дополнительно заставляют код быть читаемым, расширяемым, универсальным. Во-вторых, юнит-тесты можно рассматривать как приложение к документации. Их изучение поможет постороннему человеку лучше понять, как должен работать модуль. 44 В-третьих, сама постановка задачи придумывания тестов заставляет программиста размышлять над тем, какие же входные данные могут к нему придти. А уже одно только это уменьшает вероятность ошибок. Наконец, в-четвертых, хотя это ещё не все преимущества, тесты упрощают жизнь при изменении модуля, рефакторинге. Иногда приходится вернуться к коду спустя годы и что-то в нём подправить. В таких ситуациях особенно важно убедиться, что вы ничего не сломали. Если действовать аккуратно и после каждой небольшой правки запускать тесты, ошибка в старом поведении не должна будет появиться. То, что модули работают корректно по отдельности, ещё не значит, что и приложение будет без ошибок. Отдельные части программы вполне могут вызываться неправильно или конфликтовать друг с другом. Для того, чтобы отслеживать такие ситуации, пишутся так называемые интеграционные тесты. Их цель — убедиться, что модули работают вместе правильно. Отдельный вопрос — а что вообще должно быть в тестах? В идеальном случае покрытие кода ими должно быть стопроцентным. Лучше сделать плохой тест, чем никакой вообще. Проверять при этом следует как типовые случаи (те с которыми будет работать пользователь), так и крайние варианты: нулевые аргументы, выходы за допустимые диапазоны значений и т.д. Когда писать тесты — это уже зависит от того, как вам удобнее. Некоторые покрывают ими код в самом конце, когда довели его до идеального состояния. Ктото старается писать их в процессе, тем самым ускоряя чистку от ошибок. Есть также парадигма разработки через тестирование — это когда тесты создаются в самом начале, а уже после под них выстраивается модуль. Тут у каждого из подходов есть свои достоинства и недостатки. 45 Чтение Obj-формата Теперь, когда вы знакомы со структурой трёхмерной полигональной модели, настало время обсудить, как они хранятся на диске. Существует большое количество форматов для самых разных задач (FBX, STL и так далее). В рамках данного курса мы будем использовать один из самых простых — формат OBJ. Это текстовые файлы, то есть вы можете понять структуру модели, открыв их в любом текстовом редакторе. В данном формате каждая из строк файла добавляет в модель какой-то новый компонент. Например, так могут выглядеть строки, описывающие вершины: 1 v 1.5 2.8 0.1 2 v 0.4 1.2 4.0 3 v 2.2 -0.4 -0.3 4 ... Сначала идёт символ v, обозначающий vertex, то есть вершину. А затем через пробел указываются три её координаты. Текстурные вершины записываются следующим образом: 1 vt 0.3 0.7 2 vt 0.5 0.25 3 ... Тут в начале строки стоит vt, а координат будет всего две, потому что задаётся точка на плоскости. Наконец, нормали к вершинам будут задаваться строками следующего вида: 1 vn 0.66 0.66 -0.33 Напомним, что в модели могут быть не указаны текстурные координаты и нормали. Также в файле нет какого-то строго порядка, что за чем задавать. Вполне могут быть подобные ситуации: 1 v ... 2 vt ... 3 ... 4 vn ... 5 v ... 6 ... 7 vt ... 8 vt ... Но по мере того, как встречаются элементы одного и того же типа, им присваиваются номера, начиная с единицы. Первый раз встретилась строка с v — это будет первая вершина. Далее пойдут вторая, третья и так далее. Аналогично своя собственная нумерация будет у текстурных координат и нормалей. 46 Эти индексы могут использоваться при описании полигонов. В отличие от объектов выше, их возможно задать разными способами. Например, эта строка укажет, что в модели есть полигон, состоящий из первой, третьей и пятой вершин: 1 f 1 3 5 Разумеется, их количество может быть произвольным (но не меньше трёх): 1 f 1 3 5 7 2 f 10 20 12 22 40 42 Буква f обозначает face — так тоже иногда называют полигоны. Если у модели есть текстура, то её с помощью текстурных вершин следует привязать к объекту. Напомним, что делается это в момент описания полигонов. Строка в таком случае должна выглядеть следующим образом: 1 f 1/2 3/4 5/6 В данном примере полигон состоит из трёх вершин (указаны их индексы в файле). И к этим точкам треугольника прикреплены вторая, четвертая и шестая текстурные координаты соответственно. Если в файле хранятся нормали, можно аналогично через ещё одну косую черту привязать их к полигону по индексам: 1 f 1/2/1 3/4/5 5/6/10 А если есть вершины и нормали, но не указаны текстурные координаты, то строка примет следующий вид: 1 f 1//1 3//5 5//10 В целом разобранных случаев достаточно для выполнения заданий курса. Конечно, структура модели несколько сложнее, а в Obj-файле можно встретить и другие строки. Но для наших целей они не понадобятся. Тем не менее всё же советуем разобрать этот формат чуть более подробно. Он даст лучшее понимание тех объектов, с которыми мы будем работать: https://en.wikipedia.org/wiki/Wavefront_.obj_file В основном репозитории курса хранятся модели для тестов. Вы можете как использовать их, так и скачать или сделать свои собственные: https://github.com/kv1tr4vn/CGVSU/tree/main/3DModels ;A< 47 Посмотрим, как можно загрузить модель в программу. Для этих целей был написан вспомогательный проект: https://github.com/kv1tr4vn/CGVSU/tree/main/Task3/ObjReaderInitial Класс модели в нём содержит следующие поля: 1 public ArrayList < Vector3f > vertices ; 2 public ArrayList < Vector2f > textureVertices ; 3 public ArrayList < Vector3f > normals ; 4 public ArrayList < Polygon > polygons ; Как и обсуждалось выше, модель — это набор массивов из четырёх элементов. Вершины и нормали задаются трёхмерными векторами. Текстурные координаты — двумерными. Полигон — это отдельный класс, задаваемый следующими полями: 1 private ArrayList < Integer > vertexIndices ; 2 private ArrayList < Integer > textureVertexIndices ; 3 private ArrayList < Integer > normalIndices ; Здесь указываются индексы вершин, текстурных координат и нормалей в том порядке, в котором они привязывались в Obj-файле. Только для удобства при чтении из них вычитается единица, чтобы в программе нумерация шла с нуля. В третьей и четвертой задачах вы имеете право отталкиваться от этого кода при работе с моделями. Чтение формата реализовано в классе ObjReader. Сейчас не будем подробно расписывать его структуру. При разборе кода обратите внимание на следующие детали:
    8. Основной метод чтения файла разбит на группу вспомогательных функций, позволяющих не только улучшить читаемость кода, но и подготовить его для удобного тестирования.
    9. Заложена основа для обработки ошибок. В Obj-файле модель может быть задана некорректно. Например, у полигона могут быть указаны только две вершины. Чтобы программа не зависала и не падала, важно учитывать, что пользователь может давать ей ошибочные данные. Хорошее приложение — то, которое способно всё это предусмотреть.
    10. Начата работа над тестированием модуля. Отдельный класс ObjReaderT est покрывает проверками часть методов основного кода. Используется готовый фреймворк, а среда разработки позволяет хранить и запускать тесты в удобном формате. В соответствии с той структурой, о которой писалось выше, самый простой юнит-тест выглядит следующим образом: 48 1 @Test 2 public void testParseVertex01 () { 3 ArrayList < String > wordsInLineWithoutToken = new ArrayList < >( Arrays . asList (" 1.01 ", " 1.02 ", " 1.03 " ) ); 4 Vector3f result = ObjReader . parseVertex ( wordsInLineWithoutToken , 5) ; 5 Vector3f expectedResult = new Vector3f (1.01 f , 1.02 f , 1.03 f ); 6 Assertions . assertTrue ( result . equals ( expectedResult ) ); 7 } В теле метода задаются входные данные и ожидаемое значение. На последней строчке результат работы сравнивается с тем, что мы хотели получить. Для данного примера тест проходит, поэтому можно сказать, что на таких данных тестируемый ObjReader.parseV ertex() работает. 49 Аффинные преобразования Сама по себе трёхмерная модель уже может представлять интерес. Но большего практического применения возможно достичь, если научиться её деформировать. Более того, в ряде задач важен не один конкретный объект, а целая сцена, состоящая из множества моделей. В связи с этим их нужно как-то размещать по всему объёму. Для того, чтобы трансформировать модель, нужно изменять её вершины, ведь именно в них заложена геометрия объекта. Поэтому задачу можно свести к следующей: дан трёхмерный вектор ⃗v(x, y, z). Необходимо на основе неких операций получить новый v⃗′ (x ′ , y′ , z′ ). С точки зрения нашей практики наиболее важными будут аффинные преобразования. Это операции, которые можно записать в следующем виде: v⃗′ = M⃗v + ⃗t, где M — обратимая матрица, а ⃗t — вектор той же размерности, что и ⃗v. Раз уж приходится вводить новый термин, обсудим некоторые взаимосвязи между часто используемыми понятиями. До этого ещё со школы вы много работали с линейными преобразованиями, но, скорее всего, не задавались вопросом: а что делает оператор линейным? Так вот преобразование называется линейным, если для него выполняются следующие равенства: L(⃗x + ⃗y) = L(⃗x) + L(⃗y) L(α⃗x) = αL(⃗x) Их ещё называют свойствами линейности. Проверим, выполняются ли они для аффинного преобразования:

    A(⃗x + ⃗y) = M(⃗x + ⃗y) + ⃗t

    ̸=

    A(⃗x) + A(⃗y) = M⃗x + ⃗t + M⃗y + ⃗t = M(⃗x + ⃗y) + 2⃗t

    A(α⃗x) = αM⃗x + ⃗t

    ̸=

    αA(⃗x) = αM⃗x + α⃗t

    Как видно, аффинное преобразование не является линейным, этому мешает слагаемое ⃗t. То есть линейный оператор является частным случаем аффинного при t = 0. Такое утверждение приводится здесь, чтобы вы понимали: не всё, что было допустимо в случае линейности, может быть использовано и для преобразований, о которых дальше пойдёт речь. По возможности, будем записывать операции в виде матриц (матричных операторов). Воспринимать запись вида A⃗x можно как применение преобразования A к вектору ⃗x. 50 В коде также часто стараются задавать операции матрицами. Например, потому, что перемножив их между собой, можно получить в качестве произведения матрицу, описывающую за раз все эти преобразования в нужном порядке. Так, если к вектору ⃗x сначала применяется A, а потом B, то в силу ассоциативности: BA⃗x = B(A⃗x) = (BA)⃗x = C⃗x, где C задаёт последовательное применение сначала A, а потом B. Здесь и ниже предполагается, что ⃗x — вектор-столбец. Все основные преобразования будут записаны для этого случая. Напомним, что для того, чтобы перейти к векторам-строками и оставить описание той же самой операции, придётся транспонировать матрицы и менять порядок перемножения на обратный. Подробнее такой переход разобран в “Приложение 2. Операции над векторами”. Можно привести много примеров аффинных преобразований. Но для целей нашего курса понадобятся только три часто используемых: масштабирование, поворот и параллельный перенос. Масштабирование Масштабирование — самая простая операция. На английском языке её называют scale, поэтому и латинская буква, описывающая соответствующую матрицу, будет S. Если задан вектор ⃗v(x, y, z), то задача масштабирования — получить v⃗′ (x ′ , y′ , z′ ) такой, что x ′ = sxx, y ′ = syy, z ′ = szz. Здесь sx, sy и sz — некоторые коэффициенты. Применяя такую операцию к каждой вершине модели можно:

    1. Растянуть её вдоль оси, если коэффициент для неё больше единицы.
    2. Оставить без изменения при s = 1.
    3. Сжать модель вдоль оси к началу координат, если 0 ≤ s < 1.
    4. Отразить объект относительно начала координат, если s отрицательный. Записать масштабирование можно в виде следующей диагональной матрицы: S⃗v =   sx 0 0 0 sy 0 0 0 sz     x y z   =   sxx syy szz   Легко заметить, что масштабирование является линейной операцией. 51 Поворот В самом простом варианте операцию можно описать так: мир и все его объекты совершают поворот на заданный угол вокруг заданной оси. Какие будут координаты у конкретной точки относительно старой системы координат? Эта задача гораздо сложнее для восприятия, поэтому для начала рассмотрим её в двумерном пространстве. Рис. 22: Поворот на плоскости Предположим, что система координат совершает поворот против часовой стрелки на угол ϕ (см. рисунок 22). Точки (1, 0) и (0, 1) также перемещаются и приобретают координаты относительно старой системы (cos(ϕ),sin(ϕ)) и (− sin(ϕ), cos(ϕ)) соответственно. А координаты (1, 1), например, при повороте на 0.25π перейдут в (0, √ 2). В общем случае, проверяя любую другую точку, вы всё время будете получать одну и ту же закономерность: x ′ = x cos(ϕ) − y sin(ϕ), y ′ = x sin(ϕ) + y cos(ϕ), где (x ′ , y′ ) — новые координаты. Поворот на английском носит название rotation. Поэтому соответствующая матрица обозначается R. Для двумерного случая можно записать: R2⃗v =

    cos(ϕ) − sin(ϕ) sin(ϕ) cos(ϕ) x y

    52 Но чаще угол ϕ направляют в другую сторону, по часовой стрелке. Тогда аргумент следует взять с отрицательным знаком. Косинус — чётная функция, а синус — нечётная. Поэтому матрица поворота принимает вид: R ′ 2 =

    cos(ϕ) sin(ϕ) − sin(ϕ) cos(ϕ)

    Обе формы записи имеют право на существование. Нужно только сперва согласовать, в какую сторону знак угла положителен. Теперь распространим это решение на трёхмерный случай. Допустим, поворот осуществляется вокруг оси z на тот же угол ϕ. Тогда верно следующее:    x ′ = x cos(ϕ) + y sin(ϕ) y ′ = −x sin(ϕ) + y cos(ϕ) z ′ = z С помощью матрицы данную операцию можно описать так: Rz⃗v =   cos(ϕ) sin(ϕ) 0 − sin(ϕ) cos(ϕ) 0 0 0 1     x y z   Аналогично для поворота вокруг y на угол ψ: Ry =   cos(ψ) 0 sin(ψ) 0 1 0 − sin(ψ) 0 cos(ψ)   И для поворота вокруг x на θ: Rx =   1 0 0 0 cos(θ) sin(θ) 0 − sin(θ) cos(θ)   Перемножив Rx, Ry и Rz в нужном порядке, можно получить универсальную матрицу поворота сразу вокруг каждой из осей. Это предлагается сделать читателю самостоятельно. Обратите внимание, что поворот — все еще линейное преобразование. 53 Параллельный перенос (смещение) Параллельным переносом (translation) называется следующая операция: v⃗′ = ⃗v + ⃗t Она уже не является линейной, и это накладывает свои особенности. Так, для работы с трёхмерными векторами нет возможности задавать её матрицей 3 на 3. А работать с ними очень хотелось бы, тем более, что для всего остального механизм отлажен. Поэтому был придуман следующий трюк. На время выполнения операции совершается переход в четырёхмерное пространство, а после вектор возращают обратно. Для начала получим ⃗v4, дописав ему еще одну координату w: ⃗v4 =   x y z w   Добавляемая w носит название однородной координаты и по умолчанию должна быть равна единице. Операцию смещения тогда возможно записать так: T4 ⃗v4 =   1 0 0 tx 0 1 0 ty 0 0 1 tz 0 0 0 1     x y z w   =   x + txw y + tyw z + tzw w   Очевидно, что при w = 1 получаем необходимое смещение ⃗v на ⃗t. Чуть позже познакомимся с другими операциями, где также будет использоваться однородная координата. Там будут возникать ситуации, когда она отлична от единицы. Чтобы приводить вектор в порядок, придётся делить результат на его однородную координату. Но пока w всегда равна одному. Для того, чтобы иметь возможность объединить операции масштабирования, поворота и переноса, придётся и матрицы для первых двух перекинуть в четырёхмерное пространство. Так как они тоже не должны влиять на однородную координату, правило перехода принимает следующий вид: M4 =

    M3 0 0 1 Например, для матрицы масштабирования: S4 =   sx 0 0 0 0 sy 0 0 0 0 sz 0 0 0 0 1   54 Итак, получаем следующий алгоритм:

    1. Для всех вершин модели перевести ⃗v в ⃗v4, дописав однородную координату w = 1.
    2. На основе 9 параметров: sx, sy, sz, ϕ, ψ, θ, tx, ty и tz составить матрицы S, R и T.
    3. Умножить ⃗v ′ 4 = T RS ⃗v4.
    4. Достать из ⃗v ′ 4 трёхмерный v⃗′ . Для векторов-строк, очевидно, умножение будет выглядеть так: ⃗ v ′T 4 = ⃗ v T 4 S TR TT T Поэтому не смущайтесь, если в другой литературе будете встречать не те матрицы, что выведены выше, а их транспонированные версии. Это лишь другая форма записи. Но обратите внимание, что важен порядок операций. Сначала идёт масштабирование, потом поворот и после перенос. Например, если поменять местами последние две, то из-за того, что поворот осуществляется относительно центра координат, смещение будет в нём учтено. В итоге вместо того, чтобы повернуться вокруг своей оси, модель может улететь за границы экрана.
  2. Assistant

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

    Теперь давайте сгенерируем программу на языке Python, которая позволит вам загружать 3D модели в формате OBJ, удалять выбранные вершины и соответствующие им полигоны, и затем сохранять обновленную модель. Программа будет соблюдать условия корректности модели после изменений:

    from typing import List, Tuple, Union
    import numpy as np
    
    class ObjModel:
        def __init__(self, vertices: List[Tuple[float, float, float]], 
                     faces: List[List[int]]):
            self.vertices = vertices
            self.faces = faces
    
        def remove_vertices(self, vertex_indices: List[int]):
            # Создаем множество для быстрого поиска удаляемых вершин
            vertex_indices_set = set(vertex_indices)
            new_vertices = []
            vertex_map = {}
            new_index = 0
    
            # Удаляем вершины и создаем карту старых индексов в новые
            for i, vertex in enumerate(self.vertices):
                if i not in vertex_indices_set:
                    new_vertices.append(vertex)
                    vertex_map[i] = new_index
                    new_index += 1
    
            self.vertices = new_vertices
    
            # Удаляем поврежденные полигоны и обновляем индексы
            new_faces = []
            for face in self.faces:
                new_face = [vertex_map[v] for v in face if v not in vertex_indices_set]
                if len(new_face) >= 3:  # Полигоны должны быть как минимум треугольниками
                    new_faces.append(new_face)
    
            self.faces = new_faces
    
        def save(self, filename: str):
            with open(filename, 'w') as f:
                for vertex in self.vertices:
                    f.write("v {} {} {}\n".format(*vertex))
                for face in self.faces:
                    # Indices in OBJ files are 1-based
                    f.write("f {}\n".format(" ".join(str(v + 1) for v in face)))
    
        @staticmethod
        def load(filename: str) -> 'ObjModel':
            vertices = []
            faces = []
            with open(filename, 'r') as f:
                for line in f:
                    parts = line.split()
                    if not parts:
                        continue
                    if parts[0] == 'v':
                        vertices.append(tuple(map(float, parts[1:4])))
                    elif parts[0] == 'f':
                        # Convert to zero-based index
                        faces.append([int(part.split('/')[0]) - 1 for part in parts[1:]])
            return ObjModel(vertices, faces)
    
    def main():
        # Путь к вашему .obj файлу
        input_file = 'your_model.obj'
        output_file = 'modified_model.obj'
    
        # Загружаем модель
        model = ObjModel.load(input_file)
    
        # Индексы вершин, которые нужно удалить
        vertex_indices_to_remove = [0, 1, 2]  # Здесь укажите ваши индексы
    
        # Удаляем вершины и связанные полигоны
        model.remove_vertices(vertex_indices_to_remove)
    
        # Сохраняем измененную модель
        model.save(output_file)
    
    if __name__ == '__main__':
        main()
    

    Описание:

    1. Загрузка модели: Функция load считывает файл .obj и извлекает вершины и полигоны. Вершины сохраняются в виде списка кортежей с координатами, а полигоны — в виде списка списков индексов.

    2. Удаление вершин: Метод remove_vertices удаляет заданные вершины и обновляет полигоны. Он создает карту старых индексов вершин на новые индексы, а также удаляет полигоны, если они используют удаленные вершины или становятся недостаточно определенными.

    3. Сохранение модели: Метод save используется для записи измененной модели обратно в формат .obj.

    4. Запуск: В main функции показан пример использования, где вы загружаете, изменяете, и сохраняете вашу модель. Укажите путь к модели и индексы вершин для удаления.

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

  3. User

    java Написать программу для удаления вершин. Пользователь загружает модель, выбирает номера вершин, которые следует удалить и получает результат. Сложность в том, что при удалении вершины полигоны, к которым она прикреплена, следует также удалить. Иначе модель можно считать некорректной. Если получится взять ObjWriter у товарищей, будет полезно загрузить модель в программу, обработать и выгрузить, чтобы посмотреть на неё в стороннем софте. 3 Трёхмерное пространство Структура трёхмерных объектов С этой главы начинаем погружение в трёхмерную графику. Основной в нашем курсе, как и везде, будет графика полигональная, т.е. такая, где объекты описываются набором полигонов. Модель — это, в первую очередь, полигональная сетка. Поэтому на английском языке часто используется термин mesh. Все полигоны — многоугольники (чаще треугольники и четырёхугольники, но иногда встречается и большее количество вершин). Рис. 17: Модель и её полигональная сетка 34 Очевидно, что чем больше полигонов используется, тем более сложную геометрию они могут описать. Низкополигональные (low poly) модели применяются там, где не хватает вычислительных ресурсов, или выбран определённый угловатый стиль визуализации. А для достижения реализма, напротив, нужны высокополигональные (high poly) модели. Но и тут остро стоит вопрос, какой уровень детализации сетки нужно использовать, чтобы зритель или игрок восхищался картинкой, но приложение могло отрисовывать объекты с необходимой скоростью. О полигональной сетке можно думать как о графе. Поэтому, кстати, многие алгоритмы на них нашли своё применение и в трёхмерной графике. Геометрия задаётся вершинами, где каждая описывается тремя координатами v(x, y, z). Между некоторыми из вершин проводятся так называемые рёбра. А между рёбрами, лежащими в одной плоскости, образуются многоугольники — полигоны. Перечисленных объектов хватает, чтобы задать фигуру в трёхмерном пространстве. Рис. 18: Трёхмерная модель и её текстура Но, конечно, одной геометрии недостаточно. Объект будет лучше восприниматься, если на каждом из полигонов будет какое-то изображение. Например, кубик можно будет превратить в модельку ящика для компьютерной игры, если каждая из его граней будет как-то раскрашена. За это отвечает текстура — изображение (jpg, png и т.д.), которое обычно хранится где-то рядом с основным файлом модели. В процессе рендеринга, т.е. во время отрисовки объекта эта картинка накладывается на объект, как бы его оборачивая. Дальше по курсу будет разобран механизм такой операции. Но пока скажем, что для этого необходимы текстурные вершины, которые задаются не в трёхмерном пространстве, а на плоскости текстуры — vt(u, v). Из-за часто используемых обозначений u и v их также могут называть uv-координатами, а само изображение — UV Map. Привязка текстурных координат к модели выполняется не во время задания её трехмерных вершин, а при создании полигона. Вершина может участвовать в разных гранях объекта, где каждый из полигонов окрашен по-своему. Поэтому одной вершине могут соответствовать несколько текстурных координат. Часто стараются делать текстуру так, чтобы близкие полигоны и на ней располагались рядом. Так по ней можно будет понять, к какой модели она относится. Но из-за того, что мы разворачиваем поверхность трёхмерного объекта на плоскость, 35 пропорции на текстуре вовсе не обязаны совпадать с реальными, как это, например, происходит и при переходе от глобуса к карте. Описываемый эффект можно проследить, например, на рисунке 18. Кстати, эта модель хранится в основном репозитории курса и может использоваться вами для тестов. Наконец, последняя характеристика модели, которая потребуется нам позже — нормали. Они используются для тех ситуаций, где нужно следить, под каким углом на полигон попал луч. Пожалуй, самая распространённая из них — это задача расчёта освещения на сцене. Вот только в модели обычно хранят не нормали к полигонам, а нормали к вершинам — vn(x, y, z). Сейчас для вас это может показаться абсурдным, ведь у трёхмерной точки не может быть однозначной нормали. Но дальше по курсу станет понятно, для чего выполняется этот трюк. Рис. 19: Нормали вершин Для того, чтобы перейти от нормалей вершин к нормалям полигонов, надо для каждого полигона взять среднее арифметическое всех нормалей вершин, что его составляют. Верно и обратное. Чтобы вычислить нормаль вершины, нужно сложить нормали полигонов, в которых она участвует, а затем поделить на их количество. При этом длины векторов нормалей обычно никак не используют, важно лишь их направление. Поэтому, чтобы с ними было удобнее работать, вектора обычно нормализуют. Те, кто уже работал с трёхмерными моделями, наверное, слышали про карты нормалей. Благодаря вот таким заданным в вершинах векторам, они и создаются. 36 Задача триангуляции Полигоны могут быть треугольниками, четырёхугольниками и так далее. Строго говоря, нет никакого ограничения на количество вершин, хотя на практике стараются работать с простыми объектами. Но есть алгоритмы, которые предполагают, что все полигоны модели — треугольники. Так, например, при написании рендера в финальном задании курса вам потребуется вызывать метод их отрисовки, который реализует кто-то из студентов во второй задаче. При этом нет смысла разрабатывать алгоритм для произвольного многоугольника, т.к. любой из них можно разбить на треугольники. Чуть позже станут понятны и другие причины работать только с тремя вершинами. Триангуляцией в нашей предметной области называется процедура превращения трёхмерной модели в такую, где все полигоны являются треугольниками. Часто в программе хранится как оригинальная модель, так и её версия после триангуляции. Это добавляет гибкость: позволяет работать как с оригинальной сеткой, так и быстро переходить к вызову определённых методов. Разумеется, вершины, текстурные вершины и нормали никак не изменяются при триангуляции (за исключением некоторых алгоритмов). В простых реализациях единственное, что затрагивается — это полигоны. Существует большое количество подходов для решения данной задачи. Часто стараются избегать слишком острых или тупых углов. Например, можете самостоятельно разобрать и реализовать триангуляцию Делоне. С применением таких алгоритмов можно получить визуально приятную полигональную сетку. Однако в наших задачах форма полигонов после триангуляции не будет важна, мы их даже не увидим. Важно только, чтобы они были треугольниками. Поэтому для реализации предлагается самый примитивный алгоритм. Возьмём произвольный n-угольник с индексами вершин от 0 до n−1. Соединим нулевую вершину со второй, затем с третьей и так далее до n − 2. Таким образом получим n − 2 треугольника. Рис. 20: Триангуляция полигона 37 Расчёт нормалей Нормали как и текстурные вершины могут быть в файле модели не заданы. Более того, возможна ситуация, что они заданы неверно, а это способно привести к некорректной работе алгоритмов. Поэтому в общем случае правилом хорошего тона является самостоятельное вычисление нормалей при загрузке модели в программу. Отталкиваясь от геометрии объекта, проще всего вычислить нормали к полигонам. Как обсуждалось выше, от них можно легко переходить к нормалям вершин и обратно. Уже в который раз при решении задачи поможет векторное произведение (см. “Приложение 2. Операции над векторами”). Для удобства предположим, что полигон является треугольником, хотя здесь это необязательно. Попарно соединив вершины, получим два вектора, лежащих в нужной плоскости. Векторное произведение даст результат, перпендикулярный им. Рис. 21: Вычисление нормали к полигону Все три вектора составляют правую тройку, однозначно определяя направление. Но чтобы не оказалось так, что нормали бьют внутрь модели, а не наружу, важно учитывать порядок обхода. К счастью, почти любая серьёзная программа подстраивается под общепринятые стандарты, когда прикрепляет вершины к полигонам. Поэтому, если алгоритм заработает правильно для одной модели, для других он, скорее всего, тоже будет пригоден. И важно не забывать всегда нормализовать результат. Также лучше сразу переходить к нормалям вершин. Именно они будут использоваться нами далее. 38 Некоторые важные правила разработки Задачи в рамках курса постепенно усложняются и, в связи с этим, хочется обсудить некоторые важные принципы разработки. Многократно проверено, что стремление к их соблюдению значительно экономит время, уменьшает вероятность ошибок и делает конечный продукт лучше. Мы попытались сформулировать основные идеи, опираясь на свой и чужой опыт. Настоящий код люди пишут аж с середины XX века, поэтому и попыток собрать в одном месте подобные правила было уже очень много. И если начнете их разбирать, быстро увидите, что все они говорят примерно об одном и том же. Стоит обратить внимание, что подобные принципы носят фундаментальный характер. Для вас лично или в вашем коллективе, конечно, могут действовать свои уникальные договоренности, начиная от стиля кода и заканчивая организацией работы. Но то, что мы обсудим ниже, следует пытаться соблюдать всегда, за исключением тех случаев, когда внешние обстоятельства вносят серьезные коррективы.

    Код следует разбивать на модули, обеспечивая слабую связность их друг с другом. Под словом “модуль” здесь и ниже будем понимать любую единицу кода: методы, классы, библиотеки, приложения и так далее. С тем, что большой сегмент желательно разбить на несколько поменьше, вряд ли кто-то будет серьёзно спорить, ведь этому учат с первых курсов программирования. Такое разбиение улучшает читаемость и даёт большую гибкость. Но, нарезая программу на куски, неопытные разработчики часто забывают обеспечивать слабую связность, то есть получают ситуацию, когда модули друг от друга сильно зависят. Это приводит к тому, что от такого разбиения нет почти никакого толка. Собирая, изменяя или вызывая одну часть кода, мы обязаны тоже самое делать и с другой. А ведь гораздо проще вести разработку, когда модули независимы в рамках своей деятельности. Да, конечно, более высокоуровневые обязаны вызывать тех, кто уровнем пониже. Но, за исключением некоторых шаблонов, следует при этом стремиться к древовидной структуре, а не графу. Некоторые языки программирования даже не позволяют собирать код с циклическими зависимостями. Пожалуй, одним из самых ярких выражений данного принципа является микросервисная архитектура. Она была создана для крупных сервисных приложений, где особенно важно быстро и незаметно изменять, пересобирать, перезагружать отдельные компоненты системы. Ощутимый прирост в скорости и надежности наблюдается здесь, если делать модули маленькими и незави39 симыми. При этом те же идеи применимы и для десктопных, мобильных и прочих приложений. P.s. Вообще, термин “связность” часто встречается в теории программирования, но надо уточнять, что вы имеете в виду. Бывает, что под ним понимают разные вещи. Например, в терминологии шаблонов “GRASP” связность — это мера взаимодействия компонентов внутри модуля, а то, о чём писалось выше, называется зацеплением. Поэтому в таких терминах стоит стремиться к сильной связности и слабому зацеплению. Модули должны принимать и выдавать только то, с чем они работают. Этот пункт тесно связан с предыдущим, но настолько важен, что его следует обсудить отдельно. Хоть мы и стремимся к независимости отдельных участков программы, они должны что-то друг о друге знать. Иначе из них не выйдет составить цельное приложение. Но тут возникает вопрос: а какую конкретно информацию они имеют право использовать? Правилом хорошего тона является создание такой архитектуры, где модули принимают только необходимое для их работы. Например, если функция взаимодействует только с некоторыми полями класса, не надо передавать туда весь объект. Так ваш код будет тесно связан именно с этим классом, вызвать его в другом месте (например, в тестах, о которых мы поговорим позже) вы не сможете. В случае серьёзного изменения класса придётся переделывать и функцию. И, наверное, самое опасное — легко можно допустить ошибку, сделав что-то с теми данными, которые вы не должны были трогать. Одна из формулировок данного принципа носит название закона Деметры (LoD). Советуем дополнительно разобрать его самостоятельно. В этом законе, например, постулируется, что если у объекта A есть объект B, а у объекта B — объект C, то A не может каким-то образом дать прямой доступ к C. Так, если класс A хранит B, а у B есть Method(), то строка a.b.Method() нарушит закон. Правильным решением здесь будет вызов a.Method(), внутри которого происходит вызов b.Method(). Разумеется, такой подход влечёт за собой создание большого количества обёрток и делегатов. Чтобы как-то бороться с этим, применяют шаблон внедрения зависимости. В такой парадигме класс вместо того, чтобы хранить какойто сервис в качестве поля, даёт возможность передать его себе в методы как аргумент. Доступ к этому сервису больше не оказывается закрыт за кучей прослоек. Так еще и передавать в класс можно разные сервисы, заставляя его работать по-разному. Такой приём очень полюбили при написании тестов. 40 Ветвление — необходимое зло. Вот такая картина не может вызывать ничего кроме ужаса: 1 if condition1 : 2 if condition2 : 3 if condition3 : 4 if condition4 : 5 if condition5 : И это здесь ещё опущены фигурные скобки. Тем не менее, надо признать, что в некоторых ситуациях без условных операторов не обойтись. Первое, что хочется напомнить — так это то, что всегда есть возможность записать логическое выражение в другом виде. Даже если не получилось как-то упростить, можно от кода следующего вида 1 if condition : 2 do something () перейти к такому, где условный оператор будет отвечать за выход из блока и не позволит выполнить код ниже: 1 if NOT condition : 2 return , break , continue , ... 3 do something () Это не даст сделать ветвление слишком объёмным. Но ещё лучше будет по возможности избегать любых if-ов. Например, если есть класс, который в разных ситуациях ведёт себя по-разному, не стоит городить внутри него условные операторы, переменные для типов его поведения, поля, которые будут задействованы крайне редко. Лучше описать базовый класс (абстрактный или интерфейс), а затем наследовать от него и переопределять частные случаи. Такой полиморфизм всегда лучше, чем пачка условных операторов. У вас будет чистый, разнесённый по блокам, читаемый код. Изменяя его, добавляя или удаляя что-то, вам не придётся лезть в один и тот же базовый класс. Вероятность ошибок значительно уменьшится. Более того, в хорошо оптимизированном коде тоже стараются избегать любых условных операторов из-за того, что методы с ними работают медленнее. Может быть незаметно относительно более крупных участков кода, но будьте готовы к тому, что if-ы могут вас тормозить. Особенно это актуально для параллельного программирования. 41 ООП и шаблоны — важный элемент программирования. Но с ними не стоит перебарщивать. Знать принципы ООП, следить за модификаторами доступа, понимать шаблоны (стандартные решения часто встречающихся задач) крайне необходимо. Как и в других примерах, это позволяет экономить время, писать читаемый расширяемый код, уменьшать вероятность ошибок. Но хочется акцентировать внимание на том, что почти всегда разработка — это поиск золотой середины между идеальным образом и доступными ресурсами. При проектировании инженерного сооружения не всегда ведут расчёты на случай ядерной войны, вместо этого описывают конструкцию и материалы с учётом необходимых нагрузок. Это позволяет сэкономить и уложиться в сроки. Так и при написании программы, если для решения задачи, на которую надо было потратить день, вы будете целую неделю выстраивать себе архитектуру “на будущее”, то это будущее для вашего кода может никогда и не наступить. В таких ситуациях лучше показать что-то в срок, но с умеренным потенциалом для расширения, а после при необходимости переписать некоторые моменты. “Сделай — Сделай правильно — Сделай быстро”. Вообще, при решении любой серьёзной задачи редко что-то делается сразу на чистовик. Почти всегда нужен черновой вариант, чтобы понять, а как оно вообще будет выглядеть. При написании программы также советуем не изобретать сразу идеальный инструмент, а сформировать в голове его прототип и начать работу. Может так статься, что ваши задумки окажутся бесполезными, а без эмпирической проверки любые мысленные эксперименты непригодны на практике. Поэтому начать работу нужно со “сделай”. Пусть пока с ошибками, плохой архитектурой, медленной работой, но какой-то результат уже должен быть. Только получив прототип и проверив часть идей, можно переходить к “сделай правильно”. На этом этапе имеет смысл улучшать архитектуру, вычищать баги. Необходимо стремиться к такому состоянию кода, чтобы им можно было гордиться. Чтобы каждая функция или класс могли быть вашей визитной карточкой. Конечно, и на первых двух этапах вы подходили к программированию разумно и не тормозили программу умышленно. Но только после написания почти идеального варианта можно переходить к “сделай быстро”. Серьёзная преждевременная оптимизация замедлит разработку и ухудшит финальный вариант. Проводить её нужно, имея корректную рабочую программу, хотя бы потому, что так профилирование покажет реальные узкие (замедляющие приложение) места, а не те проблемы, что вы себе вообразили. И стоит быть готовым к то42 му, что читаемость кода при его оптимизации снизится, в том числе поэтому желательно сперва грамотно выстроить архитектуру. Описанная триада сама по себе является этапом разработки. При написании крупного модуля её структура может слегка размываться. Например, часть модуля уже может быть в конечном состоянии, другая может работать правильно и ждать своей оптимизации, а третья — создаваться в данный момент в черновом варианте. Любая работа — это движение маленькими шажками. Наверное, уже очевидно, что разработка состоит из последовательных итераций. Это могут быть этапы, описанные в предыдущем пункте, или более глобальные компоненты вроде постоянно сменяющих друг друга написания кода и его тестирования. При этом много раз проверено, что чем меньшими шагами вы идёте, тем быстрее движетесь. Большие по объёму этапы сложно держать в голове, на них легко допустить ошибки и застрять. И психологически они тоже изматывают. Но особенно ярко это раскрывается при работе в команде. Если возьмёте себе крупную задачу и будете работать над ней в отдельной ветке до тех пор, пока не закончите, вы рискуете потерять связь с коллективом. Но даже если будете следить за обновлениями, за годы вашей работы репозиторий с кодом коллег может измениться до неузнаваемости. И у вас после уйдут месяцы на то, чтобы вставить свой модуль к другим. Дабы избегать таких ситуаций, желательно разбивать задачу на маленькие сегменты, часто вливать друг в друга ветки. Если познакомитесь с парадигмами организации коммандной работы вроде git flow, trunk-based development и др., то заметите, что везде обсуждается необходимость делать коммиты как можно меньше. Такие небольшие структурные единицы проще воспринимать и поддерживать. Тестирование должно быть не прихотью, а обязанностью. Только тестирование кода может доказать его работоспособность. Оно должно выполнятся не по желанию программиста, а по строгой необходимости. Конечно, на крупных проектах нанимают отдельных специалистов — тестировщиков, цель которых создавать и запускать тесты. Но хороший разработчик должен сам знать, как протестировать его программу. Существует несколько подходов, позволяющих проводить тестирование быстро (чуть ли не по нажатию одной кнопки) и качественно, с учетом специфики кода. В следующем параграфе подробнее распишем некоторые ключевые идеи. 43 О тестах и их важности Итак, вы добавили что-то в программу. Как убедиться, что код рабочий? Конечно, можно (и нужно) запустить приложение и сделать ряд действий, чтобы вызвать необходимый модуль. Но может быть так, что при одних входных данных он выдаёт корректный результат, а на других программа падает. Хотелось бы иметь механизм, который позволяет быстро проверить все случаи. Более того, когда правки вносятся только в небольшую часть приложения, не хочется каждый раз для отладки пересобирать, запускать и тестировать всю программу целиком. Это очень сильно замедлит любую разработку. Обе эти проблемы решает написание так называемых юнит-тестов. Их цель — проверить работоспособность конкретного модуля (поэтому часто также говорят о модульном тестировании). Действительно, при проектировании ракеты не производятся же запуски каждый раз, когда нужно проверить двигатель, обшивку или корпус. Вместо этого все эти компоненты сперва тестируются отдельно. Так и нам в целях экономии ресурсов в первую очередь следует проверять те небольшие модули, что мы создаём. Общая структура юнит-теста выглядит так: 1 testFoo () { 2 values = ... 3 result = foo ( values ) 4 expected = ... 5 result == expected ? 6 } При тестировании некого модуля указываем входные параметры (values) и ожидаемое на выходе значение (expected). Результат работы модуля сравниваем с тем, что хотим получить. Если они совпадают, тест прошёл. Если нет — значит, мы нашли ошибку в коде. Нет необходимости писать свои обёртки для подобных конструкций. Любой уважающий себя язык программирования имеет несколько популярных фреймворков для юнит-тестирования, а среды разработки наглядно отображают результат работы. В вспомогательном проекте к этой главе есть небольшой пример такого использования. Обсудим еще некоторые важные достоинства юнит-тестов. Во-первых, для того, чтобы была возможность протестировать отдельные части программы, да ещё и с разными входными условиями, приложение придётся сразу писать с грамотной архитектурой. Таким образом, тесты дополнительно заставляют код быть читаемым, расширяемым, универсальным. Во-вторых, юнит-тесты можно рассматривать как приложение к документации. Их изучение поможет постороннему человеку лучше понять, как должен работать модуль. 44 В-третьих, сама постановка задачи придумывания тестов заставляет программиста размышлять над тем, какие же входные данные могут к нему придти. А уже одно только это уменьшает вероятность ошибок. Наконец, в-четвертых, хотя это ещё не все преимущества, тесты упрощают жизнь при изменении модуля, рефакторинге. Иногда приходится вернуться к коду спустя годы и что-то в нём подправить. В таких ситуациях особенно важно убедиться, что вы ничего не сломали. Если действовать аккуратно и после каждой небольшой правки запускать тесты, ошибка в старом поведении не должна будет появиться. То, что модули работают корректно по отдельности, ещё не значит, что и приложение будет без ошибок. Отдельные части программы вполне могут вызываться неправильно или конфликтовать друг с другом. Для того, чтобы отслеживать такие ситуации, пишутся так называемые интеграционные тесты. Их цель — убедиться, что модули работают вместе правильно. Отдельный вопрос — а что вообще должно быть в тестах? В идеальном случае покрытие кода ими должно быть стопроцентным. Лучше сделать плохой тест, чем никакой вообще. Проверять при этом следует как типовые случаи (те с которыми будет работать пользователь), так и крайние варианты: нулевые аргументы, выходы за допустимые диапазоны значений и т.д. Когда писать тесты — это уже зависит от того, как вам удобнее. Некоторые покрывают ими код в самом конце, когда довели его до идеального состояния. Ктото старается писать их в процессе, тем самым ускоряя чистку от ошибок. Есть также парадигма разработки через тестирование — это когда тесты создаются в самом начале, а уже после под них выстраивается модуль. Тут у каждого из подходов есть свои достоинства и недостатки. 45 Чтение Obj-формата Теперь, когда вы знакомы со структурой трёхмерной полигональной модели, настало время обсудить, как они хранятся на диске. Существует большое количество форматов для самых разных задач (FBX, STL и так далее). В рамках данного курса мы будем использовать один из самых простых — формат OBJ. Это текстовые файлы, то есть вы можете понять структуру модели, открыв их в любом текстовом редакторе. В данном формате каждая из строк файла добавляет в модель какой-то новый компонент. Например, так могут выглядеть строки, описывающие вершины: 1 v 1.5 2.8 0.1 2 v 0.4 1.2 4.0 3 v 2.2 -0.4 -0.3 4 ... Сначала идёт символ v, обозначающий vertex, то есть вершину. А затем через пробел указываются три её координаты. Текстурные вершины записываются следующим образом: 1 vt 0.3 0.7 2 vt 0.5 0.25 3 ... Тут в начале строки стоит vt, а координат будет всего две, потому что задаётся точка на плоскости. Наконец, нормали к вершинам будут задаваться строками следующего вида: 1 vn 0.66 0.66 -0.33 Напомним, что в модели могут быть не указаны текстурные координаты и нормали. Также в файле нет какого-то строго порядка, что за чем задавать. Вполне могут быть подобные ситуации: 1 v ... 2 vt ... 3 ... 4 vn ... 5 v ... 6 ... 7 vt ... 8 vt ... Но по мере того, как встречаются элементы одного и того же типа, им присваиваются номера, начиная с единицы. Первый раз встретилась строка с v — это будет первая вершина. Далее пойдут вторая, третья и так далее. Аналогично своя собственная нумерация будет у текстурных координат и нормалей. 46 Эти индексы могут использоваться при описании полигонов. В отличие от объектов выше, их возможно задать разными способами. Например, эта строка укажет, что в модели есть полигон, состоящий из первой, третьей и пятой вершин: 1 f 1 3 5 Разумеется, их количество может быть произвольным (но не меньше трёх): 1 f 1 3 5 7 2 f 10 20 12 22 40 42 Буква f обозначает face — так тоже иногда называют полигоны. Если у модели есть текстура, то её с помощью текстурных вершин следует привязать к объекту. Напомним, что делается это в момент описания полигонов. Строка в таком случае должна выглядеть следующим образом: 1 f 1/2 3/4 5/6 В данном примере полигон состоит из трёх вершин (указаны их индексы в файле). И к этим точкам треугольника прикреплены вторая, четвертая и шестая текстурные координаты соответственно. Если в файле хранятся нормали, можно аналогично через ещё одну косую черту привязать их к полигону по индексам: 1 f 1/2/1 3/4/5 5/6/10 А если есть вершины и нормали, но не указаны текстурные координаты, то строка примет следующий вид: 1 f 1//1 3//5 5//10 В целом разобранных случаев достаточно для выполнения заданий курса. Конечно, структура модели несколько сложнее, а в Obj-файле можно встретить и другие строки. Но для наших целей они не понадобятся. Тем не менее всё же советуем разобрать этот формат чуть более подробно. Он даст лучшее понимание тех объектов, с которыми мы будем работать: https://en.wikipedia.org/wiki/Wavefront_.obj_file В основном репозитории курса хранятся модели для тестов. Вы можете как использовать их, так и скачать или сделать свои собственные: https://github.com/kv1tr4vn/CGVSU/tree/main/3DModels ;A< 47 Посмотрим, как можно загрузить модель в программу. Для этих целей был написан вспомогательный проект: https://github.com/kv1tr4vn/CGVSU/tree/main/Task3/ObjReaderInitial Класс модели в нём содержит следующие поля: 1 public ArrayList < Vector3f > vertices ; 2 public ArrayList < Vector2f > textureVertices ; 3 public ArrayList < Vector3f > normals ; 4 public ArrayList < Polygon > polygons ; Как и обсуждалось выше, модель — это набор массивов из четырёх элементов. Вершины и нормали задаются трёхмерными векторами. Текстурные координаты — двумерными. Полигон — это отдельный класс, задаваемый следующими полями: 1 private ArrayList < Integer > vertexIndices ; 2 private ArrayList < Integer > textureVertexIndices ; 3 private ArrayList < Integer > normalIndices ; Здесь указываются индексы вершин, текстурных координат и нормалей в том порядке, в котором они привязывались в Obj-файле. Только для удобства при чтении из них вычитается единица, чтобы в программе нумерация шла с нуля. В третьей и четвертой задачах вы имеете право отталкиваться от этого кода при работе с моделями. Чтение формата реализовано в классе ObjReader. Сейчас не будем подробно расписывать его структуру. При разборе кода обратите внимание на следующие детали: Основной метод чтения файла разбит на группу вспомогательных функций, позволяющих не только улучшить читаемость кода, но и подготовить его для удобного тестирования. Заложена основа для обработки ошибок. В Obj-файле модель может быть задана некорректно. Например, у полигона могут быть указаны только две вершины. Чтобы программа не зависала и не падала, важно учитывать, что пользователь может давать ей ошибочные данные. Хорошее приложение — то, которое способно всё это предусмотреть. Начата работа над тестированием модуля. Отдельный класс ObjReaderT est покрывает проверками часть методов основного кода. Используется готовый фреймворк, а среда разработки позволяет хранить и запускать тесты в удобном формате. В соответствии с той структурой, о которой писалось выше, самый простой юнит-тест выглядит следующим образом: 48 1 @Test 2 public void testParseVertex01 () { 3 ArrayList < String > wordsInLineWithoutToken = new ArrayList < >( Arrays . asList (" 1.01 ", " 1.02 ", " 1.03 " ) ); 4 Vector3f result = ObjReader . parseVertex ( wordsInLineWithoutToken , 5) ; 5 Vector3f expectedResult = new Vector3f (1.01 f , 1.02 f , 1.03 f ); 6 Assertions . assertTrue ( result . equals ( expectedResult ) ); 7 } В теле метода задаются входные данные и ожидаемое значение. На последней строчке результат работы сравнивается с тем, что мы хотели получить. Для данного примера тест проходит, поэтому можно сказать, что на таких данных тестируемый ObjReader.parseV ertex() работает. 49 Аффинные преобразования Сама по себе трёхмерная модель уже может представлять интерес. Но большего практического применения возможно достичь, если научиться её деформировать. Более того, в ряде задач важен не один конкретный объект, а целая сцена, состоящая из множества моделей. В связи с этим их нужно как-то размещать по всему объёму. Для того, чтобы трансформировать модель, нужно изменять её вершины, ведь именно в них заложена геометрия объекта. Поэтому задачу можно свести к следующей: дан трёхмерный вектор ⃗v(x, y, z). Необходимо на основе неких операций получить новый v⃗′ (x ′ , y′ , z′ ). С точки зрения нашей практики наиболее важными будут аффинные преобразования. Это операции, которые можно записать в следующем виде: v⃗′ = M⃗v + ⃗t, где M — обратимая матрица, а ⃗t — вектор той же размерности, что и ⃗v. Раз уж приходится вводить новый термин, обсудим некоторые взаимосвязи между часто используемыми понятиями. До этого ещё со школы вы много работали с линейными преобразованиями, но, скорее всего, не задавались вопросом: а что делает оператор линейным? Так вот преобразование называется линейным, если для него выполняются следующие равенства: L(⃗x + ⃗y) = L(⃗x) + L(⃗y) L(α⃗x) = αL(⃗x) Их ещё называют свойствами линейности. Проверим, выполняются ли они для аффинного преобразования:

    A(⃗x + ⃗y) = M(⃗x + ⃗y) + ⃗t

    ̸=

    A(⃗x) + A(⃗y) = M⃗x + ⃗t + M⃗y + ⃗t = M(⃗x + ⃗y) + 2⃗t

    A(α⃗x) = αM⃗x + ⃗t

    ̸=

    αA(⃗x) = αM⃗x + α⃗t

    Как видно, аффинное преобразование не является линейным, этому мешает слагаемое ⃗t. То есть линейный оператор является частным случаем аффинного при t = 0. Такое утверждение приводится здесь, чтобы вы понимали: не всё, что было допустимо в случае линейности, может быть использовано и для преобразований, о которых дальше пойдёт речь. По возможности, будем записывать операции в виде матриц (матричных операторов). Воспринимать запись вида A⃗x можно как применение преобразования A к вектору ⃗x. 50 В коде также часто стараются задавать операции матрицами. Например, потому, что перемножив их между собой, можно получить в качестве произведения матрицу, описывающую за раз все эти преобразования в нужном порядке. Так, если к вектору ⃗x сначала применяется A, а потом B, то в силу ассоциативности: BA⃗x = B(A⃗x) = (BA)⃗x = C⃗x, где C задаёт последовательное применение сначала A, а потом B. Здесь и ниже предполагается, что ⃗x — вектор-столбец. Все основные преобразования будут записаны для этого случая. Напомним, что для того, чтобы перейти к векторам-строками и оставить описание той же самой операции, придётся транспонировать матрицы и менять порядок перемножения на обратный. Подробнее такой переход разобран в “Приложение 2. Операции над векторами”. Можно привести много примеров аффинных преобразований. Но для целей нашего курса понадобятся только три часто используемых: масштабирование, поворот и параллельный перенос. Масштабирование Масштабирование — самая простая операция. На английском языке её называют scale, поэтому и латинская буква, описывающая соответствующую матрицу, будет S. Если задан вектор ⃗v(x, y, z), то задача масштабирования — получить v⃗′ (x ′ , y′ , z′ ) такой, что x ′ = sxx, y ′ = syy, z ′ = szz. Здесь sx, sy и sz — некоторые коэффициенты. Применяя такую операцию к каждой вершине модели можно:

    Растянуть её вдоль оси, если коэффициент для неё больше единицы. Оставить без изменения при s = 1. Сжать модель вдоль оси к началу координат, если 0 ≤ s < 1. Отразить объект относительно начала координат, если s отрицательный. Записать масштабирование можно в виде следующей диагональной матрицы: S⃗v =   sx 0 0 0 sy 0 0 0 sz     x y z   =   sxx syy szz   Легко заметить, что масштабирование является линейной операцией. 51 Поворот В самом простом варианте операцию можно описать так: мир и все его объекты совершают поворот на заданный угол вокруг заданной оси. Какие будут координаты у конкретной точки относительно старой системы координат? Эта задача гораздо сложнее для восприятия, поэтому для начала рассмотрим её в двумерном пространстве. Рис. 22: Поворот на плоскости Предположим, что система координат совершает поворот против часовой стрелки на угол ϕ (см. рисунок 22). Точки (1, 0) и (0, 1) также перемещаются и приобретают координаты относительно старой системы (cos(ϕ),sin(ϕ)) и (− sin(ϕ), cos(ϕ)) соответственно. А координаты (1, 1), например, при повороте на 0.25π перейдут в (0, √ 2). В общем случае, проверяя любую другую точку, вы всё время будете получать одну и ту же закономерность: x ′ = x cos(ϕ) − y sin(ϕ), y ′ = x sin(ϕ) + y cos(ϕ), где (x ′ , y′ ) — новые координаты. Поворот на английском носит название rotation. Поэтому соответствующая матрица обозначается R. Для двумерного случая можно записать: R2⃗v =

    cos(ϕ) − sin(ϕ) sin(ϕ) cos(ϕ) x y

    52 Но чаще угол ϕ направляют в другую сторону, по часовой стрелке. Тогда аргумент следует взять с отрицательным знаком. Косинус — чётная функция, а синус — нечётная. Поэтому матрица поворота принимает вид: R ′ 2 =

    cos(ϕ) sin(ϕ) − sin(ϕ) cos(ϕ)

    Обе формы записи имеют право на существование. Нужно только сперва согласовать, в какую сторону знак угла положителен. Теперь распространим это решение на трёхмерный случай. Допустим, поворот осуществляется вокруг оси z на тот же угол ϕ. Тогда верно следующее:    x ′ = x cos(ϕ) + y sin(ϕ) y ′ = −x sin(ϕ) + y cos(ϕ) z ′ = z С помощью матрицы данную операцию можно описать так: Rz⃗v =   cos(ϕ) sin(ϕ) 0 − sin(ϕ) cos(ϕ) 0 0 0 1     x y z   Аналогично для поворота вокруг y на угол ψ: Ry =   cos(ψ) 0 sin(ψ) 0 1 0 − sin(ψ) 0 cos(ψ)   И для поворота вокруг x на θ: Rx =   1 0 0 0 cos(θ) sin(θ) 0 − sin(θ) cos(θ)   Перемножив Rx, Ry и Rz в нужном порядке, можно получить универсальную матрицу поворота сразу вокруг каждой из осей. Это предлагается сделать читателю самостоятельно. Обратите внимание, что поворот — все еще линейное преобразование. 53 Параллельный перенос (смещение) Параллельным переносом (translation) называется следующая операция: v⃗′ = ⃗v + ⃗t Она уже не является линейной, и это накладывает свои особенности. Так, для работы с трёхмерными векторами нет возможности задавать её матрицей 3 на 3. А работать с ними очень хотелось бы, тем более, что для всего остального механизм отлажен. Поэтому был придуман следующий трюк. На время выполнения операции совершается переход в четырёхмерное пространство, а после вектор возращают обратно. Для начала получим ⃗v4, дописав ему еще одну координату w: ⃗v4 =   x y z w   Добавляемая w носит название однородной координаты и по умолчанию должна быть равна единице. Операцию смещения тогда возможно записать так: T4 ⃗v4 =   1 0 0 tx 0 1 0 ty 0 0 1 tz 0 0 0 1     x y z w   =   x + txw y + tyw z + tzw w   Очевидно, что при w = 1 получаем необходимое смещение ⃗v на ⃗t. Чуть позже познакомимся с другими операциями, где также будет использоваться однородная координата. Там будут возникать ситуации, когда она отлична от единицы. Чтобы приводить вектор в порядок, придётся делить результат на его однородную координату. Но пока w всегда равна одному. Для того, чтобы иметь возможность объединить операции масштабирования, поворота и переноса, придётся и матрицы для первых двух перекинуть в четырёхмерное пространство. Так как они тоже не должны влиять на однородную координату, правило перехода принимает следующий вид: M4 =

    M3 0 0 1 Например, для матрицы масштабирования: S4 =   sx 0 0 0 0 sy 0 0 0 0 sz 0 0 0 0 1   54 Итак, получаем следующий алгоритм: Для всех вершин модели перевести ⃗v в ⃗v4, дописав однородную координату w = 1. На основе 9 параметров: sx, sy, sz, ϕ, ψ, θ, tx, ty и tz составить матрицы S, R и T. Умножить ⃗v ′ 4 = T RS ⃗v4. Достать из ⃗v ′ 4 трёхмерный v⃗′ . Для векторов-строк, очевидно, умножение будет выглядеть так: ⃗ v ′T 4 = ⃗ v T 4 S TR TT T Поэтому не смущайтесь, если в другой литературе будете встречать не те матрицы, что выведены выше, а их транспонированные версии. Это лишь другая форма записи. Но обратите внимание, что важен порядок операций. Сначала идёт масштабирование, потом поворот и после перенос. Например, если поменять местами последние две, то из-за того, что поворот осуществляется относительно центра координат, смещение будет в нём учтено. В итоге вместо того,

  4. Assistant

    создание программы на Java для удаления вершин в 3D-модели в формате OBJ можно разбить на несколько этапов. Мы будем загружать модель, удалять выбранные вершины и связанные полигоны, затем сохранять обновленную модель. Давайте рассмотрим реализацию:

    import java.io.*;
    import java.util.*;
    
    public class ObjModelEditor {
    
        static class Vertex {
            float x, y, z;
    
            Vertex(float x, float y, float z) {
                this.x = x;
                this.y = y;
                this.z = z;
            }
    
            @Override
            public String toString() {
                return String.format("v %.6f %.6f %.6f", x, y, z);
            }
        }
    
        static class Face {
            List<Integer> vertexIndices;
    
            Face(List<Integer> indices) {
                this.vertexIndices = indices;
            }
    
            @Override
            public String toString() {
                StringBuilder sb = new StringBuilder("f");
                for (int index : vertexIndices) {
                    sb.append(" ").append(index + 1); // OBJ индексирование с 1
                }
                return sb.toString();
            }
        }
    
        static class ObjModel {
            List<Vertex> vertices = new ArrayList<>();
            List<Face> faces = new ArrayList<>();
    
            void removeVertices(Set<Integer> indicesToRemove) {
                Map<Integer, Integer> indexMap = new HashMap<>();
                List<Vertex> newVertices = new ArrayList<>();
                int newIndex = 0;
    
                for (int i = 0; i < vertices.size(); i++) {
                    if (!indicesToRemove.contains(i)) {
                        newVertices.add(vertices.get(i));
                        indexMap.put(i, newIndex++);
                    }
                }
                vertices = newVertices;
    
                List<Face> newFaces = new ArrayList<>();
                for (Face face : faces) {
                    List<Integer> newFaceIndices = new ArrayList<>();
                    for (int index : face.vertexIndices) {
                        if (indexMap.containsKey(index)) {
                            newFaceIndices.add(indexMap.get(index));
                        }
                    }
                    if (newFaceIndices.size() >= 3) {
                        newFaces.add(new Face(newFaceIndices));
                    }
                }
                faces = newFaces;
            }
    
            void save(String filename) throws IOException {
                try (BufferedWriter writer = new BufferedWriter(new FileWriter(filename))) {
                    for (Vertex vertex : vertices) {
                        writer.write(vertex.toString());
                        writer.newLine();
                    }
                    for (Face face : faces) {
                        writer.write(face.toString());
                        writer.newLine();
                    }
                }
            }
    
            static ObjModel load(String filename) throws IOException {
                ObjModel model = new ObjModel();
                try (BufferedReader reader = new BufferedReader(new FileReader(filename))) {
                    String line;
                    while ((line = reader.readLine()) != null) {
                        line = line.trim();
                        if (line.startsWith("v ")) {
                            String[] parts = line.split("\\s+");
                            model.vertices.add(new Vertex(
                                    Float.parseFloat(parts[1]),
                                    Float.parseFloat(parts[2]),
                                    Float.parseFloat(parts[3])));
                        } else if (line.startsWith("f ")) {
                            String[] parts = line.split("\\s+");
                            List<Integer> indices = new ArrayList<>();
                            for (int i = 1; i < parts.length; i++) {
                                String part = parts[i].split("/")[0]; // игнорируем tex и normal индексы
                                indices.add(Integer.parseInt(part) - 1); // OBJ индексирование с 1
                            }
                            model.faces.add(new Face(indices));
                        }
                    }
                }
                return model;
            }
        }
    
        public static void main(String[] args) {
            try {
                String inputFile = "your_model.obj";
                String outputFile = "modified_model.obj";
    
                ObjModel model = ObjModel.load(inputFile);
    
                // Пример индексов вершин для удаления (начиная с 0)
                Set<Integer> indicesToRemove = new HashSet<>(Arrays.asList(0, 1, 2)); 
    
                model.removeVertices(indicesToRemove);
    
                model.save(outputFile);
    
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    

    Описание кода:

    1. Класс Vertex и Face: Представляют вершину и полигон соответственно. Класс Vertex хранит координаты вершины, а Face — список индексов вершин, формирующих полигон.

    2. Класс ObjModel: Этот класс содержит списки вершин и полигонов. Методы removeVertices и save реализуют удаление вершин и запись измененной модели в файл.

    3. Метод load: Считывает OBJ-файл, парсит информацию о вершинах и полигонах, создавая объекты Vertex и Face.

    4. Метод main: Загружает модель, удаляет указанные вершины, и сохраняет модель обратно в формате OBJ.

    Как использовать:

    • Убедитесь, что Java установлена на вашем компьютере.
    • Укажите путь к вашему OBJ-файлу в переменной inputFile.
    • Укажите индексы вершин для удаления в indicesToRemove.
    • Запустите программу, чтобы сгенерировать измененный OBJ-файл.

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

  5. User

    java.io.FileNotFoundException: your_model.obj (Не удается найти указанный файл)

  6. Assistant

    Ошибка java.io.FileNotFoundException: your_model.obj (Не удается найти указанный файл) возникает, когда программа не может найти файл your_model.obj в указанном месте. Вот несколько шагов, которые могут помочь решить эту проблему:

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

    2. Проверьте путь к файлу: Если your_model.obj находится в другом каталоге, укажите полный путь к файлу. Например:

      String inputFile = "C:\\path\\to\\your\\model.obj";
      

      или, если вы используете Unix или MacOS, путь может выглядеть так:

      String inputFile = "/path/to/your/model.obj";
      
    3. Поместите файл в корневой каталог проекта: Если вы хотите использовать относительный путь, убедитесь, что файл находится в корневом каталоге проекта, рядом с папкой src или в папке ресурсов.

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

    5. Диагностика: Выводите полные пути к файлам при отладке, чтобы видеть, где программа ищет файл:

      File file = new File(inputFile);
      System.out.println("Attempting to read from: " + file.getAbsolutePath());
      

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

    После проверки и исправления пути или местоположения файла попробуйте снова запустить программу. Если возникнут дополнительные ошибки или у вас будут ещё вопросы, дайте знать!