Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Изначально приложение Dynamo задумывалось как надстройка Revit для информационного моделирования зданий, однако со временем оно стало самостоятельным многофункциональным решением. В первую очередь Dynamo — это платформа, позволяющая проектировщикам изучать процессы визуального программирования, устранять возникающие проблемы и создавать собственные инструменты. Знакомство с приложением Dynamo следует начать с изучения того, что оно из себя представляет и как именно его можно использовать.
Dynamo — это платформа визуального программирования с открытым исходным кодом для проектировщиков.
Представляем Dynamo Primer — исчерпывающее руководство по визуальному программированию в Autodesk Dynamo. Это активный проект, целью которого является распространение сведений по основам программирования. Здесь содержатся практические советы по проектированию на основе правил, рассматриваются такие темы, как работа с вычислительной геометрией, применение программирования в различных направлениях деятельности, а также многие другие возможности платформы Dynamo.
Преимущество Dynamo заключается в широком спектре поддерживаемых операций, связанных с проектированием. Dynamo предлагает широкий спектр возможностей по началу работы.
Познакомьтесь с принципами визуального программирования.
Соедините между собой рабочие процессы из разных программ.
Участвуйте в жизни активного сообщества пользователей, программистов и разработчиков.
Разрабатывайте проект на платформе с открытым исходным кодом, чтобы способствовать его постоянному улучшению.
Чтобы не потеряться среди этих увлекательных возможностей, требуется руководство по работе с Dynamo, отвечающее потребностям пользователей на всех перечисленных уровнях, от новичков до опытных. Это и есть Dynamo Primer.
Подробные сведения о преимуществах данного руководства Primer приведены в руководстве пользователя.
Мы постоянно работаем над улучшением Dynamo, поэтому некоторые функции могут на вид отличаться от представленных в этом руководстве. Однако все функциональные изменения будут отражены наглядно и точно.
Проект Dynamo Primer открыт для всех. Мы стремимся предоставлять качественную информацию и будем рады вашим отзывам. Если вы хотите сообщить о какой-либо проблеме, опубликуйте свой вопрос на соответствующей странице GitHub: https://github.com/DynamoDS/DynamoPrimer/issues.
Если вы хотите предложить новый раздел, правки или другие изменения по этому проекту, ознакомьтесь с нашим хранилищем на GitHub: https://github.com/DynamoDS/DynamoPrimer.
Dynamo Primer — это проект с открытым исходным кодом, который был инициирован Мэттом Джезиком (Matt Jezyk) и группой по разработке Dynamo в компании Autodesk.
Первая версия этого руководства была составлена специалистами Mode Lab. Мы выражаем им благодарность за то, что положили начало этому ценному ресурсу.
Обновление этого руководства в соответствии с изменениями, внесенными в Dynamo 2.0, было выполнено Джоном Пирсоном (John Pierson) из компании Parallax Team.
Обновление этого руководства в соответствии с изменениями, внесенными в Dynamo 2.13, было выполнено специалистами Matterlab.
Обновление этого руководства в соответствии с изменениями, внесенными в Dynamo 2.17, было выполнено специалистами Archilizer.
Обновление этого руководства в соответствии с изменениями, внесенными в Dynamo for Civil 3D, было выполнено специалистами Wood Rodgers.
Выражаем особую благодарность Иэну Кио (Ian Keough) за то, что положил начало проекту Dynamo.
Мы благодарим Мэтта Йежика (Matt Jezyk), Иэна Кио (Ian Keough), Зака Крона (Zach Kron), Рэйсель Амур (Racel Amour) и Колина МакКрона (Colin McCrone) за активную совместную работу и возможность принять участие в широком спектре проектов Dynamo.
Dynamo Последнюю стабильную версию Dynamo можно найти на следующих веб-сайтах.
http://dynamobim.com/download/ или http://dynamobuilds.com
* Примечание. Начиная с версии Revit 2020, Dynamo включается в комплект установки Revit, поэтому устанавливать Dynamo вручную не требуется. Подробные сведения см. в этом блоге.
DynamoBIM. Веб-сайт DynamoBIM — это наилучшее место для получения дополнительной информации, поиска обучающих материалов и общения на форумах.
http://dynamobim.org
Страница Dynamo на GitHub. Dynamo — это проект разработки с открытым исходным кодом, размещенный на GitHub. Если вы хотите внести свой вклад в работу над ним, посетите DynamoDS.
https://github.com/DynamoDS/Dynamo
Контактная информация. Если вы обнаружите какую-либо проблему в этом документе, сообщите нам об этом.
Dynamo@autodesk.com
Copyright 2023 Autodesk
Лицензировано Apache License, Version 2.0 («Лицензия»); использовать только в совокупности с Лицензией. Копию Лицензии можно получить по следующему адресу:
http://www.apache.org/licenses/LICENSE-2.0
За исключением случаев, предусматриваемых соответствующим законом или заключенным в письменном виде соглашением, программное обеспечение, распространяемое на условиях Лицензии, распространяется «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО УСЛОВИЙ И ГАРАНТИЙ, выраженных в явной форме или подразумеваемых. Текст Лицензии содержит точные разъяснения разрешенного и запрещенного использования программных продуктов на условиях Лицензии.
Dynamo — это приложение для визуального программирования, которое можно скачать и запустить в автономном режиме «песочницы» или в качестве подключаемого модуля для другого программного обеспечения, например Revit, FormIt или Civil 3D.
Подробнее о различиях между Dynamo Core/Revit/Sandbox.
Dynamo предоставляет доступ к процессу визуального программирования, который позволяет создавать пользовательские алгоритмы путем определения связей между элементами, образующими последовательность действий. Эти алгоритмы можно применять для широкого спектра задач — от обработки данных до создания геометрии, — и все это в реальном времени без написания единой строчки code
.
Узлы и провода — это ключевые компоненты Dynamo для поддержки процесса визуального программирования. Это позволяет установить прочные визуальные и системные взаимосвязи между частями проекта. Соединение узлов щелчком мыши при разработке проекта позволяет оптимизировать рабочий процесс.
Приложение Dynamo является надежным помощником в решении самых разных задач, начиная с использования средств визуального программирования для проектирования рабочих процессов и заканчивая разработкой специализированных инструментов.
Dynamo — это активный проект разработки с открытым исходным кодом. Ознакомьтесь со
Dynamo поставляется в комплекте с таким программным обеспечением, как Revit 3D, FormIt, Civil 3D и т. д.
Дополнительные сведения об использовании Dynamo с конкретным программным обеспечением см. в следующих разделах.
Чтобы использовать Dynamo как автономное приложение, продолжите чтение статьи для ознакомления с инструкциями по скачиванию Dynamo Sandbox.
Чтобы получить предшествующую или последнюю версию, перейдите в нижний раздел на той же странице.
Новейшие разработки включают в себя новые экспериментальные возможности, которые еще не прошли полную проверку, поэтому могут функционировать нестабильно. С помощью этой версии можно обнаружить ошибки или проблемы, помочь нам улучшить приложение, сообщив о проблемах нашей команде.
Для начинающих пользователей рекомендуется официальная стабильная версия.
Перед запуском любой скачанной версии необходимо распаковать содержимое в выбранную папку.
Щелкните правой кнопкой мыши файл ZIP и выберите Извлечь все.
Выберите папку для распаковки всех файлов.
В выбранной папке дважды щелкните файл DynamoSandbox.exe, чтобы запустить его.
Отображается следующий экран запуска DynamoSandbox.
Поздравляем! Настройка DynamoSandbox завершена.
Геометрия — это дополнительная функция в Dynamo Sandbox, доступная только пользователям с действующей подпиской или лицензией на следующие программные продукты Autodesk: Revit, Robot Structural Analysis, FormIt и Civil 3D. Геометрия позволяет импортировать, создавать, редактировать и экспортировать геометрию из Dynamo Sandbox.
Пользовательский интерфейс Dynamo разделен на пять основных областей. В следующих разделах подробно рассматривается рабочее пространство и библиотека.
Меню
Панель инструментов
Библиотека
Рабочее пространство
Панель выполнения
Здесь указаны меню для основных функций приложения Dynamo. Как и в большинстве программ Windows, первые два меню связаны с управлением файлами, операциями выбора и редактированием содержимого. В остальных меню содержатся функции, присущие именно Dynamo.
Общие сведения и настройки можно найти в раскрывающемся меню Dynamo.
О программе: данные о версии Dynamo, установленной на компьютере.
Соглашение о сборе данных об использовании: возможность принять участие в обмене пользовательскими данными для улучшения работы Dynamo или отказаться от него.
Настройки: параметры, такие как точность десятичных знаков в приложении и качество визуализации геометрии.
Выход из Dynamo
При возникновении вопросов по работе программы воспользуйтесь меню Справка. Для доступа к справочным веб-сайтам Dynamo можно использовать веб-браузер.
Начало работы: краткое введение в работу с приложением Dynamo.
Интерактивные руководства.
Образцы: файлы примеров для справки.
Словарь Dynamo: ресурс с документацией по всем узлам.
Веб-сайт Dynamo: просмотр проекта Dynamo на GitHub.
Проект Dynamo Wiki: переход на страницу справки Wiki, посвященную методам разработки с помощью API Dynamo, вспомогательных библиотек и инструментов.
Показ начальной страницы: возврат на начальную страницу Dynamo при работе с документом.
Отчет об ошибке: создание инцидента на веб-сайте GitHub.
Панель инструментов Dynamo содержит ряд кнопок для быстрого доступа к файлам, а также команды «Отменить» [CTRL+Z] и «Повторить [CTRL+Y]». Справа находится еще одна кнопка, с помощью которой можно экспортировать снимок рабочего пространства, что часто требуется при работе с документацией и совместном использовании данных.
Обеспечивает запуск сценария Dynamo. Щелкните значок раскрывающегося списка на кнопке «Выполнение», чтобы переключиться между различными режимами.
«Автоматически»: сценарий запускается автоматически. Изменения применяются в реальном времени.
«Вручную»: сценарий выполняется только при нажатии кнопки «Запуск». Используется при внесении изменений в сложный и крупный сценарий.
«Периодически»: по умолчанию этот параметр неактивен. Он становится доступен только при использовании узла DateTime.Now. С его помощью можно настроить автоматическое выполнение сценария с заданным интервалом.
Рабочее пространство Dynamo состоит из четырех основных элементов.
Все активные вкладки
Режим предварительного просмотра
Элементы управления масштабированием/панорамированием
Узел в рабочем пространстве
При открытии нового файла по умолчанию открывается новое исходное рабочее пространство.
Можно создать пользовательский узел и открыть его в рабочем пространстве пользовательского узла.
В каждом окне Dynamo можно использовать только одно исходное рабочее пространство, однако на вкладках можно открыть несколько рабочих пространств пользовательского узла.
Существует три способа переключения между режимами предварительного просмотра.
a. Использование значков в верхней части экрана справа
b. Щелчком правой кнопкой мыши в рабочем пространстве
Переключение из режима 3D-просмотра в режим предварительного просмотра графика
Переключение из режима предварительного просмотра графика в режим 3D-просмотра
c. С помощью горячей клавиши (CTRL + B)
Для навигации в любом рабочем пространстве можно использовать значки или мышь.
a. В режиме Предварительный просмотр графика
Использование значков:
Использование мыши:
Щелчок левой кнопкой мыши — выбор
Щелчок левой кнопкой мыши и перетаскивание — выбор нескольких точек
Прокрутка колесика вперед/назад — увеличение/уменьшение
Перетаскивание с удерживаемой средней кнопкой мыши — панорамирование
Щелчок правой кнопкой мыши в любом месте активного окна — открытие окна поиска в активном окне
b. В режиме 3D-просмотра
Использование значков:
Использование мыши:
Прокрутка колесика вперед/назад — увеличение/уменьшение
Перетаскивание с удерживаемой средней кнопкой мыши — панорамирование
Щелчок правой кнопкой мыши и перетаскивание — вращение
Щелкните левой кнопкой мыши, чтобы выбрать какой-либо узел.
Чтобы выбрать несколько узлов, щелкните и перетащите указатель для создания рамки выбора.
Чтобы начать работу, запустите данную программу на панели инструментов. В зависимости от используемого программного обеспечения, значок запуска обычно находится на вкладке «Меню» > Управление. Щелкните значок Dynamo , чтобы запустить программу.
Приложение Dynamo доступно на . Официальные, предыдущие и предварительные версии доступны на странице загрузки. Перейдите на страницу и нажмите кнопку Загрузить, чтобы получить официальную версию.
Скачайте и установите на компьютер программу для выполнения этого шага.
«Создать»: создание нового файла DYN.
«Открыть»: открытие существующего файла DYN (рабочее пространство) или DYF (пользовательский узел).
«Сохранить»/«Сохранить как»: сохранение активного файла DYN или DYF.
«Отменить»: отмена последнего действия.
«Повторить»: повтор действия.
«Экспорт рабочего пространства в виде изображения»: экспорт видимого рабочего пространства в виде файла PNG.
Библиотека Dynamo — это набор функциональных библиотек, каждая из которых содержит узлы, сгруппированные по категориям. Она содержит базовые библиотеки, которые добавляются при установке Dynamo по умолчанию. В рамках этой процедуры мы продолжим знакомство с ее использованием. Мы рассмотрим, как расширить базовые функции с помощью пользовательских узлов и дополнительных пакетов. В разделе содержатся подробные инструкции по использованию.
Рабочее пространство позволяет создавать визуальные программы и изменять настройки предварительного просмотра для отображения 3D-геометрии. Дополнительные сведения см. в разделе .
Предварительный просмотр графика
Предварительный 3D-просмотр
Вписать
Увеличить
Уменьшить
Панорамирование
Вписать
Увеличить
Уменьшить
Панорамирование
Орбита
В этом разделе рассматриваются основные узлы, доступные в библиотеке Dynamo, которые помогут создать собственную визуальную программу на профессиональном уровне.
Геометрия для вычислительного проектирования: принципы работы с геометрическими элементами в Dynamo. Изучите несколько способов создания простых или сложных геометрий на основе примитивов.
Компоновочные блоки программ: сведения о том, что такое данные и каковы основные типы данных, которые можно использовать в программе. Узнайте больше о том, как внедрять математические и логические операции в рабочий процесс проектирования.
Проектирование на основе списков: сведения о том, как управлять структурами данных и координировать их. Узнайте больше о понятии списка и используйте его для эффективного управления проектными данными.
Словари в Dynamo: сведения о том, что такое словари. Узнайте, как использовать словари для поиска конкретных данных и значений из набора существующих результатов.
Данное руководство включает главы, составленные Mode Lab. В этих главах основное внимание уделяется принципам, которые позволят вам приступить к разработке собственных визуальных программ в Dynamo, а также полезным советам по повышению эффективности использования Dynamo.
Данное руководство предназначено для пользователей с самыми разными навыками и опытом. В указанных ниже разделах можно найти общие сведения о настройке Dynamo, пользовательском интерфейсе и ключевых понятиях. Начинающим пользователям рекомендуется изучить следующие темы:
Для более глубокого понимания каждого элемента, например конкретных узлов и понятий, лежащих в их основе, представлена отдельная глава.
Для ознакомления с рабочими процессами Dynamo мы добавили несколько графиков в раздел «Примеры рабочих процессов». При создании собственных графиков Dynamo следуйте прилагаемым инструкциям.
В последующих главах, посвященных Dynamo, рассматриваются более специализированные упражнения. Упражнения обычно приводятся в последнем разделе на каждой странице.
То, чем Dynamo является сегодня, — во многом заслуга постоянного круга активных пользователей и профессиональных программистов, помогающих приложению развиваться. Станьте участником нашего сообщества: читайте блог, публикуйте результаты своей работы в галерее или обсуждайте Dynamo с другими пользователями на форуме.
Приложение Dynamo задумывалось как средство визуального программирования для проектировщиков, в котором можно создавать инструменты для работы с внешними библиотеками или любой программой Autodesk с API. Dynamo Sandbox позволяет создавать программы в среде песочницы, но экосистема, в которой существует Dynamo, постоянно пополняется и расширяется.
Исходный код проекта является открытым, благодаря чему расширять функциональность приложения можно настолько, насколько хватит фантазии. Посетите страницу проекта Dynamo на сайте GitHub и просмотрите текущие проекты пользователей, занимающихся адаптацией Dynamo.
Просматривайте интересные проекты, создавайте Fork-копии и адаптируйте Dynamo под свои потребности.
Библиотека содержит все загруженные узлы, включая десять узлов по умолчанию, входящих в установочный пакет, а также все дополнительно загруженные пользовательские узлы и пакеты. Узлы в библиотеке организованы иерархически в виде библиотек, категорий и подкатегорий (если это необходимо).
Основные узлы: входят в установку по умолчанию.
Пользовательские узлы: сохраняйте часто используемые процедуры или специальные графики в качестве пользовательских узлов. Ими также можно поделиться с сообществом.
Узлы из Package Manager: коллекция опубликованных пользовательских узлов.
Мы рассмотрим иерархические категории узлов, способ быстрого поиска узлов в библиотеке, а также некоторые из часто используемых узлов.
Обзор узлов по категориям позволяет быстро разобраться в иерархии узлов, которые требуется добавить в рабочее пространство, а также найти узлы, которыми вы еще не пользовались.
Откройте библиотеку, щелкнув меню, чтобы развернуть каждую категорию и ее подкатегорию.
Начинать знакомство с программой рекомендуется с меню Geometry, так как в них представлено наибольшее количество узлов.
Библиотека
Категория
Подкатегория
Узел
Далее внутри подкатегории выполняется распределение узлов в зависимости от их функции: создание данных, выполнение действия или запрос данных.
Наведите указатель на узел, чтобы посмотреть подробные сведения, помимо его имени и значка. Такие подсказки позволяют быстро определить функции, выполняемые узлом, какие данные ему требуются на входе, и что он выдает на выходе.
Описание: описание узла на обычном языке.
Значок: увеличенная версия значка, используемого в меню библиотеки.
Входные данные: наименование, тип и структура данных.
Выходные данные: наименование, тип и структура данных.
Если вам с относительной точностью известно, какой узел необходимо добавить в рабочее пространство, введите ключевые слова в поле Поиск, чтобы найти все соответствующие узлы.
Щелчком выберите необходимый узел или нажмите клавишу ENTER, чтобы добавить выделенные узлы в центр рабочего пространства.
Поиск узлов можно выполнять не только по ключевым словам, но и по иерархии, разделяя ее уровни точкой в поле поиска, или с помощью узлов Code Block (в которых используется текстовый язык Dynamo).
Иерархия каждой библиотеки отражается в имени узлов, добавляемых в рабочее пространство.
При вводе тех или иных фрагментов расположения узла в библиотечной иерархии в формате library.category.nodeName
отображаются различные результаты.
library.category.nodeName
category.nodeName
nodeName
или keyword
В рабочем пространстве имя узла обычно представлено в формате category.nodeName
. Есть некоторые исключения, в частности, узлы категорий Input и View.
Соблюдайте осторожность при использовании узлов с одинаковыми именами и обращайте особое внимание на различия в категориях, к которым они относятся.
Узлы из большинства библиотек содержат формат категории.
Узлы Point.ByCoordinates
и UV.ByCoordinates
имеют одинаковое имя, но относятся к разным категориям.
К исключениям относятся встроенные функции, узлы Core.Input, Core.View и логические операторы.
В базовый комплект установки приложения Dynamo входят сотни узлов. Какие из них наиболее важны при разработке визуальных программ? Рассмотрим узлы, которые позволяют определить параметры программы (Input), отображать результаты действия, выполняемого тем или иным узлом (Watch), и задавать входные данные или функции с помощью горячей клавиши (Code Block).
Узлы Input — это ключевой инструмент, благодаря которому пользователи визуальных программ могут работать с основными параметрами. Ниже перечислены некоторые узлы, доступные в основной библиотеке.
Логический
Количество
String
Number Slider
Directory Path
Integer Slider
File Path
Узлы Watch играют важную роль в управлении потоком данных в визуальной программе. Результат работы узла можно увидеть в окне предварительного просмотра данных узла, наведя курсор на узел.
Элемент удобно просматривать в узле Watch.
Кроме того, результаты геометрии можно просмотреть с помощью узла Watch3D.
Оба этих узла находятся в категории видов основной библиотеки.
Совет. Иногда при работе с большим количеством узлов пользоваться функцией 3D-просмотра может быть неудобно. В этом случае можно снять флажок фонового просмотра в меню «Параметры» и использовать узел Watch3D для предварительного просмотра геометрии.
Узлы Code Block позволяют создавать блоки кода, состоящие из строк, разделенных запятыми. Это так же просто, как и с узлом X/Y
.
Кроме того, узлы Code Block можно использовать как горячую клавишу для ввода чисел или вызова другой функции узла. Для этого используется синтаксис, соответствующий соглашению об именовании для текстового языка Dynamo — DesignScript.
Ниже приведен простой пример (с инструкциями) по использованию Code Block в сценарии.
Дважды щелкните мышью для создания узла Code Block.
Введите Circle.ByCenterPointRadius(x,y);
.
Щелкните в рабочем пространстве, чтобы отменить выбор и автоматически добавить входные порты x
и y
.
Создайте узлы Point.ByCoordinates и Number Slider, затем соедините их с портами ввода в узле Code Block.
Результат выполнения визуальной программы отображается в виде окружности в окне 3D-просмотра.
Dynamo — это среда визуального программирования, которая позволяет пользователям создавать процессы обработки данных. Данные — это числа или текст. Но это также и геометрия. С точки зрения компьютера, геометрия (иногда ее также называют вычислительной геометрией) — это данные, которые можно использовать для создания эстетичных, детализированных или высокопроизводительных моделей. Для этого нужно сначала внимательно изучить различные типы геометрии, доступные для использования.
Узлы Dynamo — это объекты, путем соединения которых создается визуальная программа. Каждый узел выполняет ту или иную операцию. Это может быть как простая операция, например хранение числа, так и более сложная, например создание или запрос геометрического объекта.
Большинство узлов Dynamo состоит из пяти частей. За некоторыми исключениями (например, входные узлы) в большинстве своем узлы имеют следующую структуру.
Имя: имя узла, имеющее формат
Category.Name
.Основная часть узла: если щелкнуть ее правой кнопкой мыши, отобразятся параметры, действующие на уровне узла.
Порты (ввода и вывода): разъемы для проводов, передающих входные данные для узла, а также результаты выполненной узлом операции.
Значение по умолчанию: щелкните порт ввода правой кнопкой мыши. Для некоторых узлов заданы значения по умолчанию, которые можно использовать или игнорировать.
Порты — это вводы и выводы узлов, играющие роль разъемов для проводов. В порты, расположенные слева, поступают входящие данные, а из портов, расположенных справа, передаются далее результаты выполненной операции.
Каждый порт рассчитан на прием данных определенного типа. Если соединить с портами узла Point.ByCoordinates число, например 2.75, то операция выполнится успешно и будет создана точка. Но если вместо числа соединить с тем же портом текстовое значение, например Red, это приведет к ошибке.
Совет. Наведите курсор на порт, чтобы увидеть подсказку о требуемом типе данных.
Метка порта
Подсказка
Тип данных
Значение по умолчанию
Для демонстрации состояния выполнения операций в узлах визуальной программы в Dynamo используются разные цвета. Иерархия состояний определяется следующим образом: ошибка > предупреждение > информация > просмотр.
Если навести курсор на имя или порты, либо щелкнуть их правой кнопкой мыши, отобразятся дополнительные сведения и параметры.
Соответствующие входные данные: если над входными портами узла отображаются синие вертикальные полосы, это означает, что узел правильно подключен, и в него поступают входные данные нужного типа.
Несоответствующие входные данные: если над одним или несколькими входными портами узла отображается красная вертикальная полоса, нужно подключить эти порты так, чтобы в них поступали входные данные нужного типа.
Функция: это узел, выводом которого является функция и порт вывода которого помечен серой вертикальной полосой.
Выбранный: выбранные узлы выделяются голубой рамкой по периметру.
Замороженный: замороженными являются полупрозрачные синие узлы, и выполнение операций таких узлов приостановлено.
Предупреждение: желтый цвет строки состояния под узлом указывает на состояние предупреждения. Это значит, что в узле отсутствуют входные данные либо используются неверные типы данных.
Ошибка: красный цвет строки состояния под узлом указывает на то, что в узле произошла ошибка.
Сведения: синий цвет строки состояния под узлом указывает на информационное состояние, которое обозначает наличие полезных сведений об узлах. Переход к этому состоянию может быть вызван значением, близким к максимальному значению, поддерживаемому узлом, либо таким использованием узла, при котором может пострадать производительность, и т. д.
Совет. Используя информацию из подсказки, проверьте узлы, предшествующие текущему, на наличие ошибок в типе или структуре требуемых данных.
Подсказка с предупреждением: не указанные данные или значение Null не могут использоваться как данные типа Double (то есть, число).
Используйте узел Watch, чтобы просмотреть входные данные.
Узел Number, предшествующий текущему, передает на выходе текстовое значение Red, а не число.
В некоторых случаях может потребоваться предотвратить выполнение операций определенных узлов в визуальной программе. Это можно сделать, заморозив узел. Этот параметр доступен в контекстном меню узла.
При замораживании узла также замораживаются следующие за ним узлы. Другими словами, все узлы, которые зависят от вывода замороженного узла, также будут заморожены.
Провода соединяют друг с другом узлы, создавая тем самым связи и обеспечивая поток выполнения операций в рамках визуальной программы. Их можно воспринимать как настоящие электрические провода, передающие заряды (данные) от одного объекта к другому.
Каждый провод соединяет порт вывода одного узла с портом ввода другого. Такой порядок подключения определяет направление потока данных в визуальной программе.
Порты ввода находятся слева от узлов, а порты вывода — справа, поэтому можно сказать, что поток выполнения операций в программе направлен слева направо.
Для создания провода нужно щелкнуть сначала порт одного узла, а затем порт другого узла, чтобы установить соединение. В процессе создания соединения провод отображается пунктирной линией, после чего становится сплошным.
Данные всегда проходят по проводам в направлении от вывода к вводу, однако последовательность выбора соединяемых портов не играет роли и может быть любой.
Зачастую при работе над визуальной программой возникает необходимость в корректировке потока выполнения операций путем редактирования проводов, играющих роль соединительных элементов. Чтобы отредактировать провод, щелкните порт ввода подсоединенного узла. Далее выберите один из следующих вариантов:
Чтобы изменить подключение к порту ввода, щелкните другой порт ввода.
Чтобы удалить провод, перетащите его в сторону от узла, а затем щелкните в рабочем пространстве.
Чтобы повторно соединить несколько проводов, щелкните нужные элементы при нажатой клавише SHIFT.
Чтобы дублировать провод, щелкните нужный элемент при нажатой клавише CTRL.
По умолчанию провода отображаются при просмотре как серые прерывистые линии. При выборе узла все подключенные к нему провода выделяются голубым цветом, как и сам узел.
Выделенный провод
Провод по умолчанию
Скрытие проводов по умолчанию
Если требуется скрыть провода на графике, снимите флажок «Показать соединители» в меню «Просмотреть» > «Соединители».
В данном случае бледно-голубым цветом будут отображаться только выбранные узлы и соединенные с ними провода.
Чтобы скрыть только выбранный провод, щелкните правой кнопкой мыши вывод узла и выберите «Скрыть провода».
Геометрия — это язык, на котором осуществляется разработка. Если в основе языка или среды программирования лежит геометрия, это открывает широкие возможности для создания точных и надежных моделей, автоматизации процессов разработки и итерации проектов на основе алгоритмов.
Зная типы геометрии и то, , можно легко ориентироваться в наборе узлов Geometry, доступных в библиотеке. Узлы Geometry располагаются в алфавитном порядке, а не по иерархическому принципу. Здесь они отображаются примерно так же, как и в интерфейсе Dynamo.
Кроме того, эти знания позволят упростить и сделать более понятым процесс создания моделей в Dynamo, а также соотнесение потока данных в графике с изображением в области предварительного просмотра.
Обратите внимание на предполагаемую систему координат, представленную сеткой и цветными осями.
Выбранные узлы визуализируют соответствующую геометрию (если узел создает геометрию) в фоновом режиме.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
В обычном понимании геометрия — это исследование формы, размера, относительного положения фигур и свойств пространства. Эта дисциплина имеет богатую историю, берущую свое начало тысячи лет назад. Благодаря появлению компьютеров мы получили мощный инструмент для описания, изучения и генерирования геометрических объектов. В настоящее время можно с легкостью рассчитать сложнейшие геометрические взаимодействия, и ни для кого не секрет, что мы активно используем эти возможности.
Если вы хотите узнать, насколько разнообразной и сложной может быть геометрия, разрабатываемая с помощью компьютеров, введите словосочетание «Стенфордский кролик» в любой поисковой системе. Это каноническая модель, которая используется для тестирования алгоритмов.
Перспектива применения геометрии в контексте алгоритмов, компьютерных вычислений и повышенной сложности может показаться пугающей. Однако есть несколько относительно простых ключевых принципов, освоив которые, мы сможем приступить к изучению более сложных вариантов применения геометрии.
Геометрия —это данные, поэтому с точки зрения компьютера и приложения Dynamo геометрический кролик практически ничем не отличается от обычного числа.
Геометрия основана на абстракции: по сути, все геометрические элементы описываются с помощью чисел, отношений и формул в заданной пространственной системе координат.
Геометрия имеет иерархию: точки образуют линии, линии образуют поверхности и т. д.
Геометрия одновременно описывает часть и целое: если есть кривая, то она представляет собой и форму, и все возможные точки вдоль нее.
На практике эти принципы означают, что пользователи должны понимать, над чем они работают (тип геометрии, как она была создана и т. д.). Это понимание позволит нам с легкостью конструировать, разбирать и снова собирать различные геометрические объекты в ходе разработки сложных моделей.
Давайте рассмотрим геометрию с точки зрения принципов абстракции и иерархии. Хоть это и не всегда очевидно, эти принципы тесно взаимосвязаны, и если в этом не разобраться, то при разработке детализированных рабочих процессов и моделей можно столкнуться с серьезным препятствием. Для начала давайте воспользуемся понятием пространственным измерений в качестве основной характеристики моделируемых нами объектов. Зная количество измерений, необходимых для описания формы, мы сможем приблизиться к пониманию иерархического устройства геометрии.
Точка (определяемая координатами) не имеет измерений. Она описывается только числами, соответствующими каждой из координат.
Отрезок (определяемый двумя точками), в свою очередь, имеет одно измерение: мы можем перемещаться вдоль отрезка вперед (положительное направление) и назад (отрицательное направление).
Плоскость (определяемая двумя линиями) имеет два измерения: мы можем перемещаться не только вперед и назад, но и влево или вправо.
Параллелепипед (определяемый двумя плоскостями) имеет три измерения: в дополнение к указанному выше, мы можем перемещаться вверх и вниз.
Пространственные измерения — это удобный способ классификации геометрический объектов, но не всегда самый лучший. В конце концов, при моделировании используются не только точки, отрезки, плоскости и параллелепипеды. Что, если нужен изогнутый объект? Кроме этого, существует еще одна категория геометрических типов, которые являются полностью абстрактными: они определяют такие свойства, как ориентация, объем или связи между отдельными частями объекта. Такой объект, как вектор, например, абсолютно неосязаем. Так как же описать его относительно того, что мы видим в пространстве? Нужна более подробная классификация иерархии геометрических объектов, которая должна отражать разницу между абстрактными типами (вспомогательными средствами), которые можно сгруппировать по выполняемой ими функции, и типами, которые используются для описания формы элементов модели.
Создание моделей в Dynamo не ограничено объектами, которые можно создать с помощью узлов. Есть несколько способов расширить возможности использования геометрии.
Dynamo позволяет импортировать файлы: используйте файлы CSV для создания облаков точек или файлы SAT для добавления поверхностей.
При работе с Revit можно ссылаться на элементы Revit, чтобы использовать их в Dynamo.
В этом указателе представлена дополнительная информация обо всех узлах, используемых в учебнике, а также о других компонентах, которые могут оказаться полезными. Это лишь краткое описание некоторых из 500 узлов Dynamo.
** Другими словами, при создании кубоида длиной 10 по ширине (ось X) и преобразовании его в систему координат с 2-кратным масштабированием по оси X, его ширина останется равной 10. ASM не позволяет извлекать вершины тела в каком-либо предсказуемом порядке, поэтому после преобразования определить размеры невозможно.
— это представление величины и направления. Его можно изобразить в виде стрелки, которая движется в определенном направлении с заданной скоростью. Векторы являются ключевым компонентом при разработке моделей в Dynamo. Обратите внимание, что поскольку они относятся к категории вспомогательных средств, то при создании векторы не отображаются в области фонового просмотра.
В качестве замены вектору в области предварительного просмотра можно использовать отрезок.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
Хотя плоскости являются абстрактными, они имеют исходную точку, что позволяет определить их положение в пространстве.
В Dynamo плоскости визуализируются в области фонового просмотра.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
Хотя системы координат являются абстрактными, они имеют исходную точку, что позволяет определить их положение в пространстве.
В Dynamo системы координат визуализируются в области фонового просмотра в виде точки (начало координат) и линий, определяющих оси (согласно принятым нормам, ось X обозначается красным цветом, Y — зеленым, а Z — синим).
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
Векторы, плоскости и системы координат составляют основную группу абстрактных типов геометрии. Они помогают задавать расположение, ориентацию и пространственный контекст для других геометрических объектов, определяющих формы. Представим себе человека, который находится в Нью-Йорке на пересечении 42-й улицы и Бродвея (система координат), стоит на тротуаре (плоскость) и смотрит на север (вектор). Мы только что описали местонахождение человека с помощью вспомогательных абстрактных средств. Таким же образом можно задать местонахождение любого объекта, от чехла телефона до небоскреба. Это контекст, необходимый для разработки любой модели.
Вектор — это геометрическая величина, описывающая направление и величину. Векторы являются абстрактными, т. е. они представляют собой некоторую величину, а не геометрический элемент. Векторы легко спутать с точками, поскольку они также состоят из списка значений. Однако существует одно важное отличие: точки описывают положение в заданной системе координат, а векторы описывают относительную разницу в положении, что аналогично понятию направления.
Если идея относительной разницы не вполне ясна, представьте, что вектор AB означает следующее: вы стоите в точке A и смотрите в точку B. Направление от одной точки (A) до другой (B) и будет вектором.
Рассмотрим подробнее структуру векторов на примере вектора AB.
Начальная точка вектора называется его началом.
Конечная точка вектора называется его концом или направлением.
Вектор AB и вектор BA — это два разных вектора, поскольку они указывают в противоположных направлениях.
Чтобы отдохнуть от слишком формальных и абстрактных определений вектора и посмеяться, посмотрите классическую комедию «Аэроплан!» (Airplane!), где есть следующая знаменитая цитата:
Roger, Roger. What's our vector, Victor? (Роджер, Роджер. Каков наш вектор, Виктор?)
Плоскости являются двумерной абстрактной вспомогательной геометрией. Плоскости по определению являются «плоскими» и бесконечно расширяются в двух направлениях. Обычно они визуализируются в виде небольшого прямоугольника в начале координат.
Но постойте, скажете вы. Начало координат? Как в системе координат, которая используется для моделирования в САПР?
Совершенно верно. В большинстве программ моделирования используются плоскости построения, или «уровни», с помощью которых определяется локальный двумерный контекст для создания черновиков чертежей. XY, XZ, YZ или, возможно, более знакомые вам «север», «юго-восток», «план» — все это плоскости, определяющие бесконечный «плоский» контекст. Плоскости не имеют глубины, но они помогают описать направление.
Если мы с вами освоили плоскости, то разобраться с системами координат нам не составит труда. Плоскость состоит из тех же компонентов, что и система координат, при условии что это стандартная евклидова система координат или система координат XYZ.
Однако имеются и другие альтернативные системы координат, например цилиндрические или сферические. Как будет показано в следующих разделах, системы координат можно также применять к другим типам геометрии для указания положения в пределах этой геометрии.
Можно добавить альтернативные системы координат — цилиндрические и сферические.
определяется одним или несколькими значениями, которые называют координатами. Количество значений координат, необходимых для определения точки, зависит от системы координат или контекста, в котором она находится.
Самый распространенный тип точки в Dynamo существует в трехмерной мировой системе координат и имеет три координаты: [X,Y,Z] (3D-точка в Dynamo).
2D-точка в Dynamo имеет две координаты — [X,Y].
Параметры кривых и поверхностей являются непрерывными и выходят за пределы заданной геометрии. Поскольку формы, определяющие параметрическое пространство, находятся в трехмерной мировой системе координат, параметрическую координату можно всегда легко преобразовать в «мировую». Например, точка [0.2, 0.5] на поверхности соответствует точке [1.8, 2.0, 4.1] в системе мировых координат.
Точка в предполагаемой системе мировых координат XYZ.
Точка, представленная относительно заданной системы координат (цилиндрической).
Точка, представленная координатами UV на поверхности.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
Если геометрия — это язык модели, то точки — ее алфавит. Точки являются основой для создания всех прочих объектов геометрии. Для создания кривой требуется не менее двух точек, для создания полигона или грани сети — не менее трех и т. д. Определение положения, порядка и связей между точками (например, с помощью функции синуса) позволяет работать с геометрией более высокого порядка, в том числе с такими элементами, как окружности или кривые.
Окружность, построенная с помощью функций
x=r*cos(t)
иy=r*sin(t)
.Синусоидальная кривая, построенная с помощью функций
x=(t)
иy=r*sin(t)
.
Точки также могут существовать в двумерной системе координат. В зависимости от типа рабочего пространства, могут использоваться различные буквенные обозначения — [X,Y] на плоскости или [U,V] на поверхности.
Точка в евклидовой системе координат: [X,Y,Z]
Точка в системе координат параметров кривой: [t]
Точка в системе координат параметров поверхности: [U,V]
в модели используется для представления объектов, которые мы видим в нашем трехмерном мире. Несмотря на то, что кривые не всегда являются плоскими и по сути трехмерны, пространство, определяемое ими, всегда является одномерным. Поверхности позволяют придать модели дополнительное измерение, а также включают набор специальных свойств, которые можно использовать при выполнении других операций моделирования.
Импортируйте в Dynamo и проанализируйте объект Surface в конкретном параметре, чтобы узнать, какие сведения можно извлечь.
Surface.PointAtParameter возвращает объект Point в заданной координате UV.
Surface.NormalAtParameter возвращает вектор нормали в заданной координате UV.
Surface.GetIsoline возвращает изопараметрическую кривую в координате U или V (обратите внимание на порт ввода isoDirection).
Скачайте файлы примеров, щелкнув ссылку ниже.
Полный список файлов примеров можно найти в приложении.
Поверхность — это математическая форма, определяемая функцией и двумя параметрами. Вместо параметра t
, используемого для кривых, здесь для описания соответствующего пространства используются параметры U
и V
. Это означает, что при работе с геометрией этого типа появляются дополнительные данные для использования. Например, у кривых есть касательные векторы и плоскости нормали (которые могут поворачиваться или скручиваться вдоль кривой), а у поверхностей есть векторы нормали и касательные плоскости с последовательной ориентацией.
Поверхность
Изолиния U
Изолиния V
Координата UV
Перпендикулярная плоскость
Вектор нормали
Область поверхности: определяется как диапазон параметров (U,V), каждый из которых соответствует трехмерной точке на этой поверхности. Область в каждом измерении (U или V) обычно описывается двумя числами: (от U мин. до U макс.) и (от V мин. до V макс.).
Хотя поверхность может не выглядеть как прямоугольник, а некоторые ее участки могут отличаться более или менее плотным расположением изолиний, «пространство», определяемое областью поверхности, всегда является двумерным. В Dynamo всегда подразумевается, что область поверхности определяется диапазоном значений U и V, где минимальное значение равно 0.0, а максимальное — 1.0. У плоских или обрезанных поверхностей могут быть разные области.
Изолиния (или изопараметрическая кривая): кривая, определяемая постоянным значением для одного направления (U или V) на поверхности и областью значений для другого направления (V или U, соответственно).
Координата UV: точка в пространстве параметров UV, определяемая значениями U, V и иногда W.
Перпендикулярная плоскость: плоскость, перпендикулярная изолиниям U и V в заданной координате UV.
Вектор нормали: вектор, определяющий направление «вверх» относительно перпендикулярной плоскости.
Поверхности NURBS очень похожи на NURBS-кривые. Такую поверхность можно представить в виде сетки из NURBS-кривых, идущих в двух направлениях. Форма поверхности NURBS определяется набором управляющих точек и степенью сглаживания этой поверхности в направлениях U и V. Те же алгоритмы используются для вычисления формы, нормалей, касательных, кривизны и других свойств с помощью управляющих точек, весов и степени сглаживания.
В случае с поверхностями NURBS для геометрии подразумеваются два направления, поскольку эти поверхности являются прямоугольными сетками из управляющих точек, хотя они могут выглядеть совсем по-другому. Эти направления во многих случаях задаются произвольным образом на основе мировой системы координат, однако они часто используются для анализа моделей или создания других геометрических объектов на основе поверхности.
Степень сглаживания (U,V) = (3,3)
Степень сглаживания (U,V) = (3,1)
Степень сглаживания (U,V) = (1,2)
Степень сглаживания (U,V) = (1,1)
Полиповерхности состоят из нескольких поверхностей, кромки которых соединены. Полиповерхности обеспечивают более детализированные сведения, нежели простое двумерное определение UV, благодаря чему их можно использовать для перехода по соединенным формам посредством их топологии.
Термин «топология» в большинстве случаев используется для обозначения того, как различные элементы связаны и взаимодействуют друг с другом. В Dynamo топология (Topology) также является типом геометрии. Topology является родительской категорией таких объектов, как поверхности (Surface), полиповерхности (Polysurface) и тела (Solid).
Объединение поверхностей таким образом (иногда называемое замыканием) позволяет создавать более сложные формы, а также детализировать стыки. К кромкам объекта Polysurface можно применять операции сопряжения или фаски.
Для создания сложных моделей, которые невозможно получить из одной поверхности, или определения явного объема необходимо научиться работе с (и полиповерхностями). Даже для самого простого куба требуется целых шесть поверхностей, по одной на каждую грань. Тела позволяют получить доступ к двум ключевым концепциям, не доступным при работе с поверхностями, а именно к уточненным топологическим описаниям (граням, кромкам, вершинам) и логическим операциям.
Для изменения тел применяются . Попробуйте использовать несколько логических операций для создания шара с шипами.
Sphere.ByCenterPointRadius: создание базового объекта тела Solid.
Topology.Faces, Face.SurfaceGeometry: запрос граней тела и преобразование в геометрию поверхности (в данном случае сфера имеет только одну грань).
Cone.ByPointsRadii: построение конусов, используя точки на поверхности.
Solid.UnionAll: объединение конусов со сферой.
Topology.Edges: запрос кромок нового объекта Solid.
Solid.Fillet: сглаживание кромок шара с шипами.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
Логические операции сложны, и их вычисление может занимать много времени. Замораживание можно использовать, чтобы приостановить выполнение операций в выбранных узлах, а также следующих за ними узлах.
1. Используйте контекстное меню, чтобы «заморозить» операцию объединения тел.
2. Выбранный узел и все следующие за ним узлы отображаются светло-серым полупрозрачным цветом, а все затронутые провода отображаются в виде прерывистых линий. Предварительный просмотр соответствующей геометрии также будет полупрозрачным. Теперь можно изменить значения в узлах, предшествующих выбранному, не перегружая приложение расчетом логической операции объединения.
3. Чтобы разморозить узлы, щелкните правой кнопкой мыши и снимите флажок «Заморозить».
4. Все затронутые узлы и изображения предварительного просмотра связанных геометрических объектов обновляются и возвращаются к стандартному виду.
Тела состоят из одной или нескольких поверхностей, внутри которых заключен объем, определенный замкнутым контуром, который отделяет то, что внутри тела, от того, что снаружи. Независимо от количества используемых поверхностей, для того чтобы объект считался телом, содержащийся в нем объем должен быть полностью замкнутым. Тела можно создавать путем объединения поверхностей или полиповерхностей либо с помощью таких операций, как лофтинг, сдвиг и вращение. Такие примитивы, как сфера, куб, конус и цилиндр, также являются телами. Объект Cube, у которого отсутствует хотя бы одна грань, считается полиповерхностью, которая уже не является телом, хотя и обладает многими аналогичными свойствами.
Плоскость состоит из одной поверхности и не является телом.
Сфера состоит из одной поверхности и является телом.
Конус состоит из двух соединенных поверхностей и является телом.
Цилиндр состоит из трех соединенных поверхностей и является телом.
Куб состоит из шести соединенных поверхностей и является телом.
Элементы, из которых состоят тела, делятся на три типа: вершины, кромки и грани. Грани — это поверхности, образующие тело. Кромки — это кривые, обозначающие области соединения смежных граней, а вершины — это начальные и конечные точки этих кривых. Эти элементы можно запросить с помощью узлов Topology.
Грани
Кромки
Вершины
Тела можно изменять путем применения скруглений и фасок к кромкам, чтобы тем самым сгладить острые углы. Операция фаски создает поверхность соединения между двумя гранями, а операция сопряжения сглаживает переход между гранями для сохранения касательности.
Твердотельный куб
Куб с фасками
Скругленный куб
Логические операции для тел — это методы, позволяющие объединить несколько тел в одно. Каждая логическая операция включает в себя четыре операции:
Пересечение двух или более объектов.
Разделение их в местах пересечения.
Удаление ненужных частей геометрии.
Объединение оставшихся частей.
Объединение: несколько тел объединяются в одно с удалением перекрывающихся частей.
Разность: одно тело вычитается из другого. Тело, которое вычитается, называется инструментом. Обратите внимание, что для сохранения обратного объема вычитаемое и подвергающееся вычитанию тела можно поменять местами.
Пересечение: при пересечении сохраняются только перекрывающиеся части двух тел.
UnionAll: операция объединения для сферы и повернутых наружу конусов.
DifferenceAll: операция разности для сферы и повернутых внутрь конусов.
Create: создание или построение геометрии с нуля. Например, окружности.
Action: выполнение действия с объектом. Например, масштабирование окружности.
Query: получение свойства уже существующего объекта. Например, получение радиуса окружности.
Значок переплетения: значение , заданное для совпадающих входных данных списка (подробные сведения см. далее).
Просмотр откл.: серый цвет строки состояния под узлом и значок глаза указывают на то, что просмотр геометрии для этого узла отключен.
Если визуальная программа содержит предупреждения или ошибки, то Dynamo предоставляет подробную информацию о проблеме. Над именем каждого желтого узла отображается подсказка. Наведите курсор на значок подсказки с предупреждением или ошибкой , чтобы узнать подробности.
В Dynamo Package Manager реализованы дополнительные функции, поддерживающие расширенный набор типов геометрии и операций. Ознакомьтесь с возможностями пакета .
— это двумерная поверхность. Ее можно изобразить в виде плоской поверхности, уходящей в бесконечность. Каждая плоскость имеет исходную точку и направления по осям X, Y и Z (вверх).
— это система для определения местоположения точек и других геометрических элементов. На изображении ниже показано, как это выглядит в Dynamo, и что представляет каждый цвет.
Подробные сведения о замораживании узлов см. в разделе .
Благодаря этому использование логических операций для тел позволяет значительно сэкономить время. Существует три логические операции для тел, позволяющие определить, как части геометрии должны сохраняться.
В дополнение к этим трем операциям в Dynamo доступны узлы Solid.DifferenceAll и Solid.UnionAll для выполнения операций разности и объединения с несколькими телами.
СОЗДАНИЕ
Color.ByARGB Создание цвета путем комбинирования альфа-компонента с красным, зеленым и синим компонентами.
Цветовой диапазон Получение цвета на основе цветового градиента между начальным и конечным цветом.
ДЕЙСТВИЯ
Color.Brightness Получение значения яркости для данного цвета.
Color.Components Вывод списка компонентов цвета в следующем порядке: альфа, красный, зеленый, синий.
Color.Saturation Получение значения насыщенности для данного цвета.
Color.Hue Получение значения оттенка для данного цвета.
ЗАПРОС
Color.Alpha Поиск альфа-компонента цвета (от 0 до 255).
Color.Blue Поиск синего компонента цвета (от 0 до 255).
Color.Green Поиск зеленого компонента цвета (от 0 до 255).
Color.Red Поиск красного компонента цвета (от 0 до 255).
СОЗДАНИЕ
GeometryColor.ByGeometryColor Отображение геометрии с помощью цвета.
ДЕЙСТВИЯ
View.Watch Визуализация выходных данных узла.
View.Watch 3D Динамический предварительный просмотр геометрии.
ДЕЙСТВИЯ
Логическое Выбор между значениями True и False.
Code Block Непосредственная разработка кода DesignScript.
Directory Path Выбор папки в системе и получение пути к ней.
File Path Выбор файла в системе и получение его имени.
Integer Slider Регулятор, создающий целые значения.
Number Создание числа.
Number Slider Регулятор, создающий числовые значения.
String Создание строки.
Object.IsNull Определение того, имеет ли данный объект нулевое значение.
СОЗДАНИЕ
List.Create Создание нового списка из заданных входных значений.
List.Combine Применение комбинатора к каждому элементу в двух последовательностях.
Number Range Создание последовательности чисел в заданном диапазоне.
Number Sequence Создание последовательности чисел.
ДЕЙСТВИЯ
List.Chop Разделение списка на набор списков, содержащих заданное количество элементов.
List.Count Получение количества элементов, хранящихся в данном списке.
List.Flatten Выравнивание вложенного списка списков по определенному количественному значению.
List.FilterByBoolMask Фильтрация последовательности путем поиска соответствующих индексов в отдельном списке логических операций.
List.GetItemAtIndex Получение элемента из данного списка, расположенного по заданному индексу.
List.Map Применение функции ко всем элементам списка с созданием нового списка на основе результатов.
List.Reverse Создание нового списка, содержащего элементы из заданного списка, расположенные в обратном порядке.
List.ReplaceItemAtIndex Замена элемента из данного списка, расположенного по заданному индексу.
List.ShiftIndices Смещение индексов в списке вправо на заданную величину.
List.TakeEveryNthItem Извлечение элементов из данного списка по индексам, которые являются множителями заданного значения, после заданного смещения.
List.Transpose Перестановка строк и столбцов в списке списков. Если некоторые строки короче других, то в конечный массив в качестве заполнителей вставляются нулевые значения, чтобы он оставался прямоугольным.
ДЕЙСТВИЯ
If Условное выражение. Проверка логического значения тестового ввода. Если тестовый ввод истинен, в результате выводится значение True; в противном случае выводится значение False.
ДЕЙСТВИЯ
Math.Cos Нахождение косинуса угла.
Math.DegreesToRadians Преобразование единиц угла из градусов в радианы.
Math.Pow Возведение числа в заданную степень.
Math.RadiansToDegrees Преобразование единиц угла из радианов в градусы.
Math.RemapRange Корректировка диапазона списка чисел при сохранении коэффициента распределения.
Math.Sin Поиск синуса угла.
Formula Оценка математических формул. Для оценки используется NCalc. См. раздел http://ncalc.codeplex.com
Map Сопоставление значения с диапазоном входных данных.
ДЕЙСТВИЯ
String.Concat Объединение нескольких строк в одну.
String.Contains Определение того, содержит ли данная строка подстроку.
String.Join Объединение нескольких строк в одну со вставкой заданного разделителя между объединяемыми строками.
String.Split Разделение одной строки на список строк, деления которого определяются заданными строками-разделителями.
String.ToNumber Преобразование строки в целое или двойное число.
СОЗДАНИЕ
Circle.ByCenterPointRadius Построение окружности с входным центром и радиусом в плоскости XY мировой системы координат с осью Z мировой системы координат в качестве нормали.
Circle.ByPlaneRadius Создание окружности с входным центром в начале координат плоскости, находящейся в заданной плоскости, с заданным радиусом.
СОЗДАНИЕ
CoordinateSystem.ByOrigin Создание объекта CoordinateSystem с началом координат во входной точке, с осями X и Y, соответствующими осям X и Y МСК.
CoordinateSystem.ByCyclindricalCoordinates Создание объекта CoordinateSystem с заданными параметрами цилиндрических координат относительно заданной системы координат.
СОЗДАНИЕ
Cuboid.ByLengths Создание кубоида с центром в начале координат МСК с определенной шириной, длиной и высотой.
Cuboid.ByLengths (origin)
Создание кубоида с центром во входной точке с определенной шириной, длиной и высотой.
Cuboid.ByLengths (coordinateSystem)
Создание кубоида с центром в начале координат МСК с определенной шириной, длиной и высотой.
Cuboid.ByCorners
Создание пролета кубоида от нижней до верхней точки.
Cuboid.Length
Возврат входных размеров кубоида, а НЕ фактических размеров мирового пространства. **
Cuboid.Width
Возврат входных размеров кубоида, а НЕ фактических размеров мирового пространства. **
Cuboid.Height
Возврат входных размеров кубоида, а НЕ фактических размеров мирового пространства. **
BoundingBox.ToCuboid
Получение ограничивающей рамки в виде твердотельного кубоида.
ДЕЙСТВИЯ
Curve.Extrude (расстояние) Выдавливание кривой в направлении вектора нормали.
Curve.PointAtParameter Получение точки на кривой по заданному параметру между StartParameter() и EndParameter().
ДЕЙСТВИЯ
Geometry.DistanceTo Получение расстояния от этого до другого геометрического объекта.
Geometry.Explode Расчленение составных или неразделенных элементов на компоненты.
Geometry.ImportFromSAT Список импортированных геометрических объектов.
Geometry.Rotate (basePlane) Поворот объекта относительно начала координат плоскости и нормали на заданное количество градусов
Geometry.Translate Перенос любого типа геометрии на заданное расстояние в заданном направлении.
СОЗДАНИЕ
Line.ByBestFitThroughPoints Создание линии, максимально приближенной к графику рассеяния точек.
Line.ByStartPointDirectionLength Построение прямой линии от начальной точки в направлении вектора на заданную длину.
Line.ByStartPointEndPoint Построение прямой линии между двумя заданными точками.
Line.ByTangency Создание линии, касательной к исходной кривой, расположенной в точке параметра исходной кривой.
QUERY
Line.Direction Направление кривой.
Создание
NurbsCurve.ByControlPoints Создание объекта BSplineCurve с использованием явно заданных управляющих точек.
NurbsCurve.ByPoints Создание элемента BSplineCurve путем интерполяции между точками.
Создание
NurbsSurface.ByControlPoints Создание объекта NurbsSurface по явно заданным управляющим точкам с заданными значениями кривизны U и V.
NurbsSurface.ByPoints Создание объекта NurbsSurface с заданными интерполированными точками и значениями кривизны U и V. Полученная поверхность проходит через все точки.
СОЗДАНИЕ
Plane.ByOriginNormal Создание плоскости с центром в корневой точке с входным вектором нормали.
Plane.XY Создание плоскости XY в МСК.
СОЗДАНИЕ
Point.ByCartesianCoordinates Построение точки в заданной системе координат с тремя декартовыми координатами.
Point.ByCoordinates (2d) Построение точки в плоскости XY по двум заданным декартовым координатам. Координата Z равна 0.
Point.ByCoordinates (3d) Построение точки по трем заданным декартовым координатам.
Point.Origin Получение точки начала координат (0,0,0).
ДЕЙСТВИЯ
Point.Add Добавление вектора к точке. Аналогично Translate (вектор).
QUERY
Point.X Получение координаты точки по оси X.
Point.Y Получение координаты точки по оси Y.
Point.Z Получение координаты точки по оси Z.
СОЗДАНИЕ
Polycurve.ByPoints Создание объекта PolyCurve из последовательности линий, соединяющих точки. Последняя точка замкнутой кривой должна находиться в том же месте, что и начальная точка.
СОЗДАНИЕ
Rectangle.ByWidthLength (плоскость) Построение прямоугольника с центром во входном корне плоскости с входной шириной (расстояние по оси плоскости X) и длиной (расстояние по оси плоскости Y).
СОЗДАНИЕ
Sphere.ByCenterPointRadius Создание твердотельного шара с заданным радиусом с центром во входной точке.
СОЗДАНИЕ
Surface.ByLoft Создание поверхности посредством лофтинга между входными кривыми поперечного сечения.
Surface.ByPatch Создание поверхности путем заполнения пространства внутри замкнутой границы, заданной входными кривыми.
ДЕЙСТВИЯ
Surface.Offset Смещение поверхности в направлении нормали поверхности на заданное расстояние.
Surface.PointAtParameter Получение точки с заданными параметрами U и V.
Surface.Thicken Утолщение поверхности до формирования тела с выдавливанием в направлении нормалей поверхности с обеих сторон поверхности.
СОЗДАНИЕ
UV.ByCoordinates Создание UV из двух двойных значений.
СОЗДАНИЕ
Vector.ByCoordinates Построение вектора на основе трех евклидовых координат.
Vector.XAxis Получение канонического вектора оси X (1,0,0).
Vector.YAxis Получение канонического вектора оси Y (0,1,0).
Vector.ZAxis Получение канонического вектора оси Z (0,0,1).
ДЕЙСТВИЯ
Vector.Normalized Получение нормализованной версии вектора.
СОЗДАНИЕ
CoordinateSystem.ByOrigin Создание объекта CoordinateSystem с началом координат во входной точке, с осями X и Y, соответствующими осям X и Y МСК.
CoordinateSystem.ByCyclindricalCoordinates Создание объекта CoordinateSystem с заданными параметрами цилиндрических координат относительно заданной системы координат.
+ Сложение
- Вычитание
* Умножение
/ Деление
% При модульном делении выполняется поиск остатка первых введенных данных после деления на вторые.
< Меньше, чем
> Больше, чем
== Проверка равенства двух значений.
Цвет — это тип данных, который помогает создавать наглядные визуальные представления, а также отражать различия в результатах визуального программирования. При работе с абстрактными данными и численными переменными бывает трудно определить, что именно изменилось и в какой степени. Для решения этой проблемы можно использовать цвета.
Цвета в Dynamo создаются с использованием входных данных ARGB, что является сокращенным обозначением комбинации альфа-канала (Alpha) с красным (Red), зеленым (Green) и синим (Blue) каналами. Альфа-канал служит для задания прозрачности цвета, а остальные три канала используются как основные цвета для создания всего цветового спектра.
Цвет ARGB (Color.ByARGB)
A,R,G,B
color
Цвета в таблице ниже запрашивают свойства, использованные для настройки итогового цвета: альфа, красный цвет, зеленый цвет и синий цвет. Обратите внимание, что узел Color.Components включает все четыре свойства в качестве портов вывода, поэтому его удобнее всего использовать для запроса свойств цвета.
Альфа (Color.Alpha)
color
A
Красный (Color.Red)
color
R
Зеленый (Color.Green)
color
G
Синий (Color.Blue)
color
B
Компоненты (Color.Components)
color
A, R, G, B
Цвета в таблице ниже соответствуют цветовому пространству HSB. Разделение цвета на такие составляющие, как оттенок, насыщенность и яркость, является более понятным и привычным с точки зрения интерпретации цвета. Какого оттенка должен быть цвет? Насколько ярким он должен быть? Насколько светлым или темным? Отвечая на эти вопросы, мы тем самым разбиваем цвет на составляющие, то есть на оттенок, насыщенность и яркость соответственно.
Оттенок (Color.Hue)
color
Hue
Насыщенность (Color.Saturation)
color
Saturation
Яркость (Color.Brightness)
color
Brightness
Цветовой диапазон аналогичен узлу Remap Range из упражнения #part-ii-from-logic-to-geometry: он повторно сопоставляет список чисел с другой областью. Однако вместо сопоставления с областью чисел цветовой диапазон выполняет сопоставление с цветовым градиентом в соответствии со входными значениями в диапазоне от 0 до 1.
Текущий узел хорошо выполняет свои функции, но с ним может быть трудно добиться нужных результатов с первого раза. Чтобы уверенно работать с цветовым градиентом, стоит несколько раз опробовать его на практике в интерактивном режиме. Выполните небольшое упражнение, чтобы узнать, как настроить градиент, так чтобы цвета на выходе соответствовали заданным числам.
Определите три цвета. С помощью узла Code Block определите красный, зеленый и синий цвета, назначив каждому из них соответствующие сочетания значений 0 и 255.
Создайте список. Объедините три цвета в один список.
Определите индексы. Создайте список для определения положения ручек каждого цвета (в диапазоне от 0 до 1). Обратите внимание, что для зеленого цвета задано значение 0,75. Это смещает зеленый цвет на 3/4 вдоль горизонтального градиента в регуляторе цветового диапазона.
Code Block. Введите значения (от 0 до 1), которые будут преобразованы в цвета.
Узел Display.ByGeometry позволяет раскрашивать геометрию на видовом экране Dynamo. Это позволяет наглядно показывать различные типы геометрии, демонстрировать параметрические концепции и задавать условные обозначения для расчета при моделировании. В качестве входных данных здесь требуются только геометрия и цвет. Для создания градиента, как на изображении выше, порт ввода Color соединяется с узлом Range.
Узел Display.BySurfaceColors позволяет использовать цвет для сопоставления данных на поверхности. Это дает нам широкие возможности для визуализации данных, полученных с помощью таких типов дискретного анализа, как расчеты инсоляции и энергопотребления, а также анализ близости. Применение цвета к поверхности в Dynamo аналогично применению текстуры к материалу в других средах САПР. Выполните небольшое упражнение ниже, чтобы ознакомиться с этим инструментом.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
В этом упражнении основное внимание уделяется параметрическому управлению цветом параллельно с геометрией. Геометрия — стандартная спираль, определение которой выполнено ниже с помощью узла Code Block. Это простой и быстрый способ создания параметрической функции. Так как на данном уроке рассматривается работа с цветом (а не с геометрией), то Code Block идеально подходит для быстрого создания спирали без загромождения рабочей области. Мы будем использовать Code Block все чаще и чаще по мере изучения более сложных процессов.
Code Block: создайте два узла Code Block, используя приведенные выше формулы. Это быстрый параметрический метод создания спирали.
Point.ByCoordinates: соедините порты координат этого узла с тремя портами вывода узла Code Block.
Отображается массив точек, которые образуют спираль. Далее необходимо создать кривую, проходящую через точки, чтобы получить изображение спирали.
PolyCurve.ByPoints: соедините порт вывода Point.ByCoordinates с портом ввода points этого узла. Отображается спиральная кривая.
Curve.PointAtParameter: соедините порт вывода PolyCurve.ByPoints с портом ввода curve. Это требуется, чтобы создать параметрическую точку притяжения, которая перемещается вдоль кривой. Так как кривая вычисляет положение точки с помощью параметра, необходимо задать значение param в диапазоне от 0 до 1.
Number Slider: добавьте этот узел в рабочую область и измените значение min на 0,0, значение max на 1.0, а значение step на .01. Соедините порт вывода регулятора с портом ввода param узла Curve.PointAtParameter. Появляется точка, которая перемещается вдоль спирали в соответствии с положением регулятора (0 — в начальной точке, 1 — в конечной).
Создав опорную точку, мы можем сравнить расстояние от нее до исходных точек, определяющих геометрию спирали. Данное расстояние будет определять геометрию и цвет.
Geometry.DistanceTo: соедините порт вывода узла Curve.PointAtParameter с портом input этого узла. Соедините узел Point.ByCoordinates с входным параметром «geometry».
Watch: в результате мы получаем список значений расстояния от каждой точки спирали до опорной точки, перемещающейся вдоль кривой.
Следующий шаг — определение параметров на основе списка расстояний между точками спирали и опорной точкой. Эти значения расстояний будут использованы для определения радиусов сфер, размещаемых вдоль кривой. Чтобы обеспечить подходящий размер сфер, необходимо повторно сопоставить значения расстояния.
Math.RemapRange: соедините порт вывода узла Geometry.DistanceTo с портом ввода numbers.
Code Block: соедините узел Code Block со значением 0,01 с портом ввода newMin, а узел Code Block со значением 1 с портом ввода newMax.
Watch: соедините порт вывода Math.RemapRange с одним узлом, а порт вывода Geometry.DistanceTo — с другим. Сравните результаты.
Выполнив этого шаг, мы получили повторно сопоставленный список расстояний меньшего диапазона. При необходимости можно задать другие значения newMin и newMax. Новые значения будут повторно сопоставлены и будут иметь одинаковый коэффициент распределения в пределах области.
Sphere.ByCenterPointRadius: соедините порт вывода узла Math.RemapRange с портом ввода radius, а порт вывода исходного узла Point.ByCoordinates — с портом ввода centerPoint.
Измените значение числового регулятора и посмотрите, как при этом изменится размер сфер. Теперь у нас есть параметрический шаблон.
Размер сфер является представлением параметрического массива, определяемого опорной точкой, перемещающейся вдоль кривой. Применим эту же концепцию к радиусу сфер, чтобы определить их цвет.
Color Range: добавьте в рабочую область этот узел. При наведении указателя мыши на порт ввода value обратите внимание, что запрашиваемые числа находятся в диапазоне от 0 до 1. Необходимо повторно сопоставить числа, указанные для порта вывода узла Geometry.DistanceTo, чтобы они были совместимы с этой областью.
Sphere.ByCenterPointRadius: временно отключите предварительный просмотр узла (щелкните правой кнопкой мыши, а затем выберите «Предварительный просмотр»).
Math.RemapRange: эта процедура должна быть вам уже знакома. Соедините порт вывода узла Geometry.DistanceTo с портом ввода numbers.
Code Block: аналогично шагу выше задайте значение 0 для порта ввода newMin и 1 для порта ввода newMax. Обратите внимание, что в данном случае мы задаем два порта вывода для одного узла Code Block.
Color Range: соедините порт вывода узла Math.RemapRange с портом ввода value.
Color.ByARGB: этот блок позволит нам создать два цвета. Хотя процесс может показаться не самым очевидным, по сути, это то же самое, что и работа с цветами RGB в другом программном обеспечении. Просто здесь мы используем возможности визуального программирования.
Code Block: создайте два значения — 0 и 255. Соедините два порта вывода с двумя портами ввода Color.ByARGB в соответствии с изображением выше (или создайте другие цвета на свой выбор).
Color Range: порт ввода colors запрашивает список цветов. Необходимо создать этот список из двух цветов, заданных на предыдущем шаге.
List.Create:: объедините два цвета в один список. Соедините порт вывода этого узла с портом ввода colors узла Color Range.
Display.ByGeometryColor: соедините узел Sphere.ByCenterPointRadius с портом ввода geometry, а узел Color Range — с портом ввода color. К области кривой применяется мягкий цветовой градиент.
Если изменить в определении значение узла Number Slider, который мы изучили ранее, то цвета и размеры геометрии будут обновлены. Цвета и размер радиуса в данном случае связаны напрямую, и теперь между этими двумя параметрами существует и визуальная связь.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
Сначала необходимо создать поверхность (или выбрать существующую поверхность в качестве опорной) для использования в качестве входных данных для узла Display.BySurfaceColors. В этом примере поверхность образуется путем лофтинга между синусоидой и косинусоидой.
Эта группа узлов создает точки вдоль оси Z с последующим смещением в соответствии с функциями синуса и косинуса. Затем два полученных списка точек используются для создания NURBS-кривых.
Surface.ByLoft: сформируйте интерполированную поверхность между NURBS-кривыми из списка.
File Path: выберите файл изображения, который будет использоваться в качестве образца для пиксельных данных на последующих этапах.
С помощью узла File.FromPath преобразуйте путь к файлу в файл, а затем передайте этот файл в узел Image.ReadFromFile, чтобы вывести изображение для использования в качестве образца.
Image.Pixels: используйте изображение в качестве входных данных и введите значение количества образцов, получаемых вдоль осей X и Y изображения.
Slider: задайте значения количества образцов для узла Image.Pixels.
Display.BySurfaceColors: сопоставьте массив значений цветов на поверхности со значениями по осями X и Y соответственно.
Просмотрите увеличенную предварительную версию итоговой поверхности с разрешением 400 x 300.
Чтобы углубиться в процесс разработки визуальных программ, нам потребуется более тонкое понимание того, что представляют собой компоновочные блоки программ. В этой главе описываются основные понятия, относящиеся к данным, проходящим по проводам программы Dynamo.
Логика (а точнее условная логика) позволяет задать действие или набор действий в зависимости от результата проверки. После прохождения проверки выдается логическое значение True
или False
, которое можно использовать для управления ходом программы.
Числовые переменные могут хранить целый диапазон различных чисел. В логических переменных хранятся только два значения: «Истина» или «Ложь», да или нет, 1 или 0. Из-за ограниченной применимости логические операции можно не так часто встретить в расчетах.
Выражение «If» является ключевым для программирования. Если некое условие истинно, то происходит что-то одно; в противном случае происходит что-то другое. Действие, выполняемое после проверки с помощью данного выражения, зависит от логического значения. Существует несколько способов определения выражения If в Dynamo.
If (If)
test, true, false
результат
Formula (IF(x,y,z))
x, y, z
результат
Code Block ((x?y:z);)
X, Y, Z
результат
Рассмотрим краткий пример с каждым из этих трех узлов в действии, используя условное выражение If.
На этом изображении в узле boolean задано значение true. Это означает, что на выходе появится строка this is the result if true (это результат при истинном значении). Три узла, образующие выражение If, работают одинаково.
Напомним, что узлы работают одинаково. Если для boolean изменить значение на false, результатом будет число пи, как определено в исходном операторе If.
Скачайте файл с примером, щелкнув ссылку ниже.
Полный список файлов с примерами можно найти в приложении.
Используем логику, чтобы разделить список чисел на список четных и список нечетных чисел.
a. Number Range. Добавление диапазона чисел в рабочую область.
b. Numbers. Добавление трех узлов Number в рабочую область. Каждый узел Number должен иметь следующие значения: 0.0 для start, 10.0 для end и 1.0 для step
c. Output. На выходе получается список из 11 чисел в диапазоне от 0 до 10.
d. Modulo (%). Диапазон номеров в качестве входных данных для x и значение 2.0 в качестве входных данных для y. При этом рассчитывается остаток каждого числа в списке при делении на 2. На выходе из этого списка будет представлен список чередующихся значений 0 и 1.
e. Equality Test (==). Добавление в рабочую область проверки равенства. Соедините выходные данные modulo с входным параметром x, а значение 0.0 с входным параметром y.
f. Watch. В качестве выходных данных проверки равенства будет представлен список значений «Истина» (true) и «Ложь» (false). С помощью этих значений элементы будут разделяться в списке. 0 (или true) соответствует четным числам, а 1 (или false) — нечетным.
g. List.FilterByBoolMask. Этот узел отфильтровывает значения по двум разным спискам в зависимости от вводимого логического выражения. Соедините исходный диапазон чисел с входным параметром list, а выходной параметр проверки равенства с входным параметром mask. В выходных данных in представлены истинные значения, а в out — ложные.
h. Watch. В результате мы получили списки четных и нечетных чисел. Итак, с помощью логических операторов мы разделили списки по определенному признаку.
Применим логику из первого упражнения к моделированию.
2. За основу возьмем предыдущее упражнение с теми же узлами. Помимо изменения формата, единственными исключениями будут следующие.
a. Используйте узел Sequence с этими входными значениями.
b. Отсоединен входной параметр list от узла List.FilterByBoolMask. Эти узлы пока не нужны, но они потребуются позже.
3. Начнем с создания отдельной группы Graph, как показано на изображении выше. Эта группа узлов представляет собой параметрическое уравнение для определения линейной кривой. Примечания.
a. Первый регулятор Number Slider представляет частоту волны в диапазоне от 1 до 4 с шагом 0,01.
b. Второй регулятор Number Slider представляет амплитуду волны в диапазоне от 0 до 1 с шагом 0,01.
c. PolyCurve.ByPoints. Если скопировать приведенную выше схему узлов, на видовом экране предварительного просмотра Dynamo будет создана синусоидальная кривая.
При вводе данных используйте числовые узлы для более статических свойств и регуляторы чисел для более гибких свойств. Необходимо сохранить исходный диапазон чисел, который определяется в начале этого шага. Однако синусоидальная кривая, которую мы пытаемся создать, должна обладать определенной гибкостью. Перемещая регуляторы, можно видеть частотные и амплитудные изменения кривой.
4. Забежим немного вперед и посмотрим на конечный результат, чтобы представить, каким он должен быть. Первые два шага выполняются отдельно, теперь их нужно соединить. С помощью базовой синусоидальной кривой будет определяться местоположение компонентов молнии, а с помощью логики «истина/ложь» — элементы меньшего или большего размера.
a. Math.RemapRange. С помощью последовательности чисел, созданной на шаге 02, сформируем новую последовательность чисел, перенастроив диапазон. Исходные числа из шага 01 имеют диапазон от 0 до 100. С помощью входных параметров newMin и newMax диапазон значений изменяется на 0–1 соответственно.
5. Создайте узел Curve.PointAtParameter, а затем соедините выходной параметр Math.RemapRange из шага 04 с входным параметром param.
На этом шаге создаются точки вдоль кривой. Диапазон чисел был перенастроен на 0–1, так как входной параметр param ищет значения в этом диапазоне. Значение 0 соответствует начальной точке, а значение 1 — конечным точкам. Все промежуточные числа относятся к диапазону [0,1].
6. Соедините выходной параметр узла Curve.PointAtParameter с узлом List.FilterByBoolMask, чтобы разделить список четных и нечетных индексов.
a. List.FilterByBoolMask. Соедините узел Curve.PointAtParameter из предыдущего шага с входным параметром list.
b. Watch. Узел Watch для in и узел Watch для out показывают, что имеется два списка — c четными и нечетными индексами. Тот же самый порядок точек используется в кривой, что демонстрируется на следующем шаге.
7. Далее используйте результат вывода из узла List.FilterByBoolMask на шаге 05 для создания геометрий с размерами в соответствии с индексами.
Cuboid.ByLength. Для создания молнии вдоль синусоидальной кривой воспроизведите связи, представленные на изображении выше. В данном случае кубоид — это просто рамка, размер которой определяется в зависимости от точки кривой в центре рамки. Теперь логика деления «четные/нечетные» в модели должна быть понятной.
a. Список кубоидов с четными индексами.
b. Список кубоидов с нечетными индексами.
Готово! Вы только что запрограммировали процесс определения геометрических размеров в соответствии с логической операцией, показанной в этом упражнении.
Кривые — это первый из рассматриваемых здесь типов геометрических данных с привычным набором свойств, определяющих форму объекта (степень изгиба, длина и т. д.). Следует помнить, что основной единицей при построении любых объектов — от отрезка до сплайна и всех прочих типов кривых — остаются точки.
Отрезок
Полилиния
Дуга
Окружность
Эллипс
NURBS-кривая
Сложная кривая
NURBS — это модель, используемая для точного представления кривых и поверхностей. Создайте синусоидальную кривую в Dynamo с помощью двух различных методов создания кривых NURBS и сравните результаты.
Узел NurbsCurve.ByControlPoints в качестве управляющих точек использует список точек.
Узел NurbsCurve.ByPoints создает кривую по списку точек.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
Под термином кривая обычно понимаются все типы криволинейных форм (даже если они являются прямолинейными). Таким образом, кривая — это родительская категория, в которую входят все эти типы форм: отрезки, окружности, сплайны и т. д. В техническом плане кривая описывает все возможные точки, которые можно найти, путем ввода параметра «t» в набор простых (x = -1.26*t, y = t
) или высших математических функций. Независимо от типа кривой, искомым свойством является данный параметр, условно обозначаемый как «t». Кроме этого, все кривые, независимо от своей формы, также имеют начальную и конечную точки, которые соответствуют минимальному и максимальному значениям «t», используемым для создания кривой. Это также позволяет определить направленность кривой.
Важно помнить, что в Dynamo область значений «t» для кривой охватывает диапазон от 0,0 до 1,0.
Все кривые также имеют ряд свойств или характеристик, которые можно использовать для их описания или анализа. Если расстояние между начальной и конечной точками равно нулю, кривая будет замкнутой. Кроме этого, каждая кривая имеет несколько управляющих точек. Если все эти точки расположены в одной плоскости, то кривая будет плоской. Некоторые свойства применяются ко всей кривой, другие — только к определенным точкам на кривой. Например, планарность является глобальным свойством, а вектор касательной при заданном значении — локальным.
Отрезки — это простейшая форма кривых. Хотя они могут не выглядеть изогнутыми, на самом деле, это кривые, у которых просто отсутствует кривизна. Существует несколько способов создания отрезков, наиболее простым из которых является создание отрезка от точки A до точки B. Форма отрезка AB заключена между этими точками, но математически она бесконечно продолжается в обоих направлениях.
При соединении двух отрезков создается полилиния. На этом изображении наглядно показано, что собой представляет управляющая точка. При изменении положения любой из этих точек изменится и форма полилинии. Если полилиния замкнута, получится полигон. Если длина всех ребер полигона одинакова, он будет правильным.
Постепенно усложняя параметрические функции, определяющие форму, можно построить не просто отрезок, но и дугу, окружность, эллиптическую дугу или эллипс, задав один или два радиуса. Отличие между дугой и окружностью или эллипсом состоит только в том, что последние две формы являются замкнутыми.
NURBS (неоднородные сплайны с рациональной основой ) — это математические представления, которые позволяют точно смоделировать любую форму: от простого двумерного отрезка, окружности, дуги или прямоугольника до сложнейшей трехмерной органичной кривой произвольной формы. Благодаря своей гибкости (плавной интерполяции, в зависимости от заданной степени, при относительно небольшом количестве управляющих точек) и точности (достигаемой за счет сложных математических вычислений) модели NURBS можно использовать в любом процессе, будь то презентация, анимация или производство.
Степень: степень кривой определяет диапазон влияния управляющих точек на кривую (чем выше степень, тем больше диапазон). Степень — это положительное целое число. Обычно это число 1, 2, 3 или 5, но вместо него может использоваться любое другое положительное целое число. NURBS-отрезки и полилинии обычно имеют степень 1, а кривые произвольной формы — степени 3 или 5.
Управляющие точки: список точек в количестве не меньшем, чем «степень + 1». Одним из самых простых способов изменения формы NURBS-кривой является перемещение ее управляющих точек.
Вес: с управляющими точками связано определенное число, которое называется весом. Обычно вес является положительным числом. Если для управляющих точек кривой установлен одинаковый вес (обычно 1), кривая называется нерациональной. В противном случае она считается рациональной. Большинство NURBS-кривых являются нерациональными.
Узлы: список чисел (степень+N-1), где N — количество управляющих точек. Узлы используются вместе со значениями веса для управления влиянием управляющих точек на итоговую кривую. Одной из функций узлов является создание точек излома в определенных точках кривой.
Степень = 1
Степень = 2
Степень = 3
Обратите внимание, что чем выше значение степени, тем больше управляющих точек используется для интерполяции полученной кривой.
Формально строка — это последовательность символов, представляющих литеральную константу или переменную определенного типа. Однако на сленге программистов строкой называется любой текст. Мы уже говорили о том, как можно управлять параметрами с помощью целых и десятичных чисел. Аналогичным образом можно работать и с текстом.
Строки применяются в разных ситуациях, в том числе при настройке пользовательских параметров, аннотировании документации и анализе текстовых наборов данных. Узел String находится в разделе Core > Input Category.
Примеры узлов выше являются строками. В виде строки может быть представлено число, буква или целый массив текста.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
С помощью запроса строк можно быстро анализировать большие объемы данных. Поговорим о некоторых основных операциях, которые могут ускорить рабочий процесс и обеспечить совместимость программного обеспечения.
На следующем изображении показана строка данных из внешней электронной таблицы. Строка представляет вершины прямоугольника в плоскости XY. Рассмотрим подробнее некоторые операции по разделению строк в небольшом упражнении.
В качестве разделителя вершин прямоугольника используется точка с запятой («;»). При этом создается список, содержащий 3 элемента для каждой вершины.
Если нажать знак «+» посредине узла, будет создан новый разделитель.
Добавьте строку «,» в рабочую область и соедините ее с новым входным параметром separator.
Получится список из десяти элементов. Сначала в качестве разделителя узла используется значение separator0, а затем — separator1.
Хотя элементы списка на изображении выше выглядят как числа, в Dynamo они все так же считаются отдельными строками. Для создания точек тип соответствующих данных необходимо преобразовать из строкового в числовой. Для этого используется узел String.ToNumber.
Этот узел достаточно прост. Соедините результаты String.Split с входным параметром. Кажется, что выходные данные не изменились, но теперь типом данных будет number, а не string.
Добавив несколько дополнительных операций, вы создали треугольник на основе исходных строковых входных данных в начале координат.
Так как строка является типовым текстовым объектом, у нее есть множество применений. Рассмотрим основные действия в разделе Core > String Category в Dynamo.
На изображении представлен метод объединения двух строк по порядку. Берется каждая литеральная строка в списке и создается одна объединенная строка.
На следующем изображении показана операция объединения трех строк.
Нажатием кнопок «+/-» в центре узла можно добавлять или удалять строки.
На выходе получается одна объединенная строка с пробелами и знаками препинания.
Метод соединения очень похож на метод объединения, но в нем есть дополнительный слой пунктуации.
Пользователям, работающим с Excel, могут быть знакомы файлы CSV. CSV расшифровывается как comma-separated values — значения, разделенные запятыми. Чтобы создать данные с аналогичной структурой, в узле String.Join в качестве разделителя можно использовать запятую (или в данном случае два дефиса).
На следующем изображении показано соединение двух строк.
Входной параметр separator позволяет создать строку, выступающую в качестве разделителя соединенных строк.
В этом упражнении с помощью методов запроса строк и операций со строками мы разберем последнее четверостишие стихотворения американского поэта Роберта Фроста Stopping By Woods on a Snowy Evening. Хотя это не самый практичный пример, он поможет понять, как выполнять основные операции со строками в связном тексте с размером и рифмой.
Начнем с разделения строк четверостишия. Прежде всего, обратим внимание на то, что в стихотворении используются запятые. С помощью них можно будет разделить каждую строчку на отдельные элементы.
Исходная строка вставляется в узел String.
Для указания разделителя используется еще один узел String. В данном случае разделителем будет запятая.
В рабочую область добавляется узел String.Split, который соединяется с двумя строками.
На выходе строчки разделены на отдельные элементы.
Перейдем к самой интересной части стихотворения: последним двум строчкам. Исходное четверостишие представляло собой один элемент данных. Сперва эти данные были разделены на отдельные элементы. Теперь необходимо найти нужный нам текст. Хотя это можно осуществить, выбрав два последних элемента списка, в случае с целой книгой не обязательно прочитывать ее всю и выделять элементы вручную.
Вместо того чтобы выполнять поиск вручную, используйте узел String.Contains для поиска набора символов. Это аналогично команде «Найти» в текстовом редакторе. В этом случае при обнаружении подстроки в элементе возвращается значение «Истина» или «Ложь».
Для входного параметра searchFor определите подстроку, которую необходимо найти в четверостишии. Воспользуйтесь узлом String с текстом «And miles».
На выходе получим список значений «Истина» и «Ложь». Воспользуемся этой логикой для фильтрации элементов на следующем этапе.
Для отбора значений True и False используйте узел List.FilterByBoolMask. Выходной параметр in возвращает выражения с входным значением mask, для которых действительно значение «Истина», а выходной параметр out — выражения, для которых действительно значение «Ложь».
Результат на выходном параметре in соответствует ожиданиям, то есть мы получаем две последние строки четверостишия.
Теперь необходимо воссоздать повтор, объединив две строки вместе. Если посмотреть на результаты выполнения предыдущего шага, можно заметить, что в списке присутствуют два элемента.
С помощью двух узлов List.GetItemAtIndex можно изолировать элементы, используя значения 0 и 1 в качестве входных данных индекса.
На выходе из каждого узла получаем последние две строки, расположенные по порядку.
Для объединения этих двух элементов в один используйте узел String.Join.
После добавления узла String.Join становится понятно, что требуется разделитель.
Для создания разделителя добавьте узел String в рабочую область и введите запятую.
Конечный результат — объединение двух последних элементов в один.
Изолирование двух последних строк может показаться довольно трудоемким процессом. Это действительно так — операции со строками часто требуют предварительной подготовки. Однако эти операции масштабируемы и могут сравнительно легко применяться к большим наборам данных. Если работа с электронными таблицами и настройка совместимости осуществляются на параметрической основе, обязательно помните об операциях со строками.
В сфере вычислительного моделирования сети представляют собой одну из наиболее распространенных форм представления 3D-геометрии. Геометрия сети обычно состоит из набора четырехугольников или треугольников. Она может быть простой и гибкой альтернативой работе с поверхностями NURBS. Сети используются во всех областях, от визуализации до цифрового производства и 3D-печати.
Приложение Dynamo определяет сети, используя структуру данных «грань—вершина». На элементарном уровне эта структура представляет собой набор точек, сгруппированных по полигонам. Точки сети называются вершинами, а полигоны, похожие на поверхности, — гранями.
Для создания сети требуется список вершин и система, позволяющая группировать эти вершины в грани, называемая группой индексов.
Список вершин
Список групп индексов для определения граней
Возможности работы с сетями в Dynamo можно расширить за счет установки пакета Mesh Toolkit. Dynamo Mesh Toolkit содержит инструменты для импорта сетей из внешних файлов в других форматах, создания сетей из геометрических объектов Dynamo и построения сетей вручную по вершинам и индексам.
В библиотеке также содержатся инструменты для изменения сетей, их восстановления или извлечения горизонтальных срезов для использования в производстве.
Ознакомьтесь с примерами работы с Mesh Toolkit на основе данного пакета.
Сеть — это набор четырехугольников и треугольников, образующих геометрию поверхности или тела. Как и в случае с телами, структура объекта-сети включает в себя вершины, ребра и грани. Существуют свойства, которыми обладают только сети, например нормали.
Вершины сети
Ребра сети (ребра, у которых только одна прилегающая грань, называются открытыми; все остальные ребра являются закрытыми)
Грани сети
Вершины сети представляют собой обычный список точек. Индекс вершин очень важен при создании сети или получении информации о структуре сети. У каждой вершины также есть соответствующая нормаль вершины (вектор), задающая усредненное направление прилегающих граней и позволяющая определить ориентацию сети «внутрь» или «наружу».
Вершины
Нормали вершин
Грань представляет собой упорядоченный список из трех или четырех вершин. Таким образом, представление грани сети зависит от положения индексируемых вершин. Благодаря наличию списка вершин, образующих сеть, вместо указания отдельных точек для определения грани достаточно использовать индекс вершин. Это также позволяет использовать одну и ту же вершину в нескольких гранях.
Квадратная грань, созданная на основе индексов 0, 1, 2 и 3
Треугольная грань, созданная на основе индексов 1, 4 и 2 (обратите внимание, что очередность групп индексов может быть изменена: если очередность следует направлению против часовой стрелки, то грань будет определена правильно)
В чем отличие геометрии сети от геометрии NURBS? Когда следует использовать геометрию каждого из этих типов?
В предыдущей главе мы узнали, что NURBS-поверхности определяются набором NURBS-кривых, идущих в двух направлениях. Эти направления обозначаются как U
и V
и позволяют осуществлять параметризацию поверхности NURBS в соответствии с областью определения двумерной поверхности. Сами кривые хранятся на компьютере в виде формул, что позволяет рассчитывать итоговые поверхности с произвольно малой степенью точности. Тем не менее скомбинировать несколько NURBS-поверхностей достаточно сложно. Объединение двух NURBS-поверхностей приведет к созданию сложной поверхности, причем разные сегменты геометрии будут иметь различные параметры UV и определения кривых.
Поверхность
Изопараметрическая кривая
Управляющая точка поверхности
Управляющей полигон поверхности
Изопараметрическая точка
Рамка поверхности
Сеть
Открытое ребро
Сетка сети
Ребра сети
Нормаль вершины
Грань сети/нормаль грани сети
Сети состоят из дискретного количества точно заданных вершин и граней. Сетка вершин, как правило, не может быть определена простыми координатами UV
, а так как грани дискретны, степень точности уже встроена в сеть и ее можно изменить только путем уточнения сети и добавления дополнительных граней. Отсутствие математических описаний у сетей обеспечивает гибкость при работе со сложными геометрическими объектами в пределах одной сети.
Еще одно важное отличие заключается в том, насколько локальные изменения геометрии сети или геометрии NURBS влияют на всю форму. Перемещение одной вершины сети влияет только на грани, прилегающие к этой вершине. В NURBS-поверхностях механизм влияния более сложен и зависит от степени, а также веса и узлов управляющих точек. Однако в целом при перемещении одной управляющей точки на NURBS-поверхности изменения в геометрии будут более сглаженными и масштабными.
NURBS-поверхность: перемещение управляющей точки влияет на всю форму.
Геометрия сети: перемещение влияет только на прилегающие элементы.
В качестве аналогии можно сравнить векторное изображение (состоящее из отрезков и кривых) с растровым изображением (состоящим из отдельных пикселей). При увеличении векторного изображения кривые остаются плотными и четкими, а при увеличении растрового изображения увеличивается размер отдельных пикселей. В этом случае NURBS-поверхности можно сравнить с векторным изображением, так как здесь работает плавная математическая связь, а сеть ведет себя так же, как растровое изображение с заданным разрешением.
Данные — это содержимое программы. Они передаются по проводам, предоставляя входные значения узлам, в которых затем обрабатываются и преобразуются в выходные данные новой формы. Давайте рассмотрим определение данных и их структуру, а затем начнем работу с данными в Dynamo.
Данные — это набор значений количественных и качественных переменных. Самая простая форма данных — это числа, например 0
, 3.14
и 17
. Однако существуют и другие типы данных: переменные, представляющие меняющиеся числа (height
); символы (myName
); геометрические объекты (Circle
); список элементов данных (1,2,3,5,8,13,...
).
В Dynamo данные добавляются (или передаются) в порты ввода узлов. Данные могут существовать без действий, однако они необходимы для обработки действий, которые представлены в форме узлов. Если узел добавлен в рабочее пространство, но не имеет входных данных, результатом будет функция, а не результат самого действия.
Простые данные
Данные и действие (узел), которое успешно выполняется.
Действие (узел) без входных данных возвращает типовую функцию.
Остерегайтесь значений null. Тип 'null'
указывает на отсутствие данных. Это абстрактное понятие, с которым можно, тем не менее, столкнуться при визуальном программировании. Если результат действия недопустим, узел возвращает нулевой объект.
Проверка наличия нулевых объектов и их удаление из структуры данных крайне важны для создания надежных программ.
Object.IsNull
obj
bool
При визуальном программировании можно очень быстро генерировать большие объемы данных, поэтому необходимы средства для управления их иерархией. Эту роль выполняют структуры данных — организационные схемы, в которых хранятся данные. Особенности структур данных и их использования зависят от языка программирования.
В Dynamo для построения иерархии данных используются списки. Они будут подробнее рассмотрены в следующих главах, пока же приведем только общие сведения.
Список — это набор элементов, размещенных в одной структуре данных:
У меня пять пальцев (элементы) на руке (список).
На моей улице (список) десять домов (элементы).
Узел Number Sequence определяет список чисел на основе входных данных start, amount и step. С помощью этих узлов было создано два отдельных списка из десяти чисел, один из которых охватывает диапазон 100–109, а другой — 0–9.
Узел List.GetItemAtIndex позволяет выбрать элемент в списке по определенному индексу. При выборе значения 0 будет получен первый элемент в списке (в данном случае — 100).
Та же процедура применительно ко второму списку дает значение 0 — первый элемент в списке.
Объединим оба списка в один с помощью узла List.Create. Обратите внимание, что узел создает список списков. Это меняет структуру данных.
При повторном использовании узла List.GetItemAtIndex с индексом 0 получаем первый список в списке списков. Это означает, что список рассматривается как элемент, в чем и состоит отличие от других языков программирования. В последующих главах операции со списками и структуры данных будут рассмотрены подробнее.
Главное, что следует помнить об иерархии данных в Dynamo — в случае со структурой данных списки рассматриваются как элементы. Другими словами, в Dynamo структура данных рассматривается сверху вниз. Что это означает? Рассмотрим пример.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
В первом примере создадим цилиндр с оболочкой, пройдя по ступеням геометрической иерархии, описанной в этом разделе.
1. Добавьте узел Point.ByCoordinates. После его добавления в рабочую область в начале координат сетки предварительного просмотра Dynamo появляется точка. Значения по умолчанию для выходных параметров x,y и z равны 0,0. В этом месте и была создана точка.
2. Plane.ByOriginNormal. Следующий шаг в построении геометрической иерархии — плоскость. Существует несколько способов построения плоскости. В этом случае в качестве входных данных используется начало координат и нормаль. Начало координат — это узел-точка, созданный на предыдущем шаге.
Vector.ZAxis. Это унифицированный вектор в направлении Z. Обратите внимание, что здесь входные данные отсутствуют, а есть только вектор со значением [0,0,1]. Он будет использоваться в качестве входных данных нормали для узла Plane.ByOriginNormal. В результате получается прямоугольная плоскость в области предварительного просмотра Dynamo.
3. Circle.ByPlaneRadius. Продвигаясь вверх по иерархии, создадим кривую из плоскости, полученной на предыдущем шаге. После соединения с узлом получаем окружность в начале координат. По умолчанию радиус в узле имеет значение 1.
4. Curve.Extrude. Теперь выполним выдавливание фигуры, задав глубину и двигаясь в третьем измерении. Этот узел создает поверхность из кривой путем выдавливания. По умолчанию расстояние в узле равно 1, а на видовом экране должен отображаться цилиндр.
5. Surface.Thicken. Этот узел создает замкнутое тело путем смещения поверхности на заданное расстояние и замыкания формы. По умолчанию значение толщины равно 1, а на видовом экране в соответствии с этими значениями отображается цилиндр с оболочкой.
6. Number Slider. Вместо использования значений по умолчанию для входных данных добавим в модель параметрические элементы управления.
Редактирование области. После добавления регулятора чисел в рабочую область щелкните значок в левом верхнем углу окна, чтобы отобразить параметры области.
Min/Max/Step. Задайте для параметров min, max и step значения 0, 2 и 0.01 соответственно. Это необходимо для управления размером всей геометрии.
7. Регуляторы чисел. Вместо входных значений по умолчанию скопируйте и вставьте этот регулятор чисел (выберите его, нажмите CTRL + C, затем CTRL + V) несколько раз, пока во всех входных параметрах со значениями по умолчанию не будут заданы регуляторы. Чтобы алгоритм действовал, некоторые значения регуляторов должны быть больше нуля (например, для увеличения толщины поверхности требуется глубина выдавливания).
8. В итоге с помощью регуляторов создан параметрический цилиндр с оболочкой. Попробуйте изменить некоторые из параметров, наблюдая за динамическим обновлением геометрических объектов на видовом экране Dynamo.
Регуляторы чисел. На следующем этапе мы добавили в рабочую область множество регуляторов, и теперь необходимо очистить интерфейс только что созданного инструмента. Щелкните один регулятор правой кнопкой мыши и выберите «Переименовать...». Замените имя каждого регулятора именем соответствующего параметра (толщина, радиус, высота и т. п.).
9. На данный момент создан цилиндр с толстыми стенками. Пока это только один объект. Теперь рассмотрим, как создать массив цилиндров, которые динамически связаны друг с другом. Для этого вместо одного объекта создадим список цилиндров.
Добавление (+). Наша цель — добавить ряд цилиндров возле уже имеющегося цилиндра. При вставке еще одного цилиндра рядом с текущим необходимо учитывать радиус цилиндра и толщину его оболочки. Это число можно получить, сложив два значения регуляторов.
10. Это более сложный шаг, поэтому рассмотрим его подробнее. Конечная цель — создать список чисел, определяющих местоположение каждого цилиндра в последовательности.
a. Умножение. Сначала умножим значение из предыдущего шага на 2. Это было значение радиуса, а цилиндр необходимо переместить на полный диаметр.
b. Number Sequence. С помощью этого узла создадим массив чисел. Сначала вставим узел умножения из предыдущего шага в качестве значения step. В качестве значения start можно указать 0.0, используя узел number.
c. Integer Slider. Чтобы задать значение amount, присоединим регулятор целых чисел. Он будет определять количество создаваемых цилиндров.
d. Выходные данные. В этом списке показано расстояние смещения каждого цилиндра в массиве, которое управляется параметрически с помощью первоначальных регуляторов.
11. Этот шаг достаточно прост: соедините последовательность из предыдущего шага с входным параметром x исходного узла Point.ByCoordinates. При этом регулятор pointX будет заменен, и его можно удалить. Теперь на видовом экране отображается массив цилиндров (убедитесь, что регулятор целых чисел имеет значение больше 0).
12. Цепь цилиндров по-прежнему динамически связана со всеми регуляторами. Перемещайте регуляторы, и вы увидите, как изменится картина.
Числа являются самой простой формой данных, а самым простым способом связать эти числа между собой является математика. Начиная от элементарных операторов, таких как деление, и заканчивая тригонометрическими функциями и более сложными формулами, математика — отличный способ начать знакомство с отношениями и закономерностями в мире чисел.
Оператор — это набор компонентов, в которых используются алгебраические функции с двумя входными числовыми значениями, результатом которых является одно выходное значение (сложение, вычитание, умножение, деление и т. д.). Они находятся в разделе «Операторы» > «Действия».
Сложение (+)
var[]...[], var[]...[]
var[]...[]
Вычитание (–)
var[]...[], var[]...[]
var[]...[]
Умножение (*)
var[]...[], var[]...[]
var[]...[]
Деление (/)
var[]...[], var[]...[]
var[]...[]
Скачайте файл с примером, щелкнув ссылку ниже.
Полный список файлов с примерами можно найти в приложении.
Объединяйте операторы и переменные для формирования более сложной связи с помощью формул. Используйте регуляторы для создания формулы, которой можно управлять с помощью входных параметров.
1. Создайте числовую последовательность, которая представляет собой «t» в параметрическом уравнении. Теперь нужен достаточно большой список для определения спирали.
Number Sequence. Определим последовательность чисел на основе трех входных параметров: start, amount и step.
2. На предыдущем шаге был создан список чисел для определения области параметрических компонентов. Создайте группу узлов, представляющих уравнение золотой спирали.
Золотая спираль определяется по следующей формуле:
На изображении ниже представлена золотая спираль в форме визуального программирования. Рассматривая группу узлов, обратите внимание на соответствие между визуальной программой и уравнением в записи.
a. Number Slider. Добавьте два регулятора чисел в рабочую область. Эти регуляторы будут задавать переменные a и b параметрического уравнения. Они представляют собой гибкую константу или параметры, которые можно настроить для получения желаемого результата.
b. Multiplication (*). Узел умножения обозначен звездочкой. Он будет часто использоваться для соединения умножаемых переменных
c. Math.RadiansToDegrees. Значения «t» необходимо преобразовать в градусы для их оценки в тригонометрических функциях. Следует помнить, что для оценки этих функций в Dynamo по умолчанию используются градусы.
d. Math.Pow. В качестве функции «t» и числа «e» этот узел создает последовательность Фибоначчи.
e. Math.Cos и Math.Sin. С помощью этих двух тригонометрических функций будут различаться координаты X и Y (соответственно) для каждой параметрической точки.
f. Watch. В качестве выходных данных отображается два списка, которые будут выступать в качестве координат x и y точек, используемых для формирования спирали.
Хотя набор узлов из предыдущего этапа будет выполнять поставленные задачи, этот процесс довольно трудоемкий. Для повышения эффективности работы ознакомьтесь с разделом DesignScript, в котором показано, как в одном узле разместить строку выражений Dynamo. На последующих этапах рассмотрим использование параметрического уравнения для построения спирали Фибоначчи.
Point.ByCoordinates. Соедините верхний узел умножения с входным параметром «x», а нижний — с входным параметром «y». На экране отобразится параметрическая спираль, проходящая через точки.
Polycurve.ByPoints. Соедините узел Point.ByCoordinates из предыдущего шага с входным параметром points. Параметр connectLastToFirst можно оставить без входных данных, поскольку мы не будем создавать замкнутую кривую. Таким образом, получаем спираль, которая проходит через каждую точку, заданную на предыдущем шаге.
Спираль Фибоначчи создана. Продолжим работу и выполним еще два упражнения, которые назовем «Наутилус» и «Подсолнух». Продемонстрируем два варианта использования спирали Фибоначчи на примере этих представителей естественных систем.
Circle.ByCenterPointRadius. Узел окружности будет иметь те же входные данные, что и на предыдущем шаге. Значение радиуса по умолчанию равно 1.0, поэтому окружности создаются сразу. Четко видно, каким образом точки отклоняются от начала координат.
Number Sequence. Это исходный массив элементов «t». Если соединить его со значением радиуса узла Circle.ByCenterPointRadius, центры окружностей будут по-прежнему отклоняться дальше от начального положения, но радиус окружностей будет увеличиваться, создавая необычный график спирали Фибоначчи.
3D-изображение этого объекта будет выглядеть замечательно.
Массив. После создания раковины наутилуса перейдем к параметрическим сеткам. Используя основной угол вращения спирали Фибоначчи, создайте сетку Фибоначчи, а на ее основе — модель расположения семян цветка подсолнуха.
Начнем с того же шага, что и в предыдущем упражнении: создадим массив точек спирали с помощью узла Point.ByCoordinates.
![](../images/5-3/2/math-part IV-01.jpg)
Далее выполните следующие небольшие действия, чтобы создать последовательность спиралей с различным вращением.
a. Geometry.Rotate. Существует несколько вариантов узла Geometry.Rotate. Убедитесь, что выбран узел с входными параметрами geometry, basePlane и degrees. Соедините узел Point.ByCoordinates с входным параметром «geometry». Щелкните правой кнопкой мыши этот узел и убедитесь, что для переплетения задано значение «Векторное произведение».
b. Plane.XY. Соедините узел с входным параметром basePlane. Вращение будет выполняться вокруг начала координат, которое совпадает с основанием спирали.
c. Number Range. Для входного параметра значений градусов необходимо создать несколько вращений. Это можно быстро сделать с помощью компонента Number Range. Соедините его с входным параметром degrees.
d. Number. Чтобы задать диапазон чисел, добавьте три узла Number в рабочую область в вертикальном порядке. В нисходящей последовательности назначьте значения 0.0,360.0 и 120.0 соответственно. Они будут определять вращение спирали. Обратите внимание на результаты вывода из узла Number Range после соединения с ним трех узлов Number.
Полученное изображение начинает напоминать водоворот. Скорректируйте некоторые параметры Number Range и посмотрите, как изменятся результаты.
Измените размер шага в узле Number Range, задав вместо значения 120.0 значение 36.0. Обратите внимание, что при этом генерируется больше вращений, и, следовательно, создается более плотная сетка.
Измените размер шага в узле Number Range, задав вместо значения 36.0 значение 3.6. Получится более плотная сетка, а у спирали будет отсутствовать направление. Итак, мы создали подсолнух.
Списки помогают упорядочивать данные. В операционной системе компьютера существуют файлы и папки. Приложение Dynamo устроено аналогично, только роль файлов в нем играют элементы, а папок — списки. Как и в операционной системе, в Dynamo существует множество способов создания, изменения и запроса данных. В этой главе рассказывается о том, как управлять списками в Dynamo.
Список — это набор элементов или компонентов. Возьмем, к примеру, связку бананов. Каждый банан является элементом списка (или связки). Проще взять в руки связку бананов, чем брать бананы по одному. Точно так же работать с элементами, сгруппированными по параметрическим связям в структуре данных, проще, чем с отдельными элементами.
Фотография предоставлена Августусом Бину (Augustus Binu).
Когда мы идем в магазин, мы кладем все, что купили, в пакет. Этот пакет также является списком. Мы хотим испечь банановый кекс, и нам нужно три связки бананов (мы печем очень большой кекс). Пакет представляет собой список связок, а каждая связка представляет собой список бананов. Пакет — это список списков (двумерный), а банан — это простой список (одномерный).
В Dynamo данные в списках упорядочиваются, и первому элементу в каждом списке присваивается индекс 0. Ниже мы рассмотрим то, как задать список в Dynamo, а также то, как разные списки могут быть связаны друг с другом.
Первому элементу в списке всегда назначается индекс 0, а не 1, и поначалу это может показаться странным. Поэтому запомните, что, если речь идет о первом элементе в списке, подразумевается элемент с индексом 0.
Например, если бы вам потребовалось посчитать количество пальцев на правой руке, то вы бы начали считать с 1 до 5. Однако если бы вам потребовалось внести ваши пальцы в список, то приложение Dynamo назначило бы им индексы от 0 до 4. Это может показаться странным тем, кто только начинает заниматься программированием, однако индекс, отсчитываемые от нуля, является стандартным для большинства вычислительных систем.
Обратите внимание, что такой список по-прежнему включает пять элементов, просто в нем используется система отсчета от нуля, а не от единицы. Элементы списка не обязательно должны быть числами. Это могут быть данные любого типа, который поддерживается в Dynamo, например точки, кривые, поверхности, семейства и т. д.
a. Индекс
b. Точка
c. Элемент
Зачастую самым простым способом узнать тип данных в списке является подключение узла Watch к порту вывода другого узла. По умолчанию узел Watch автоматически отображает все индексы в левой части списка, а элементы данных — в правой.
Эти индексы играют ключевую роль при работе со списками.
При работе со списками требуемые входные и выходные данные различаются в зависимости от используемого узла Dynamo. Для примера возьмем список из пяти точек и соединим его порт вывода с двумя разными узлами Dynamo: PolyCurve.ByPoints и Circle.ByCenterPointRadius:
Порт ввода points узла PolyCurve.ByPoints выполняет поиск элемента "Point[]". Этот элемент представляет собой список точек.
Выходные данные узла PolyCurve.ByPoints — это элемент PolyCurve, созданный на основе списка из пяти точек.
Порт ввода centerPoint узла Circle.ByCenterPointRadius запрашивает элемент "Point".
Выходные данные Circle.ByCenterPointRadius представляют собой список из пяти окружностей, центры которых соответствуют точкам из исходного списка.
Узлы PolyCurve.ByPoints и Circle.ByCenterPointRadius используют одни и те же входные данные, однако узел Polycurve.ByPoints на выходе дает одну сложную кривую, а узел Circle.ByCenterPointRadius — пять окружностей с центрами в каждой точке. На интуитивном уровне это кажется понятным, так как сложная кривая строится путем соединения всех пяти точек, а окружности создают отдельную окружность в каждой точке. Что же происходит с данными?
При наведении указателя мыши на порт ввода points узла Polycurve.ByPoints можно увидеть, что этому порту требуется элемент Point[]. Обратите внимание на скобки в конце. Этот элемент представляет список точек, и чтобы создать сложную кривую, в качестве входных данных этому узлу требуется отдельный список точек для каждой кривой. В результате узел объединяет каждый список в одну сложную кривую.
Порт ввода centrePoint узла Circle.ByCenterPointRadius запрашивает элемент Point. Этому узлу требуется одна точка, являющаяся отдельным элементом, для определения центра окружности. Поэтому на основе тех же входных данных мы получаем пять отдельных окружностей. Знание различий в использовании входных данных в Dynamo помогает лучше понимать, как узлы распоряжаются данными.
Сопоставление данных является проблемой, для которой не существует четкого решения. Это происходит, когда узел получается доступ к входным данных разных размеров. Изменение алгоритма сопоставления данных может привести к существенным различиям в результатах.
Рассмотрим в качестве примера узел, который создает сегменты линий между точками (Line.ByStartPointEndPoint). У него есть два входных параметра, которые используются для представления координат точек:
Самый простой способ — попарно соединять входные данные с одинаковыми индексами, пока один из списков не закончится. Это алгоритм по самому короткому списку. Узлы Dynamo используют этот алгоритм по умолчанию.
Алгоритм переплетения по самому длинному списку соединяет все входные элементы, используя некоторые элементы повторно, пока не закончатся оба списка:
Наконец, при использовании метода «Векторное произведение» создаются все возможные соединения:
Как мы видим, прочертить линию через эти наборы точек можно разными способами. Параметры переплетения можно просмотреть, щелкнув центр узла правой кнопкой мыши и выбрав меню «Переплетение».
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
Для изучении операций переплетения ниже мы воспользуемся этим базовым файлом, чтобы определить самый короткий и самый длинный списки, а также векторное произведение.
Измените настройку переплетения узла Point.ByCoordinates в графике выше, оставив остальные элементы без изменений.
При выборе Самый короткий список в качестве варианта переплетения (также является вариантом по умолчанию) мы получаем базовую диагональную линию, состоящую из пяти точек. Пять точек — это длина наименьшего списка. Таким образом, переплетение по самому короткому списку прекращается по достижении конца этого списка.
При изменении способа переплетения на Самый длинный список вы получите диагональную линию, которая имеет продолжение по вертикали. Аналогично схематическому изображению выше, последний элемент короткого списка используется повторно, пока не будет достигнут конец более длинного списка.
Изменив способ переплетения на Векторное произведение, вы получите все возможные соединения между списками, в результате чего создается сетка 5 х 10 точек. Эта структура данных эквивалентна векторному произведению, показанному в схематическом изображении выше, однако данные теперь являются списком списков. Путем соединения сложной кривой можно увидеть, что каждый список определяется значением X, в результате чего образуется ряд вертикальных линий.
Словари представляют собой набор данных, который связан с другим объектом данных, известным как ключ. Словари позволяют выполнять поиск, удаление и вставку данных в коллекциях.
По сути, словарь является эффективным механизмом поиска данных.
Функции работы со словарями присутствовали во многих версиях Dynamo. В приложении Dynamo 2.0 представлен новый способ управления данными этого типа.
Изображение предоставлено sixtysecondrevit.com
Определившись с тем, что такое список, поговорим о том, какие операции можно выполнять с ним. Представим список в виде колоды карт. Колода — это список, а каждая карта — элемент.
Фото предоставлено Кристианом Гидлефом (Christian Gidlöf)
Какие запросы доступны в списке? Это возможность вызова существующих свойств.
Сколько карт в колоде? 52.
Количество мастей? 4.
Из какого материала они изготовлены? Бумага.
Какова их длина? 3,5 дюйма, или 89 мм.
Какова их ширина? 2,5 дюйма, или 64 мм.
Какие действия можно выполнять со списком? Это изменяет список в зависимости от конкретной операции.
Колоду можно перемешать.
Колоду можно отсортировать по значению.
Колоду можно отсортировать по масти.
Колоду можно разделить.
Колоду можно раздать отдельным игрокам.
Можно выбрать отдельную карту из колоды.
У всех перечисленных выше операций есть аналогичные узлы Dynamo для работы со списками типовых данных. На уроке ниже будут рассмотрены основные операции, которые можно выполнять со списками.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов с примерами можно найти в приложении.
На изображении ниже показан базовый график для построения линий между двумя окружностями с целью представления основных операций со списками. Далее рассматривается управление данными в списке и демонстрируются визуальные результаты с помощью действий со списком.
Начните с узла Code Block со значением
500;
.Соедините его с входным параметром «x» узла Point.ByCoordinates.
Соединим узел из предыдущего шага с входным параметром origin узла Plane.ByOriginNormal.
Соединим узел из предыдущего шага с входным параметром plane узла Circle.ByPlaneRadius
С помощью узла Code Block укажите значение
50;
в качестве значения параметра radius. Это будет первая окружность.С помощью узла Geometry.Translate переместим окружность вверх на 100 единиц в направлении Z.
С помощью узла Code Block задайте диапазон из десяти чисел от 0 до 1, используя следующую строку кода:
0..1..#10;
.Соединим блок кода из предыдущего шага с входным значением param двух узлов Curve.PointAtParameter. Соединим узел Circle.ByPlaneRadius с входным параметром curve верхнего узла, а узел Geometry.Translate с входным параметром curve узла под ним.
С помощью узла Line.ByStartPointEndPoint соедините два узла Curve.PointAtParameter.
Скачайте файл с примером, щелкнув ссылку ниже.
Полный список файлов с примерами можно найти в приложении.
Узел List.Count сравнительно прост: он подсчитывает количество значений в списке и возвращает это число. При работе со списками списков в использовании этого узла появляются дополнительные нюансы. О них мы поговорим в следующих разделах.
Узел **List.Count ****** возвращает количество линий в узле Line.ByStartPointEndPoint. В данном случае значение равно 10, что соответствует количеству точек, созданных с помощью исходного узла Code Block.
Скачайте файл с примером, щелкнув ссылку ниже.
Полный список файлов с примерами можно найти в приложении.
List.GetItemAtIndex — основной способ запроса элемента в списке.
Сначала щелкните правой кнопкой мыши узел Line.ByStartPointEndPoint, чтобы отключить его предварительный просмотр.
С помощью узла List.GetItemAtIndex выбираем индекс 0 или первый элемент в списке линий.
Измените значение регулятора от 0 до 9, чтобы выбрать другой элемент с помощью List.GetItemAtIndex.
Скачайте файл с примером, щелкнув ссылку ниже.
Полный список файлов с примерами можно найти в приложении.
Узел List.Reverse располагает все элементы в списке в обратном порядке.
Для корректной визуализации обращенного списка линий создайте дополнительные линии, изменив значение узла Code Block на
0..1..#50;
.Создайте копию узла Line.ByStartPointEndPoint, вставьте узел List.Reverse между узлом Curve.PointAtParameter и вторым узлом Line.ByStartPointEndPoint.
Используйте узлы Watch3D для предварительного просмотра двух различных результатов. Первый узел показывает результат без обращенного списка. Линии соединяются вертикально с точками напротив. Второй узел показывает результат обращения списка, где все точки соединяются с точками напротив в обратном порядке.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов с примерами можно найти в приложении.
List.ShiftIndices — это удобный инструмент для создания скручиваний или спиралей и других подобных манипуляций с данными. Этот узел смещает элементы в списке на заданное количество индексов.
В том же сценарии, где был создан обращенный список, вставьте узел List.ShiftIndices между узлами Curve.PointAtParameter и Line.ByStartPointEndPoint.
С помощью узла Code Block укажите значение 1 для сдвига списка на один индекс.
Изменение незначительное, но все линии в нижнем узле Watch3D сместились на один индекс при соединении с другим набором точек.
Если увеличить значение в узле Block Code, например, до 30, в диагональных линиях появляется существенное различие. В данном случае сдвиг работает аналогично диафрагме камеры, закручивая исходную цилиндрическую форму.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов с примерами можно найти в приложении.
Узел List.FilterByBooleanMask удаляет определенные элементы на основе списка логических операций или значений «Истина»/«Ложь».
Чтобы создать список значений «Истина» или «Ложь», необходимо выполнить несколько дополнительных действий.
С помощью узла Code Block задайте выражение со следующим синтаксисом:
0..List.Count(list);
. Соединим узел Curve.PointAtParameter с входным параметром list. Этот процесс будет рассмотрен подробнее в главе о блоках кода, но в данном случае строка кода дает список, где представлены все индексы узла Curve.PointAtParameter.С помощью узла %** (модуль)** соедините выходной параметр узла Code Block с входным параметром x, а значение 4 с входным параметром y. Это позволит вычислить остаток при делении списка индексов на 4. Узел «Коэффициент» очень полезен при создании массивов. Все значения будут представлять собой возможный остаток от 4: 0, 1, 2, 3.
Благодаря узлу %** (модуль)** мы знаем, что значение 0 означает делимость индекса на 4 (0, 4, 8 и т. д.). С помощью узла == можно проверить делимость по значению 0.
Узел Watch выводит лишь следующий результат: массив истинных и ложных значений в виде true,false,false,false.....
Соедините этот массив с входным параметром mask обоих узлов List.FilterByBooleanMask.
Соедините узел Curve.PointAtParameter с входными параметрами list узла List.FilterByBooleanMask.
Выходными данными для Filter.ByBooleanMask будут_in_ и out. In — это значения, которым было присвоено значение маски true, а out — значения, которым было присвоено значение false. Соедините выходные параметры in с входными параметрами startPoint и endPoint узла Line.ByStartPointEndPoint, создав тем самым отфильтрованный список линий.
Узел Watch3D показывает, что количество линий меньше, чем количество точек. Отфильтровав только истинные значения, мы выбрали 25 % узлов.
Добавим еще больше уровней в иерархию и углубимся в нашу кроличью нору. Структура данных может быть гораздо более объемной, чем простой двумерный список списков. Поскольку списки являются самостоятельными элементами в Dynamo, мы можем создать данные с практически неограниченным количеством измерений.
Это похоже на матрешку. Каждый список можно рассматривать как один контейнер, который содержит несколько элементов. Каждый список обладает собственными свойствами и рассматривается как отдельный объект.
Набор матрешек (фотография предоставлена ) является аналогией многомерных списков. Каждый слой представляет список, и каждый список содержит элементы. В Dynamo каждый контейнер может содержать несколько контейнеров (представляющих элементы каждого списка).
Многомерные списки сложно объяснить визуально, но в данном разделе есть несколько упражнений, которые помогут вам разобраться в работе со списками, число измерений которых превышает два.
Сопоставление — возможно, самый сложный аспект управления данными в Dynamo, особенно когда речь идет о сложных иерархических структурах, состоящих из списков. В рамках приведенных ниже упражнений мы рассмотрим случаи, в которых следует использовать сопоставление и комбинации при работе с многомерными данными.
Основные сведения по работе с узлами List.Map и List.Combine можно найти в предыдущем разделе. Эти узлы будут использованы для работы со сложной структурой данных в последнем из приведенных ниже упражнений.
Скачайте файл с примером, щелкнув ссылку ниже.
Полный список файлов с примерами можно найти в приложении.
Это первое из трех упражнений, направленных на работу с импортированной геометрией. От упражнения к упражнению структура данных будет усложняться.
Начнем с файла SAT, расположенного в папке с файлами для упражнения. Добавим его в приложение с помощью узла File Path.
Узел Geometry.ImportFromSAT импортирует геометрию в Dynamo и отображает ее в виде двух поверхностей.
Для простоты в этом упражнении вы будете работать только с одной поверхностью.
Чтобы выбрать верхнюю поверхность, задайте индекс 1. Для этого добавьте узел List.GetItemAtIndex.
Отключите предварительный просмотр геометрии в области предварительного просмотра Geometry.ImportFromSAT.
Теперь нужно преобразовать поверхность в сетку точек.
1. С помощью узла Code Block вставьте две следующие строки кода:
0..1..#10;
0..1..#5;
.2. Используя узел Surface.PointAtParameter, соедините два значения Code Block с входными параметрами «u» и v. Задайте для параметра Переплетение этого узла значение Векторное произведение.
3. Полученная структура данных отображается в области предварительного просмотра Dynamo.
Затем используйте точки из последнего шага для создания десяти кривых вдоль поверхности.
Чтобы отобразить структуру данных, соедините узел NurbsCurve.ByPoints с портом вывода узла Surface.PointAtParameter.
Для получения более четкого результата можно отключить предварительный просмотр в узле List.GetItemAtIndex.
Базовый узел List.Transpose позволяет поменять местами столбцы и строки в списке списков.
При соединении порта вывода узла List.Transpose с узлом NurbsCurve.ByPoints вы получите пять кривых, идущих горизонтально вдоль поверхности.
Для получения того же результата можно отключить предварительный просмотр в узле NurbsCurve.ByPoints на предыдущем шаге.
Усложним задачу. Предположим, что нам нужно выполнить определенное действие с кривыми, которые мы получили в предыдущем упражнении. Например, нужно связать эти кривые с другой поверхностью и выполнить лофтинг между ними По сути, логика остается прежней, но задача требует более внимательной работы со структурой данных.
Начнем с операции, уже знакомой вам по предыдущему упражнению. Изолируйте верхнюю поверхность импортированной геометрии с помощью узла List.GetItemAtIndex.
Используя узел Surface.Offset, задайте значение 10, чтобы сместить поверхность.
Как и в предыдущем упражнении, добавьте узел Code Block с двумя следующими строками кода:
0..1..#10;
0..1..#5;
.Соедините порты вывода этого узла с двумя узлами Surface.PointAtParameter и задайте для параметра Переплетение каждого из них значение Векторное произведение. Один из этих узлов соединен с исходной поверхностью, а второй — с поверхностью смещения.
Отключите предварительный просмотр этих поверхностей.
Как и в предыдущем упражнении, соедините порты вывода с двумя узлами NurbsCurve.ByPoints. В результате отображаются кривые, соответствующие двум поверхностям.
С помощью узла List.Create можно объединить два набора кривых в один список списков.
В результате создаются два списка с десятью элементами, каждый из которых представляет собой связанный набор NURBS-кривых.
С помощью узла Surface.ByLoft можно создать визуальное представление этой структуры данных. Узел выполняет лофтинг для всех кривых в каждом списке.
Отключите предварительный просмотр узла Surface.ByLoft на предыдущем шаге.
Как вы помните, узел List.Transpose позволяет поменять местами столбцы и строки в списке списков. В результате использования этого узла два списка из десяти кривых каждый преобразуются в десять списков из двух кривых каждый. Теперь каждая NURBS-кривая связана с соседней кривой на другой поверхности.
С помощью узла Surface.ByLoft мы получили реберную конструкцию.
Далее демонстрируется альтернативный процесс получения этого результата
Перед началом отключите предварительный просмотр Surface.ByLoft во избежание путаницы.
Вместо узла List.Transpose можно использовать узел List.Combine. Он выполняет роль «комбинатора» для каждого вложенного списка.
В данном случае мы используем List.Create в качестве «комбинатора» для создания списка по каждому элементу во вложенных списках.
Добавив узел Surface.ByLoft, мы получаем те же поверхности, что и на предыдущем шаге. В данном случае узел Transpose является более простым вариантом, но при работе с еще более сложной структурой данных надежнее будет использовать узел List.Combine.
Вернемся на несколько шагов назад. Если вы хотите изменить ориентацию кривых в реберной конструкции, узел List.Transpose следует применить до соединения с узлом NurbsCurve.ByPoints. В результате столбцы и строки поменяются местами, и мы получим пять горизонтальных ребер.
Продолжаем усложнять задачи. В этом упражнении мы используем обе импортированные поверхности, чтобы создать сложную иерархическую структуру данных. По сути, вам предстоит выполнить то же самое действие, пользуясь той же самой логикой, что и ранее.
Вернемся к файлу, импортированному в предыдущем упражнении.
Как и в предыдущем упражнении, используйте узел Surface.Offset, чтобы задать значение смещения, равное 10.
Обратите внимание, что добавление узла смещения привело к созданию двух поверхностей.
Как и в предыдущем упражнении, добавьте узел Code Block с двумя следующими строками кода:
0..1..#20;
0..1..#20;
.Соедините порты вывода этого узла с двумя узлами Surface.PointAtParameter и задайте для параметра «Переплетение» каждого из них значение Векторное произведение. Один из этих узлов соединен с исходными поверхностями, а второй — с поверхностями смещения.
Как и в предыдущем упражнении, соедините порты вывода с двумя узлами NurbsCurve.ByPoints.
Посмотрите на выходные данные узла NurbsCurve.ByPoints и обратите внимание, что они представляют собой список, состоящий из двух списков, что является более сложной структурой, чем в предыдущем упражнении. Данные упорядочиваются по базовой поверхности, поэтому в структуру данных добавлен еще один уровень.
Обратите внимание, что структура данных в узле Surface.PointAtParameter стала более сложной. В нем представлен список, состоящий из списков списков.
Перед продолжением отключите предварительный просмотр существующих поверхностей.
С помощью узла List.Create объедините NURBS-кривые в одну структуру данных, чтобы создать список, состоящий из списков списков.
При подключении узла Surface.ByLoft мы получаем новую версию исходных поверхностей, так как они остаются в собственном списке в соответствии с исходной структурой данных.
В предыдущем упражнении мы использовали узел List.Transpose для создания реберной конструкции. В этом случае данная функция не подходит. Перенос следует использовать с двумерными списками, но мы имеем дело с трехмерным списком, поэтому перестановка столбцов и строк не сработает. Поскольку списки являются объектами, то узел List.Transpose выполнит перестановку между списками с вложенными списками, но она не затронет NURBS-кривые в списках на уровень ниже.
В этом случае List.Combine является более подходящим инструментом. При работе с более сложными структурами данных используются узлы List.Map и List.Combine.
Используя List.Create в качестве «комбинатора», создайте структуру данных, которая лучше подойдет для ваших целей.
Структуру данных все еще требуется перенести на один уровень вниз по иерархии. Для этого используйте узел List.Map. Его работа аналогична узлу List.Combine, однако в нем используется только один список входных данных, а не два или больше.
К узлу List.Map будет применена функция List.Transpose, которая меняет местами столбцы и строки вложенных списков в главном списке.
Наконец, выполните лофтинг между NURBS-кривыми с использованием соответствующей иерархии данных, чтобы получить реберную конструкцию.
Добавим глубину геометрии с помощью узла Surface.Thicken с входными параметрами, как показано на изображении.
Будет полезно добавить поверхность, поддерживающую конструкцию, поэтому добавьте еще один узел Surface.ByLoft и используйте в качестве входного параметра первый вывод узла NurbsCurve.ByPoints из предыдущего шага.
Чтобы не перегружать экран, отключите предварительный просмотр этих узлов. Щелкните узел правой кнопкой мыши и снимите флажок «Предварительный просмотр», чтобы лучше рассмотреть результат.
Теперь увеличьте толщину выбранных поверхностей.
В результате мы получили нечто, похожее на слегка неустойчивое кресло-качалку. Зато сколько данных ушло на его создание!
Наконец, изменим направление бороздок. Для этого выполните процедуру, аналогичную преобразованию, которое вы уже использовали ранее.
Чтобы заполнить еще один уровень иерархии, используйте узел List.Map с функцией List.Tranpose, чтобы изменить направление NURBS-кривых.
Если требуется увеличить количество канавок, то данные узла Code Block можно изменить на следующие:
0..1..#20;
0..1..#30;
.
Если первая версия кресла-качалки была обтекаемой, то вторая получилась более похожей на колесо внедорожника.
Добавим еще один уровень в иерархию. Если взять колоду карт из первого примера и создать рамку, в которой будет находиться несколько колод, то эта рамка будет представлять собой список колод, а каждая колода — список карт. Это и есть список списков. В качестве аналогичного примера для этого раздела ниже представлен список столбиков монет, каждый из которых содержит список монет.
Какие запросы доступны в таком списке списков? Это возможность вызова существующих свойств.
Сколько всего типов монет? 2.
Какова ценность типов монет? $0.01 и $0.25.
Какие материалы используются для изготовления монет номиналом 0,25 долл. США? 75 % меди и 25 % никеля.
Какие материалы используются для изготовления цента? 97,5 % цинка и 2,5 % меди.
Какие действия можно выполнять со списком списков? Они приведут к изменению списка списков в зависимости от конкретной операции.
Выбрать один столбик из монет номиналом 1 или 25 центов.
Выбрать одну монету номиналом 1 или 25 центов.
Переупорядочить столбики.
Перемешать столбики.
Для каждой из перечисленных выше операций в Dynamo имеется аналогичный узел. Поскольку мы работаем с абстрактными данными, а не с физическими объектами, необходимо установить набор правил, определяющих порядок перемещения вверх и вниз по иерархии данных.
При работе со списками списков данные располагаются по слоям и имеют сложную структуру, но это дает возможность выполнять ряд уникальных параметрических операций. Остановимся подробнее на основных операциях, оставив другие для последующих занятий.
Скачайте файл с примером, щелкнув ссылку ниже.
Полный список файлов с примерами можно найти в приложении.
В данном разделе необходимо усвоить один базовый принцип: Dynamo рассматривает сами по себе списки как объекты. Эта нисходящая иерархия разработана с учетом объектно-ориентированного программирования. Вместо выбора вложенных элементов с помощью, например, команды List.GetItemAtIndex в Dynamo будет выбран индекс основного списка в структуре данных. Этот элемент, в свою очередь, может быть другим списком. Рассмотрим этот вопрос подробнее на примере изображения ниже.
С помощью узла Code Block было задано два диапазона:
0..2; 0..3;
.Эти диапазоны соединены с узлом Point.ByCoordinates, а в качестве переплетения выбран вариант Cross Product (векторное произведение). При этом создается сетка точек, а в качестве выходных данных возвращается список списков.
Обратите внимание, что узел Watch содержит 3 списка с 4 элементами в каждом.
При использовании функции List.GetItemAtIndex с индексом 0 Dynamo выберет первый список и все его содержимое. Другие программы могут выбрать первый элемент каждого списка в структуре данных, но в Dynamo при работе с данными используется иерархия «сверху вниз».
Скачайте файл с примером, щелкнув ссылку ниже.
Полный список файлов с примерами можно найти в приложении.
Функция Flatten удаляет все уровни в структуре данных. Это удобно, если для выполнения операции не требуется наличие иерархий данных, но имеются определенные риски, так как удаляется информация. В примере ниже показан результат выравнивания списка данных.
Вставьте одну строку кода для определения диапазона в узле Code Block:
-250..-150..#4;
.При вставке блока кода во входные данные x и y узла Point.ByCoordinates в качестве варианта переплетения укажем Cross Product (векторное произведение), чтобы получить сетку точек.
Узел Watch показывает наличие списка списков.
Узел PolyCurve.ByPoints создаст ссылки для каждого списка и построит соответствующую сложную кривую. Обратите внимание, что в области предварительного просмотра Dynamo отобразятся четыре сложные кривые, представляющие каждый ряд сетки.
После вставки функции Flatten перед узлом сложной кривой был создан один список для всех точек. Узел PolyCurve.ByPoints создает ссылку для списка, чтобы создать одну кривую, а так как все точки находятся в одном списке, получается одна зигзагообразная сложная кривая, которая проходит по всему списку точек.
Можно также выровнять изолированные уровни данных. С помощью узла List.Flatten можно указать определенное количество уровней данных, чтобы выполнить выравнивание от верхнего уровня иерархии. Это очень полезный инструмент при работе со сложными структурами данных, которые могут быть не всегда нужны в рабочем процессе. Еще один вариант — использовать узел Flatten в качестве функции в List.Map. Далее мы подробнее обсудим List.Map.
Скачайте файл с примером, щелкнув ссылку ниже.
Полный список файлов с примерами можно найти в приложении.
При параметрическом моделировании бывает необходимо изменить структуру данных в существующем списке. С этой целью можно использовать множество других узлов, из которых Chop — самая базовая версия. С помощью функции Chop можно разделить список на вложенные списки с заданным количеством элементов.
Команда Chop (обрезка) делит списки на основе заданной длины списка. В некотором смысле обрезка обратна выравниванию: вместо упрощения структуры данных она добавляет в нее новые уровни. Это удобный инструмент для геометрических операций, таких как в примере ниже.
Скачайте файл с примером, щелкнув ссылку ниже.
Полный список файлов с примерами можно найти в приложении.
Узел List.Map/Combine позволяет применить заданную функцию к списку входных данных, но на один шаг вниз по иерархии. Набор комбинаций аналогичен команде Maps, за исключением наличия нескольких наборов входных данных, соответствующих входным данным заданной функции.
В качестве краткого введения рассмотрим узел List.Count из предыдущего раздела.
Узел List.Count подсчитывает все элементы в списке. Мы воспользуемся этим для демонстрации работы List.Map.
Вставьте следующие две строки кода в узел Code Block:
-50..50..#Nx; -50..50..#Ny;
.После ввода этих данных блок кода создаст два набора входных данных для Nx и Ny.
С помощью двух узлов Integer Slider задайте значения Nx и Ny путем их присоединения к Code Block.
Соедините каждую строку блока кода с соответствующими входными данными X и Y узла Point.ByCoordinates. Щелкните узел правой кнопкой мыши, выберите «Lacing» (переплетение), а затем Cross Product (векторное произведение). Будет создана сетка точек. Так как мы определили диапазон от -50 до 50, он охватывает сетку Dynamo по умолчанию.
Созданные точки отображаются в узле Watch. Обратите внимание на структуру данных. Мы создали список списков. Каждый список представляет собой ряд точек сетки.
Вставьте узел List.Count в выходные данные узла Watch из предыдущего шага.
Соедините узел Watch с выходными данными List.Count.
Обратите внимание, что узел List.Count выдает значение 5. Это значение равно переменной Nx, заданной в блоке кода. Почему?
Во-первых, в качестве основного входного параметра для создания списков в узле Point.ByCoordinates используется входной параметр «x». Если Nx равно 5, а Ny — 3, получается список, состоящий из 5 списков, в каждом из которых содержится 3 элемента.
Так как Dynamo рассматривает списки сами по себе как объекты, то узел List.Count применяется к основному списку в иерархии. В результате получается значение 5 (количество списков в главном списке).
С помощью узла List.Map спустимся на один шаг вниз по иерархии и на этом уровне выполним функцию.
Обратите внимание, что узел List.Count не имеет входных данных. Так как узел List.Count используется в качестве функции, он будет применен к каждому отдельному списку на один шаг вниз по иерархии. Пустые входные данные узла List.Count соответствуют входным данным списка в узле List.Map.
Результаты узла List.Count теперь выдают список из 5 элементов, в каждом из которых имеется значение 3. Это соответствует длине каждого вложенного списка.
В этом упражнении узел List.Combine используется, чтобы продемонстрировать, как его с его помощью можно применять функцию к отдельным спискам объектов.
Начните с настройки двух списков точек.
Используйте узел Sequence для создания 10 значений, каждое с увеличением на 10.
Соедините результат с входным параметром «x» узла Point.ByCoordinates. В Dynamo будет создан список точек.
Добавьте второй узел Point.ByCoordinates в рабочее пространство. Используйте тот же выходной параметр Sequence в качестве входного параметра «x», но используйте Interger Slider в качестве входного параметра «y» и задайте для него значение 31 (оно может быть любым, если не перекрывается первым набором точек), чтобы два набора точек не перекрывались друг другом.
Используйте List.Combine, чтобы применить функцию к объектам в 2 отдельных списках. В данном случае это будет простая функция рисования линий.
Добавьте узел List.Combine в рабочее пространство и соедините 2 набора точек в качестве входных данных list0 и list1.
Используйте узел Line.ByStartPointEndPoint в качестве входной функции для узла List.Combine.
После этого 2 набора точек с помощью функции Line.ByStartPointEndPoint архивируются или связываются вместе, и в Dynamo возвращаются 10 строк.
См. упражнение в многомерных списках для просмотра другого примера использования List.Combine.
Скачайте файл с примером, щелкнув ссылку ниже.
Полный список файлов с примерами можно найти в приложении.
В отличие от List.Map функция List@Level позволяет выбрать необходимый уровень списка непосредственно на входном порте узла. Эту функцию можно применять ко всем поступающим входным данным узлов и получать доступ к уровням списков быстрее, чем при использовании других методов. Просто сообщите узлу, какой уровень списка требуется использовать в качестве входных данных, и он сам сделает все необходимое.
В этом упражнении с помощью функции List@Level изолируется определенный уровень данных.
Начнем с простой 3D-сетки точек.
Поскольку сетка создается с диапазоном для X, Y и Z, структура данных будет иметь 3 уровня: список X, список Y и список Z.
Эти уровни расположены на разной высоте (уровнях). Они указаны в нижней части марки предварительного просмотра. Столбцы уровня списка соответствуют данным списка выше, что позволяет быстрее найти нужный уровень.
Уровни списка располагаются в обратном порядке, так что данные самого низкого уровня всегда находятся на высоте L1. Благодаря этому графики будут функционировать запланированным образом, даже если что-то изменится в предыдущем алгоритме.
Чтобы использовать функцию List@Level, нажмите кнопку «>». В меню отобразятся два флажка.
Использовать уровни: этот вариант включает функцию List@Level. Если этот флажок установлен, можно с помощью мыши выбрать уровни списка входных данных, которые будут использованы узлом. С помощью этого меню можно быстро проверить различные конфигурации уровней, щелкая мышью выше или ниже.
Сохранить структуру списков: если установить этот флажок, можно будет сохранить структуру уровней этих входных данных. Иногда данные бывают сознательно разделены по вложенным спискам. Если установить этот флажок, можно сохранить структуру списка неизменной без какой-либо потери информации.
Благодаря этой простой 3D-сетке можно получить доступ к структуре списка и визуализировать ее, переключаясь между уровнями списка. Любая комбинация уровня списка и индекса возвращает собственный набор точек из исходного 3D-набора.
С помощью элемента @L2 в DesignScript можно выбрать только список на уровне 2. Список на уровне 2 с индексом 0 включает в себя только первый набор точек Y и возвращает только сетку XZ.
Если задать фильтр уровней L1, можно увидеть все содержимое первого уровня списка. Список на уровне 1 с индексом 0 включает в себя все 3D-точки в одноуровневом списке.
В аналогичном случае с L3 будут видны только точки третьего уровня списка. Список на уровне 3 с индексом 0 включает в себя только первый набор точек Z и возвращает только сетку XY.
В аналогичном случае с L4 будут видны только точки третьего уровня списка. Список на уровне 4 с индексом 0 включает в себя только первый набор точек X и возвращает только сетку YZ.
Несмотря на то, что данный конкретный пример можно также создать с помощью List.Map, функция List@Level существенно упрощает взаимодействие и доступ к данным узла. Ниже представлено сравнение методов List.Map и List@Level.
Оба метода предоставляют доступ к одним и тем же точкам, однако List@Level позволяет легко переключаться между слоями данных в одном узле.
Для доступа к сетке точек с помощью List.Map требуется добавить узел List.GetItemAtIndex в дополнение к List.Map. Для каждого нижестоящего уровня списка необходимо использовать дополнительный узел List.Map. В некоторых сложных списках для получения доступа к нужному уровню информации требуется включение в график значительного количества узлов List.Map.
В этом примере узел List.GetItemAtIndex с узлом List.Map возвращает тот же набор точек и ту же структуру списка, что и List.GetItemAtIndex со значением @L3.
Скачайте файл с примером, щелкнув ссылку ниже.
Полный список файлов с примерами можно найти в приложении.
Transpose (транспонирование) — это одна из основных функций при работе со списками списков. Как и в электронных таблицах, при транспонировании происходит перестановка столбцов и строк в структуре данных. Продемонстрируем это с помощью следующей базовой матрицы, а в следующем разделе покажем, как с помощью функции транспонирования создавать геометрические взаимосвязи.
Удалите узлы List.Count из предыдущего упражнения и перенесите их на геометрические объекты, чтобы увидеть, как структурированы данные.
Соедините узел PolyCurve.ByPoints с выходными данными узла Watch из узла Point.ByCoordinates.
На выходе отобразятся 5 сложных кривых, которые можно видеть в области предварительного просмотра Dynamo. Узел Dynamo выполняет поиск списка точек (в данном случае — списка списков точек) и создает из них одну сложную кривую. По сути, каждый список в структуре данных преобразован в кривую.
Узел List.Transpose переставляет все элементы со всеми списками в списке списков. Это может показаться сложным, но в Microsoft Excel используется точно такая же логическая схема транспонирования данных: перестановка столбцов со строками в структуре данных.
Обратите внимание на изменение в списках: после транспонирования структура, состоявшая из 5 списков с 3 элементами, изменилась на 3 списка с 5 элементами в каждом.
Кроме того, обратите внимание на изменение в геометрии: использование узла PolyCurve.ByPoints привело к появлению 3 сложных кривых в перпендикулярном направлении к исходным кривым.
Скачайте файл с примером, щелкнув ссылку ниже.
Полный список файлов с примерами можно найти в приложении.
В этом упражнении для редактирования поверхности используется логическая схема из предыдущего упражнения. Эту задачу можно решить интуитивным способом, однако при этом потребуется дополнительная навигация по структуре данных. Необходимо определить поверхность путем перемещения контрольной точки.
Начните со строки узлов выше. Создайте базовую поверхность, которая охватывает всю сетку Dynamo по умолчанию.
С помощью узла Code Block вставьте следующие две строки кода и соедините их с входными параметрами u и v узла Surface.PointAtParameter соответственно:
-50..50..#3;
-50..50..#5;
.Убедитесь, что для параметра Lacing (переплетение) узла Surface.PointAtParameter задано значение Cross Product (векторное произведение).
Узел Watch показывает, что имеется список из 3 списков, каждый из которых содержит 5 элементов.
На этом этапе следует запросить центральную точку в созданной сетке. Для этого выберите центральную точку в списке посередине. Логично, не так ли?
Чтобы убедиться в правильности выбора точки, можно щелкнуть элементы узла Watch для проверки правильности выбора элемента.
При помощи узла Code Block создайте базовую строку кода для запроса списка списков:
points[1][2];
С помощью функции Geometry.Translate переместите выбранную точку вверх в направлении оси Z на 20 единиц.
Кроме того, выберите ряд точек посередине с помощью узла List.GetItemAtIndex. Примечание. Как и при выполнении предыдущего шага, можно запросить список с помощью узла Code Block, используя строку
points[1];
.
Итак, мы успешно запросили центральную точку и переместили ее вверх. Теперь необходимо вставить эту перемещенную точку обратно в исходную структуру данных.
Сначала замените элемент списка, который был изолирован при выполнении предыдущего шага.
С помощью узла List.ReplaceItemAtIndex замените центральный элемент с помощью индекса 2 на замещающий элемент, соединенный с перемещенной точкой (Geometry.Translate).
Выходные данные показывают, что перемещенная точка была вставлена в набор входных данных элемента в середине списка.
После изменения списка необходимо вставить его обратно в исходную структуру данных — список списков.
Используя ту же логическую схему, заменим список в середине на измененный список с помощью узла List.ReplaceItemAtIndex.
Обратите внимание, что индекс этих двух узлов определяется узлами Code Block 1 и 2, что соответствует исходному запросу из узла Code Block (points[1][2]).
Если выбрать список с помощью index 1, то структура данных будет выделена в области предварительного просмотра Dynamo. Итак, мы успешно встроили перемещенную точку в исходную структуру данных.
Существует множество способов создания поверхности из этого набора точек. В данном случае необходимо создать поверхность за счет лофтинга кривых.
Создайте узел NurbsCurve.ByPoints и присоедините новую структуру данных для создания трех NURBS-кривых.
Соедините узел Surface.ByLoft с выходными данными из узла NurbsCurve.ByPoints. Получится модифицированная поверхность. Можно изменить исходное значение Z геометрии. Выполните преобразование и посмотрите, как изменится геометрия.
Dynamo 2.0 не только включает в себя узлы для работы со словарями, но и аналогичные новые функции в кода блоках.
Можно использовать как приведенный ниже синтаксис, так и представления узлов на основе DesignScript.
Поскольку словарь является типом объекта в Dynamo, с ним можно выполнять следующие действия.
Подобные виды взаимодействия особенно важны при соотнесении данных Revit со строками. Далее приводятся примеры использования этой функции Revit.
В Dynamo доступно большое количество базовых узлов, позволяющих решать широкий спектр задач визуального программирования. Однако иногда создание пользовательских узлов позволяет прийти к более быстрому, оригинальному или удобному для совместного использования решению. Такие узлы можно многократно использовать в разных проектах. Они позволяют упростить и очистить графики. Опубликовав их в Package Manager, этими узлами можно поделиться с другими пользователями Dynamo по всему миру.
В Dynamo 2.0 доступны различные узлы Dictionary для работы со словарями. К ним относятся узлы создания, действия и запроса.
1. С помощью метода Dictionary.ByKeysValues
создается словарь с заданными значениями и ключами. Количество записей определяется кратчайшим входным списком.
2. Метод Dictionary.Components
создает компоненты входного словаря. (Это функция, противоположная функции узла создания).
3. Метод Dictionary.RemoveKeys
создает объект словаря с удаленными входными ключами.
4. Метод Dictionary.SetValueAtKeys
создает словарь на основе входных ключей и значений, заменяющих текущее значение в соответствующих ключах.
5. Метод Dictionary.ValueAtKey
возвращает значение во входном ключе.
6. С помощью метода Dictionary.Count
можно узнать, сколько пар «ключ — значение» хранится в словаре.
7. Метод Dictionary.Keys
возвращает наименования ключей, хранящихся в настоящий момент в словаре.
8. Метод Dictionary.Values
возвращает значения, хранящиеся в настоящий момент в словаре.
Соотнесение данных с помощью словарей — это отличная альтернатива традиционным методам работы с индексами и списками.
Dynamo 2.0 включает новый тип данных — список, являющийся ответвлением типа данных словаря. Это нововведение может повлечь за собой существенные изменения в подходах к созданию и использованию данных в рамках рабочих процессов. До версии 2.0 словари и списки относились к одному типу данных. Если говорить коротко, то списки — это словари с целочисленными ключами.
Словарь — это тип данных, образуемый набором пар «ключ — значение». Ключ каждого набора является уникальным. Содержимое словаря не упорядочено. Поиск данных осуществляется с использованием ключа, а не по значению индекса, как в списке. В Dynamo 2.0 поддерживаются только строковые ключи.
Список — это тип данных, образуемый набором упорядоченных значений. В списках Dynamo в качестве индексов используются целочисленные значения.
В результате разделения словарей и списков словари получили своеобразный статус высшего класса: они позволяют легко и быстро хранить и находить значения, и для этого не нужно запоминать значения индекса или поддерживать строгую структуру списка на протяжении всего рабочего процесса. На этапе тестирования было выявлено значительное уменьшение размеров графиков при использовании словарей вместо нескольких узлов GetItemAtIndex
.
Синтаксис: обновления привели к изменениям в процессах запуска и использования словарей и списков в блоках кода.
В словарях используется следующий синтаксис: {key:value}
.
В списках используется следующий синтаксис: [value,value,value]
.
В библиотеку добавлены новые узлы, которые позволяют создавать, изменять и запрашивать словари.
Списки, созданные в блоках кода версии 1.x, при загрузке сценария автоматически обновляются до нового синтаксиса списка, в котором используются квадратные скобки [ ]
вместо фигурных { }
.
С точки зрения информатики как науки, словари, как и списки, являются наборами объектов. Элементы в списках хранятся с соблюдением определенного порядка. Содержимое словарей не упорядочивается. В словарях не используется последовательная нумерация (индексы). Вместо этого в них используются ключи.
На изображении ниже представлен пример возможного использования словаря. Во многих случаях словари используются для соотнесения двух элементов данных, которые могут не иметь прямой корреляции. В нашем случае испанский перевод английского слова соотносится с его оригиналом для поиска в дальнейшем.
Создайте словарь, чтобы связать два фрагмента данных.
Получите значение с помощью заданного ключа.
Вам когда-нибудь приходилось искать в Revit информацию по фрагменту данных?
Вы наверняка уже проделывали нечто похожее на описанное в следующем примере.
Процесс, проиллюстрированный ниже, включает следующие этапы: сбор всех помещений в модели Revit, получение индекса нужного помещения (по его номеру) и, наконец, извлечение этого помещения по индексу.
Объединение всех помещений в модели.
Номер необходимого помещения.
Получение номера помещения и определение индекса.
Получение помещения по индексу.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
А теперь посмотрите, как тот же процесс выглядит при использовании словарей. Сначала необходимо собрать все помещения в модели Revit.
Выберите нужную категорию Revit (в данном случае работа ведется с помещениями).
Запрограммируйте сбор всех таких элементов в Dynamo.
Данные, которые будут использоваться, — это номер помещения.
Теперь создайте словарь по заданным ключам и элементам.
Узел Dictionary.ByKeysValues создает словарь с соответствующими входными данными.
Данные
Keys
должны быть строковыми, а полеvalues
поддерживает разные типы объектов.
Наконец, извлеките помещение из словаря с номером помещения.
Порт
String
выдает ключ, который используется для поиска объекта в словаре.Метод Dictionary.ValueAtKey получает объект из словаря.
Используя аналогичную логику работы со словарями, можно создавать словари, содержащие сгруппированные объекты. Если нужно найти все помещения на конкретном этаже, измените приведенный выше график следующим образом.
Вместо использования номера помещения в качестве ключа, можно использовать значение параметра (в данном случае этаж).
Теперь можно сгруппировать помещения по этажу, на котором они находятся.
Когда элементы сгруппированы по этажам, можно использовать общие (уникальные) ключи в качестве ключей для словаря, а списки помещений — в качестве его элементов.
Наконец, используя этажи, заданные в модели Revit, выполните поиск в словаре всех помещений, расположенных на нужном этаже. Метод
Dictionary.ValueAtKey
использует имя этажа в качестве входных данных и возвращает объекты помещений на этом этаже.
Возможности использования словарей практически безграничны. Сама по себе возможность соотнесения данных BIM в Revit с тем или иным элементом открывает широкий спектр вариантов применения.
Готовые узлы, доступные в библиотеке Dynamo, поддерживают широкий спектр функциональных возможностей. Если требуются дополнительные возможности, например для внедрения повторяющихся процедур или разработки особого графика для демонстрации коллегам, в Dynamo можно создать собственные пользовательские узлы и пакеты.
Отрезок состоит из набора точек. В каждом отрезке должно быть не менее 2 точек. Один из наиболее распространенных способов создания отрезка в Dynamo — использование Line.ByStartPointEndPoint
для создания отрезка в Dynamo.
Фото предоставлено .
Примечание. Это упражнение было создано в предыдущей версии Dynamo. Большая часть функциональных возможностей List.Map была упразднена с добавлением функции List@Level . Дополнительные сведения см. в разделе ниже.
Примечание. Это упражнение было создано в предыдущей версии Dynamo. Большая часть функциональных возможностей List.Combine была упразднена с добавлением функции List@Level . Дополнительные сведения см. в разделе ниже.
Для определения списка в сокращенном языке блока кода используются квадратные скобки ([]). Это гораздо более быстрый и простой способ создания списков, чем с помощью узла List.Create. Узел Code Block подробно рассматривается в разделе . На изображении ниже показано, как можно задать список с несколькими выражениями с помощью блока кода.
Для упрощенного выбора определенных элементов, которые требуется извлечь из сложной структуры данных, в сокращенном языке узла Code Block используются квадратные скобки ([]). Узлы Code Block подробно рассматриваются в главе . На изображении ниже показано, как запросить список с несколькими типами данных с помощью блока кода.
Затем необходимо решить, какие ключи будут использоваться для поиска этих данных. Сведения о ключах см. в разделе .
Хотя программа Dynamo изначально разрабатывалась с прицелом на совместимость с Revit, ее можно использовать как универсальное средство визуального программирования и за пределами Revit. Программа Dynamo также интегрирована в Civil 3D, благодаря чему пользователи могут разрабатывать эффективные процедуры автоматизации для инфраструктурных проектов. Это очень полезный инструмент для решения разных задач, от типовых до самых сложных, который помогает экономить время, оптимизировать проекты и принимать более обоснованные проектные решения. Dynamo включает в себя набор узлов, разработанных специально для Civil 3D, а также библиотеки от сторонних разработчиков из числа участников сообщества пользователей.
В этой главе данного руководства мы рассмотрим Dynamo for Civil 3D, начиная с самых базовых понятий и заканчивая расширенными процессами.
После создания пользовательских узлов необходимо упорядочить и опубликовать их в формате пакетов. Пакеты упрощают хранение узлов, а также позволяют с легкостью делиться ими с другими пользователями Dynamo.
Пользовательские узлы создаются путем помещения стандартных и созданных разработчиками узлов в так называемый пользовательский узел Dynamo, который можно рассматривать как своего рода контейнер. При запуске такого узла-контейнера в графике происходит запуск всех содержащихся в нем компонентов. В результате получается удобная комбинация узлов для многократного использования и предоставления другим пользователям.
Если в графике присутствует несколько копий пользовательского узла, их все можно отредактировать одновременно, изменив базовый экземпляр этого узла. Это позволяет с легкостью редактировать график и адаптировать его к изменениям, которые могут возникнуть в проекте или рабочем процессе.
Главное преимущество пользовательских узлов — удобство совместной работы. Например, если опытный программист создает в Dynamo сложный график, который затем требуется передать проектировщику, не работавшему с Dynamo, то программист может упростить представление графика и сделать его максимально доступным для проектировщика. Пользовательский узел-контейнер, в который помещается график, можно открывать для редактирования его содержимого, однако внешний вид контейнера при этом может оставаться простым и аккуратным. Таким образом, пользовательские узлы позволяют делать графики Dynamo лаконичными и интуитивно понятными.
Создавать пользовательские узлы в Dynamo можно самыми разными способами. В примерах, которые приведены в этой главе, пользовательские узлы создаются с помощью функций интерфейса Dynamo. Программисты, интересующиеся возможностями форматирования в C# или Zero Touch, могут ознакомиться с подробным обзором на этой странице справки Wiki по Dynamo.
Перейдите в среду пользовательского узла, чтобы создать простой узел для расчета процентного соотношения. Среда пользовательского узла отличается от среды графика Dynamo, но работа в ней осуществляется на основе тех же принципов. Итак, пора создать первый пользовательский узел.
Чтобы создать пользовательский узел с нуля, запустите Dynamo и выберите «Пользовательский узел» или используйте сочетание клавиш CTRL + SHIFT + N в рабочей области.
Задайте имя, описание и категорию в диалоговом окне «Свойства пользовательского узла».
Имя: Percentage
Описание: расчет процентного соотношения между двумя значениями.
Категория: Math.Functions
Откроется рабочая область с желтым фоном, указывающим на то, что вы находитесь в среде пользовательского узла. В этом окне можно получить доступ ко всем стандартным узлам Dynamo, а также к узлам ввода и вывода, которые используются для обозначения данных, поступающих в пользовательский узел на входе и получаемых из него на выходе. Их можно найти в разделе «Input > Basic».
Inputs: узлы Input используются для настройки портов ввода пользовательского узла. Синтаксис узла ввода: имя_ввода : тип_данных = значение_по_умолчанию (необязательно).
Outputs: аналогично узлам ввода узлы вывода используются для настройки портов вывода пользовательского узла. К портам ввода и вывода можно добавлять пользовательские комментарии для указания типа входных и выходных данных. Подробную информацию см. в разделе Создание пользовательских узлов.
Этот пользовательский узел можно сохранить в файле DYF (вместо стандартного формата DYN), после чего он автоматически станет доступен в текущем и будущих сеансах. Пользовательский узел находится в разделе Add-ons библиотеки.
После создания первого пользовательского узла можно переходить к дальнейшим разделам, в которых подробнее рассматриваются функциональные возможности пользовательских узлов и процесс публикации типовых рабочих процессов. В следующем разделе представлен процесс разработки пользовательского узла, позволяющего переносить геометрию с одной поверхности на другую.
В Dynamo предусмотрено несколько способов создания пользовательских узлов. Их можно создавать с нуля на основе существующего графика или непосредственно на языке C#. В этом разделе рассматривается создание пользовательского узла в интерфейсе Dynamo на основе существующего графика. Этот метод идеально подходит для очистки рабочего пространства, а также для упаковки последовательности узлов с целью их повторного использования в другом месте.
На изображении ниже точка одной поверхности сопоставляется с другой точкой с помощью UV-координат. Этот принцип будет использоваться для создания панелей поверхности, ссылающихся на кривые в плоскости XY. В данном случае сформируем прямоугольные панели, но этим же способом можно создавать разнообразные панели с использованием UV-наложения. Это отличная возможность для разработки пользовательских узлов, так как данную процедуру можно повторять в этом же графике или в других рабочих процессах Dynamo.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
Начните с создания графика, который будет вложен в пользовательский узел. В этом примере с помощью UV-координат мы создадим график, который сопоставляет полигоны базовой поверхности с целевой поверхностью. Эта процедура UV-наложения используется часто, благодаря чему хорошо подходит для создания пользовательских узлов. Дополнительную информацию о поверхностях и UV-пространстве см. на странице Поверхность. Готовый график — _UVmapping\Custom-Node.dyn из скачанного ранее файла ZIP.
Code Block. Используйте эту строку для создания диапазона из 10 чисел от –45 до 45
45..45..#10;
.Point.ByCoordinates. Соедините выходные данные узла Code Block с входными данными x и y, выбрав в качестве переплетения перекрестную ссылку. При этом будет создана сетка точек.
Plane.ByOriginNormal. Соедините выходные данные Point с входными данными origin, чтобы создать плоскость в каждой из точек. Будет использован вектор нормали по умолчанию (0,0,1).
Rectangle.ByWidthLength. Соедините плоскости из предыдущего шага с выходными данными plane и с помощью узла Code Block со значением 10 задайте ширину и длину.
При этом появится сетка прямоугольников. Сопоставьте эти прямоугольники с целевой поверхностью, используя UV-координаты.
Polygon.Points. Соедините выходные данные Rectangle.ByWidthLength из предыдущего шага с входными данными polygon, чтобы извлечь угловые точки каждого прямоугольника. Именно эти точки будут сопоставляться с целевой поверхностью.
Rectangle.ByWidthLength. С помощью узла Code Block со значением 100 задайте ширину и длину прямоугольника. Это будет граница базовой поверхности.
Surface.ByPatch. Соедините Rectangle.ByWidthLength из предыдущего шага с входными данными closedCurve для создания базовой поверхности.
Surface.UVParameterAtPoint. Соедините выходные данные Point узла Polygon.Points с выходными данными Surface узла Surface.ByPatch для получения параметра UV в каждой точке.
Теперь, имея базовую поверхность и набор UV-координат, можно импортировать целевую поверхность и сопоставить точки между поверхностями.
File Path. Выберите путь к файлу поверхности, которую требуется импортировать. Файл должен иметь тип SAT. Нажмите кнопку Обзор... и перейдите к файлу UVmapping_srf.sat из скачанного ранее файла ZIP.
Geometry.ImportFromSAT. Для импорта поверхности присоедините путь к файлу. При этом в области предварительного просмотра геометрии должна появиться импортированная поверхность.
UV. Соедините выходные данные параметра UV с узлами UV.U и UV.V.
Surface.PointAtParameter. Присоедините импортированную поверхность, а также координаты u и v. Теперь на целевой поверхности должна появиться сетка 3D-точек.
Последний шаг — построение прямоугольных участков поверхности с помощью 3D-точек.
PolyCurve.ByPoints. Соедините точки на поверхности, чтобы построить сложную кривую через точки.
Boolean. Добавьте в рабочее пространство узел Boolean и соедините его с входными данными connectLastToFirst, задав значение True, чтобы замкнуть сложные кривые. При этом должны появиться прямоугольники, сопоставленные с поверхностью.
Surface.ByPatch. Соедините сложные кривые с входными данными closedCurve для создания участков поверхности.
Теперь выберите узлы, которые необходимо вложить в пользовательский узел, учитывая, какие входные и выходные данные должны быть у конечного узла. Пользовательский узел должен быть максимально гибким и пригодным для сопоставления любых полигонов, а не только прямоугольников.
Выберите следующие узлы (начиная с Polygon.Points), щелкните правой кнопкой мыши рабочее пространство и выберите «Создание пользовательского узла».
В диалоговом окне «Свойства пользовательского узла» присвойте пользовательскому узлу имя, введите описание и укажите категорию.
Имя: MapPolygonsToSurface
Описание: сопоставление полигонов из базы с целевой поверхностью
Категория в разделе «Надстройки»: Geometry.Curve
Пользовательский узел в значительной мере очистил рабочее пространство. Обратите внимание, что входным и выходным данным были присвоены имена, соответствующие исходным узлам. Отредактируйте пользовательский узел, чтобы сделать имена более описательными.
Дважды щелкните пользовательский узел, чтобы отредактировать его. Откроется рабочее пространство с желтым фоном, представляющее собой внутреннюю часть узла.
Inputs. Измените имена входных параметров, задав baseSurface и targetSurface.
Outputs. Добавьте дополнительный выходной параметр для сопоставленных многоугольников.
Сохраните пользовательский узел и вернитесь в исходное рабочее пространство. Внесенные изменения отражаются в узле MapPolygonsToSurface.
Для наглядности можно добавить к узлу Пользовательские комментарии. В комментариях можно указать сведения о типах входных и выходных данных или разъяснить функции узла. Комментарии отображаются при наведении курсора на входной или выходной параметр пользовательского узла.
Дважды щелкните пользовательский узел, чтобы отредактировать его. Снова откроется рабочее пространство с желтым фоном.
Начните редактировать блок Code Block Input. Чтобы создать комментарий, введите символы «//», а затем текст комментария. Добавьте любые пояснения к узлу. В данном случае будет дано описание входного параметра targetSurface.
Кроме того, задайте значение по умолчанию для входного параметра inputSurface, указав это значение в качестве типа входных данных. В данном случае в качестве значения по умолчанию будет задан исходный набор Surface.ByPatch.
Комментарии также можно применить к выходным параметрам.
Отредактируйте текст блока «Code Block» Output. Введите «//», а затем текст комментария. Добавьте пояснения к выходным параметрам Polygons и surfacePatches путем ввода для них подробного описания.
Наведите курсор на пользовательский узел Inputs, чтобы просмотреть комментарии.
Так как для входного параметра inputSurface задано значение по умолчанию, при запуске определения можно не вводить значение поверхности.
Вы создали пользовательский узел и применили его к определенному процессу на графике Dynamo. Это очень полезный узел, поэтому его надо сохранить в библиотеке Dynamo для использования в других графиках. Для этого нужно опубликовать узел локально. Этот процесс аналогичен публикации пакета, который будет рассмотрен подробнее в следующей главе.
Узел, опубликованный локально, станет доступен в библиотеке Dynamo после запуска нового сеанса. Если пользовательский узел не опубликован, его необходимо разместить в папке графика Dynamo, ссылающегося на этот узел (либо этот узел нужно импортировать в Dynamo с помощью меню Файл > Импорт библиотеки).
Пользовательские узлы и пакеты из Dynamo Sandbox можно публиковать в версии 2.17 и более поздних, если они не имеют зависимостей основного API. В более ранних версиях пользовательские узлы и пакеты можно публиковать только в Dynamo for Revit и Dynamo for Civil 3D.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
Продолжайте работу с пользовательским узлом, созданным в предыдущем разделе. После открытия пользовательского узла PointsToSurface график отображается в редакторе пользовательских узлов Dynamo. Пользовательский узел также можно открыть, дважды щелкнув его в редакторе графиков Dynamo.
Чтобы опубликовать пользовательский узел локально, щелкните правой кнопкой мыши в рабочей области и выберите Опубликовать данный пользовательский узел...
Введите все необходимые сведения, как показано на изображении выше, и выберите Опубликовать локально. Обратите внимание, что в поле «Группа» задается основной элемент, который будет доступен в меню Dynamo.
Выберите папку для хранения всех пользовательских узлов, которые планируется опубликовать локально. Приложение Dynamo будет проверять эту папку каждый раз при загрузке, поэтому она должна находиться в постоянном расположении. Перейдите к этой папке и нажмите Выбрать папку. Пользовательский узел Dynamo опубликован локально и теперь будет отображаться в библиотеке Dynamo при каждой загрузке программы.
Чтобы проверить расположение папки пользовательского узла, откройте меню Dynamo > Настройки > Параметры пакета > Пути к узлу и пакету.
В этом окне отображается список путей.
Documents\DynamoCustomNodes... — расположение пользовательских узлов, которые были опубликованы локально.
AppData\Roaming\Dynamo... — путь по умолчанию к пакетам Dynamo, установленным из интернета.
Рекомендуется переместить путь к локальной папке вниз по списку (для этого щелкните стрелку вниз на панели слева от строки с путем). Верхняя папка всегда по умолчанию используется как расположение для установки пакетов. Поэтому если в качестве верхней папки будет указан путь для установки пакетов Dynamo, все полученные через интернет пакеты будут храниться отдельно от узлов, опубликованных локально
Порядок путей к папкам изменен, чтобы в качестве пути по умолчанию в Dynamo использовалась папка установки пакетов.
Перейдите в эту локальную папку. Исходный пользовательский узел находится в папке .dyf, имя которой является расширением для файлов пользовательских узлов Dynamo. Если отредактировать файл в этой папке, соответствующий узел будет обновлен в пользовательском интерфейсе. Кроме того, можно добавить дополнительные узлы в главную папку DynamoCustomNode, и после перезапуска Dynamo они появятся в библиотеке.
Теперь при каждой загрузке Dynamo узел PointsToSurface будет отображаться в группе DynamoPrimer библиотеки Dynamo.
В Dynamo представлено огромное количество готовых функций, а также имеется обширная библиотека пакетов, которая позволяет существенно расширить возможности Dynamo. Пакет — это набор пользовательских узлов или дополнительных функций. Dynamo Package Manager — это портал для сообщества пользователей, где можно скачать любые пакеты, которые были опубликованы в интернете. Эти инструментарии разрабатываются сторонними поставщиками и предназначены для расширения базовых функций Dynamo, доступных каждому пользователю по первому требованию.
Проекты с открытым исходным кодом, такие как Dynamo, активно развиваются благодаря подобному участию сообщества. Благодаря узкоспециализированным сторонним разработчикам Dynamo может использоваться в самых различных отраслях. По этой причине команда Dynamo сконцентрировала свои усилия на оптимизации разработки и публикации пакетов (подробнее эта тема будет обсуждаться в следующих разделах).
Самый простой способ установки пакета — воспользоваться пунктом меню «Пакеты» в интерфейсе Dynamo. Перейдем к этому пункту и установим пакет. В этом небольшом примере будет установлен популярный пакет для создания прямоугольных панелей на сетке.
В Dynamo выберите Пакеты > Package Manager...
В строке поиска введите «quads from rectangular grid». Через некоторое время отобразятся все пакеты, соответствующие поисковому запросу. Выберем первый пакет с соответствующим именем.
Нажмите кнопку «Установить», чтобы добавить пакет в библиотеку, а затем подтвердите действие. Готово!
Обратите внимание, что в библиотеке Dynamo появилась группа с именем buildz. Это имя разработчика пакета, а в группе содержится пользовательский узел. Его можно сразу использовать.
Используйте узел Code Block для быстрого определения прямоугольной сетки, вывода результата в узел Polygon.ByPoints, а затем узел Surface.ByPatch для просмотра списка только что созданных прямоугольных панелей.
В приведенном выше примере описан пакет с одним пользовательским узлом. Та же самая процедура используется для скачивания пакетов с несколькими пользовательскими узлами и вспомогательными файлами данных. Продемонстрируем это на примере более крупного пакета: Dynamo Unfold.
Как и в приведенном выше примере, выберите Пакеты > Package Manager...
На этот раз выполним поиск по слову DynamoUnfold. Когда пакеты отобразятся, скачайте их, нажав кнопку «Установить», чтобы добавить Dynamo Unfold в библиотеку Dynamo.
В библиотеке Dynamo появилась группа DynamoUnfold с несколькими категориями и пользовательскими узлами.
Рассмотрим структуру файлов и папок пакета.
Сначала выберите «Пакеты» > «Package Manager» > «Установленные пакеты».
Затем нажмите «Показать корневую папку», чтобы открыть корневую папку для этого пакета.
Откроется корневая папка пакета. Обратите внимание, что в ней содержится три папки и файл.
В папке bin находятся файлы DLL. Этот пакет Dynamo был разработан с помощью функции Zero-Touch, поэтому пользовательские узлы хранятся в этой папке.
В папке dyf хранятся пользовательские узлы. Так как данный пакет был разработан без пользовательских узлов Dynamo, папка пуста.
В папке extra хранятся дополнительные файлы, включая файлы примеров.
Файл pkg — это базовый текстовый файл, определяющий параметры пакета. Пока мы не будем его рассматривать.
Если открыть папку extra, в ней можно увидеть несколько файлов примеров, которые были скачаны при установке. Если пакет сопровождается файлами примеров (что бывает не всегда), их следует искать в этой папке.
Откроем файл SphereUnfold.
Нажав после этого кнопку «Запуск» в решателе, получим развернутую сферу. Файлы примеров, подобные этим, используются для обучения работе с новыми пакетами Dynamo.
В Package Manager можно выполнять поиск пакетов с помощью параметров сортировки и фильтрации на вкладке «Поиск пакетов». Существует несколько фильтров: по главной программе, статусу (новый, исключенный или неисключенный), а также по наличию зависимостей в пакете.
Сортировка пакетов позволяет определить пакеты с наивысшей оценкой или наиболее часто скачиваемые пакеты, а также найти пакеты с последними обновлениями.
Чтобы узнать подробнее о каждом пакете, нажмите «Просмотр сведений». При этом в Package Manager открывается боковая панель, на которой представлены такие сведения, как управление версиями и данные о зависимостях, URL-адрес веб-сайта или репозитория, сведения о лицензии и т. д.
Еще один способ найти пакеты Dynamo — воспользоваться веб-сайтом Dynamo Package Manager. Здесь можно найти статистику по пакетам и рейтинги разработчиков. Кроме того, из Dynamo Package Manager можно скачивать файлы пакетов Dynamo, но делать это непосредственно из Dynamo проще.
Если требуется узнать, где хранятся файлы пакетов, в верхней части окна навигации выберите «Dynamo» > «Настройки» > «Параметры пакета» > «Пути к узлу и файлу пакета», чтобы найти текущую корневую папку.
По умолчанию пакеты устанавливаются в следующей папке: C:/Users/[имя пользователя]/AppData/Roaming/Dynamo/[версия Dynamo.
Сообщество Dynamo постоянно развивается. Если периодически посещать портал Dynamo Package Manager, можно обнаружить там новые интересные разработки. В следующих разделах пакеты Dynamo будут рассматриваться более подробно и не только с точки зрения конечного пользователя, но и в контексте их самостоятельной разработки.
Dynamo — это гибкая среда, предназначенная для совместного использования с широким спектром программ, однако изначально она разрабатывалась для использования в Revit. Средства визуального программирования обеспечивают мощные дополнительные возможности для информационного моделирования объектов строительства (BIM). Dynamo включает отдельный набор узлов, разработанных специально для Revit, а также библиотеки сторонних разработчиков из числа участников сообщества пользователей в сфере архитектуры и строительства. В этой главе рассматриваются основные принципы работы с Dynamo в Revit.
Dynamo поддерживает различные способы создания пакетов как с целью личного использования, так и для обмена с участниками сообщества Dynamo. Ниже рассматривается структура пакетов на примере разбора содержимого существующего пакета. Данный пример основан на упражнениях предыдущей главы, где был создан набор пользовательских узлов для сопоставления геометрии одной поверхности Dynamo с другой с помощью UV-координат.
Для иллюстрации воспользуемся примером пакета для UV-наложения точек с одной поверхности на другую. Основные возможности инструмента были рассмотрены в разделе Создание пользовательских узлов данного руководства. Приведенные ниже файлы показывают, как можно применить принцип UV-наложения к разработке набора инструментов для библиотеки с возможностью публикации.
На данном изображении точка одной поверхности сопоставляется с точкой другой поверхности с помощью UV-координат. Эта же концепция лежит в основе работы данного пакета, однако он рассчитан на более сложную геометрию.
В предыдущей главе рассматривались способы создания панелей поверхности в Dynamo на основе кривых, заданных в плоскости XY. В этой главе те же принципы рассматриваются более подробно, охватывая другие размеры и геометрические объекты. Чтобы показать, каким образом осуществлялась разработка пакета, он будет установлен в исходном состоянии. В следующем разделе будет рассматриваться публикация этого пакета.
В Dynamo выберите «Пакеты» > «Package Manager» и найдите пакет MapToSurface (одним словом,без пробелов). Нажмите кнопку «Установить», чтобы скачать и добавить пакет в библиотеку.
После установки пользовательские узлы должны быть доступны в разделе «Надстройки» > DynamoPrimer.
Теперь рассмотрим структуру пакета.
В разрабатываемом пакете есть пять пользовательских узлов, которые были созданы в качестве базовых. Ниже рассмотрим назначение каждого узла. Некоторые пользовательские узлы строятся на основе других пользовательских узлов, а графики имеют структуру, позволяющую другим пользователям легко понять их.
Перед нами простой пакет с пятью пользовательскими узлами. Ниже кратко рассматривается структура каждого из них.
Это базовый пользовательский узел, на основе которого создаются все остальные узлы сопоставления. Говоря простым языком, данный узел сопоставляет точку UV-координаты исходной поверхности с местоположением UV-координаты целевой поверхности. Поскольку точки представляют собой простейшие геометрические объекты, на основе которых строится более сложная геометрия, этот принцип можно использовать для сопоставления 2D- и даже 3D-геометрии одной поверхности с другой.
В данном случае для демонстрации преобразования сопоставляемых точек из одномерной геометрии в двухмерную используются обычные полигоны. Обратите внимание, что в этот пользовательский узел вложен узел PointsToSurface. Таким образом можно сопоставить точки каждого полигона с поверхностью, а затем заново сгенерировать полигон по этим точкам. При сохранении надлежащей структуры данных (список списков точек) полигоны будут располагаться отдельно после их уменьшения до набора точек.
Здесь работает тот же принцип, что и с узлом PolygonsToSurface. Однако вместо сопоставления полигональных точек сопоставляются управляющие точки NURBS-кривой.
OffsetPointsToSurface
Этот узел немного сложнее, но, как и узел PointsToSurface, сопоставляет точки одной поверхности с другой. Однако в этом случае узел учитывает точки, которые отсутствуют на исходной поверхности, вычисляет расстояние от них до ближайшего UV-параметра и сопоставляет это расстояние с нормалью целевой поверхности в соответствующей UV-координате. Это будет проще объяснить с помощью файлов примеров.
Это простой узел, который позволяет создать параметрическую поверхность на основе исходной сетки для сопоставления с волнистой поверхностью в файлах примеров.
Файлы примеров находятся в корневой папке пакета. Выберите «Package Manager» > «Установленные пакеты».
Рядом с MapToSurface нажмите значок с вертикальными точками и выберите «Показать корневую папку».
Затем перейдите в папку extra, в которой содержатся все файлы пакета, не являющиеся пользовательскими узлами. В этой папке хранятся файлы примеров (при наличии) для пакетов Dynamo. На снимках экрана ниже показаны принципы, реализованные в файлах примеров.
В этом файле демонстрируется, как с помощью узла PointsToSurface создавать панели поверхности на основе сетки из прямоугольников. Этот принцип вам, скорее всего, уже знаком, так как аналогичный рабочий процесс был представлен в предыдущей главе.
В данном файле, где используется похожий рабочий процесс, показан алгоритм сопоставления окружностей (или полигонов, представляющих окружности) одной поверхности с окружностями другой. При этом используется узел PolygonsToSurface.
Это более сложный файл примера, так как в нем используется узел NurbsCrvToSurface. Целевая поверхность смещена на заданное расстояние, а NURBS-кривая сопоставлена с исходной целевой поверхностью и смещенной поверхностью. К двум сопоставленным кривым применяется функция лофтинга для создания поверхности, толщина которой затем увеличивается. Полученное тело имеет неровность, соответствующую нормалям целевой поверхности.
В этом файле примера показано, как сопоставить исходную гофрированную полиповерхность с целевой поверхностью. Исходная и целевая поверхности представляют собой прямоугольную поверхность, которая проходит по сетке и поверхности вращения соответственно.
Исходная полиповерхность, сопоставленная с целевой поверхностью.
Так как с помощью пользовательских узлов можно сопоставлять различные типы кривых, последний файл ссылается на файл SVG, экспортированный из Illustrator, и сопоставляет импортированные кривые с целевой поверхностью.
В результате синтаксического анализа файла SVG кривые преобразуются из формата XML в сложные кривые Dynamo.
Импортированные кривые сопоставляются с целевой поверхностью. Это позволяет явным образом (с помощью указателя) создавать панели поверхности в приложении Illustrator, импортировать их в Dynamo и применять к целевой поверхности.
Надстройка Dynamo для Revit расширяет возможности информационного моделирования зданий за счет среды логики и данных, предоставляемой графическим редактором алгоритмов. Ее гибкие возможности в сочетании с обширной базой данных Revit позволяют перевести BIM на новый уровень.
В этой главе рассматриваются рабочие процессы Dynamo для BIM. Почти каждый раздел включает упражнения, так как знакомство с графическим редактором алгоритмов для BIM эффективнее всего проводится на практике. Но для начала изучите истоки этой программы.
Поскольку Revit и Dynamo постоянно обновляются, в какой-то момент используемая версия Revit может оказаться несовместимой с установленной на компьютере версией Dynamo для Revit. Ниже приведены сведения о том, какие версии надстройки Dynamo для Revit совместимы с программой Revit.
2013
2014 г.
2015
2016
2017
2018
2019
2020+
2.1.0 (Revit 2020 или более поздней версии теперь включает Dynamo и обновляется в соответствии с графиком обновлений Revit.)
Отсутствует
Благодаря упорству разработчиков и активному вкладу сообщества пользователей этот проект прошел большой путь от скромной надстройки до того, чем он является сейчас.
Изначально приложение Dynamo разрабатывалось как средство оптимизации рабочих процессов Revit для сферы архитектуры и строительства. Хотя в Revit для каждого проекта создается обширная база данных, пользователи со средним уровнем подготовки могут столкнуться с проблемами при доступе к информации за пределами интерфейса. Revit располагает полнофункциональным интерфейсом API, благодаря которому сторонние разработчики могут создавать специализированные инструменты. И программисты пользовались этим API на протяжении многих лет, однако стоит признать, что создание текстовых сценариев под силу далеко не всем. Благодаря Dynamo и понятному графическому редактору алгоритмов данные Revit становятся более доступными для пользователей с разными уровнями подготовки.
Используя базовые узлы Dynamo в сочетании со специализированными узлами Revit, пользователи могут существенно расширить параметрические рабочие процессы для обеспечения совместимости, выпуска документации, анализа и генерации объектов. Dynamo позволяет автоматизировать повседневные рабочие процессы и направить все силы проектировщиков на анализ и изучение проектов.
В редакторе проектов или семейств Revit перейдите в раздел «Надстройки» и выберите Dynamo.*
* Программа Dynamo будет выполняться только в том файле, в котором была открыта.
При открытии Dynamo в Revit отображается новая категория с именем Revit. Это мощное дополнение к пользовательскому интерфейсу, включающее узлы, специально предназначенные для использования в рабочих процессах Revit*.
* При использовании семейства узлов, предназначенного для Revit, график Dynamo будет работать только при открытии в Dynamo для Revit. Если график, предназначенный для работы в Dynamo для Revit, открыть в однопользовательской версии Dynamo, то все узлы Revit из него пропадут.
Поскольку Revit является платформой, которая обеспечивает широкие возможности по управлению проектами, параметрические операции в Dynamo могут быть сложными, а их расчет может занимать много времени. Если Dynamo требуется много времени для расчета узлов, возможно, следует воспользоваться функцией заморозки, чтобы приостановить выполнение операций Revit во время создания графика.
Подробные сведения о замораживании узлов см. в разделе Узлы и провода.
Приложение Dynamo изначально разрабатывалось для использования в сфере архитектуры и строительства, и наше постоянно растущее сообщество пользователей — это отличный ресурс для обучения и общения с отраслевыми экспертами. В сообщество пользователей Dynamo входят архитекторы, инженеры, программисты и проектировщики, которые любят изобретать и делиться своими изобретениями.
Dynamo — это проект с открытым исходным кодом, который постоянно развивается, и многие нововведения касаются Revit. Если вы пока что новичок, переходите на форум и начинайте задавать вопросы. Если вы программист и хотите принять участие в разработке Dynamo, посетите страницу репозитория GitHub. Кроме того, если вас интересуют библиотеки сторонних разработчиков, рекомендуем ознакомиться с Dynamo Package Manager. Многие из этих пакетов предназначены для сферы архитектуры и строительства. В этой главе рассматривается использование пакетов сторонних разработчиков для создания дополнительных панелей.
Разработчики Dynamo также ведут активный блог. Ознакомьтесь с последними публикациями, чтобы быть в курсе всех новостей.
Импорт Zero-Touch — это метод, позволяющий легко и быстро импортировать библиотеки C# одним щелчком мыши. Приложение Dynamo считывает общие методы из файла DLL и преобразует их в узлы Dynamo. Функцию Zero-Touch можно использовать для разработки пользовательских узлов и пакетов, а также для импорта внешних библиотек в среду Dynamo.
Файлы DLL
Узлы Dynamo
Zero-Touch позволяет импортировать библиотеки, в том числе разработанные не в Dynamo, и создавать наборы новых узлов. Эта функция является воплощением принципа кросс-платформенности, на котором основывается проект Dynamo.
В этом разделе показан процесс импорта сторонней библиотеки с помощью функции Zero-Touch. Дополнительные сведения о разработке пользовательской библиотеки Zero-Touch см. на странице справки Wiki по работе с Dynamo.
Пакеты Zero-Touch являются хорошим дополнением к пользовательским узлам. В таблице ниже приведены некоторые пакеты, в которых используются библиотеки C#. Дополнительные сведения о пакетах см. в разделе Пакеты приложения.
Логотип/изображение
Имя
В этом примере мы рассмотрим процесс импорта внешней библиотеки AForge в формате DLL. AForge — это мощная библиотека, поддерживающая широкий спектр функциональных возможностей — от обработки изображений до искусственного интеллекта. При выполнении приведенных ниже упражнений по обработке изображений мы будет обращаться к классу Imaging этой библиотеки.
Для начала скачайте AForge. На странице загрузки AForge нажмите [ Download Installer ], дождитесь завершения загрузки и выполните установку.
Создайте новый файл в Dynamo и выберите «Файл» > «Импорт библиотеки...».
Затем найдите файл DLL.
В появившемся окне перейдите к подпапке Release в папке установки AForge. Путь к папке, скорее всего, будет выглядеть таким образом: C:\Program Files (x86)\AForge.NET\Framework\Release.
AForge.Imaging.dll: в рамках данного примера нам требуется только этот файл библиотеки AForge. Выберите этот файл DLL и нажмите Открыть.
В Dynamo на панели инструментов «Библиотека» должна появиться группа узлов AForge. Теперь библиотека для работы с изображениями AForge доступна непосредственно в приложении для визуального программирования.
Скачайте файл с примером, щелкнув ссылку ниже.
Полный список файлов с примерами можно найти в приложении.
Выполнив импорт библиотеки, можно приступать к первому несложному упражнению (01-EdgeDetection.dyn). Сначала мы выполним базовую обработку стандартного изображения и посмотрим, как AForge осуществляет фильтрацию изображений. Затем мы воспользуемся узлом Watch Image для отображения результатов и применим к изображению фильтры Dynamo, аналогичные фильтрам приложения Photoshop.
Для импорта изображений добавьте узел File Path в рабочую область и выберите файл soapbubbles.jpg в папке материалов для упражнения (источник изображения: flickr).
Узел File Path предоставляет путь к выбранному изображению в виде строки. Теперь необходимо преобразовать его в пригодный для использования файл изображения в Dynamo.
Используйте узел File From Path, чтобы преобразовать путь к файлу в изображение в среде Dynamo.
Соедините узел File Path с узлом File.FromPath.
Чтобы преобразовать файл в изображение, используйте узел Image.ReadFromFile.
Наконец, чтобы увидеть результат, перетащите узел Watch Image в рабочую область и соедините его с Image.ReadFromFile. Мы еще не воспользовались библиотекой AForge, но уже успешно импортировали изображение в Dynamo.
В разделе AForge.Imaging.AForge.Filters (в меню навигации) доступен широкий выбор фильтров. Мы воспользуемся одним из них, чтобы обесцветить изображение в соответствии с пороговыми значениями.
Перетащите в рабочую область три регулятора и задайте для них диапазоны от 0 до 1 с шагом 0,01.
Добавьте в рабочую область узел Grayscale.Grayscale. Это фильтр AForge, который позволяет применить к изображению оттенки серого. Соедините три регулятора, добавленные в шаге 1, с элементами cr, cg и cb. Задайте для верхнего и нижнего регуляторов значение 1, а для среднего — 0.
Чтобы применить оттенки серого, нам нужно задать действие, которое будет выполняться с изображением. Для этого используется узел BaseFilter.Apply. Соедините выходной параметр image с входным параметром image, а выходной параметр Grayscale.Grayscale с входным параметром baseFilter.
Соедините этот узел с новым узлом Watch Image, и вы получите обесцвеченное изображение.
Благодаря заданию пороговых значений для красного, зеленого и синего цветов можно управлять тем, как именно будет обесцвечиваться изображение. Пороговые значения задаются через входные параметры узла Grayscale.Grayscale. Обратите внимание, что изображение выглядит довольно тусклым. Это вызвано тем, что для регулятора зеленого цвета задано значение 0.
Задайте для верхнего и нижнего регуляторов значение 0, а для среднего — 1. В результате полученное обесцвеченное изображение становится более контрастным.
Теперь применим к полученному обесцвеченному изображению еще один фильтр. Поскольку изображение обладает определенной контрастностью, мы попробуем применить к нему функцию выделения границ.
Добавьте узел SobelEdgeDetector.SobelEdgeDetector в рабочую область.
Соедините его с узлом BaseUsingCopyPartialFilter.Apply и соедините обесцвеченное изображение с входным параметром изображения этого узла.
В результате мы получаем новое изображение, в котором оператор Собеля выделил все обнаруженные границы.
В результате применения инструмента выделения границ мы получили увеличенное изображение пузырьков, границы которых выделены с помощью пикселей. В библиотеке AForge есть инструменты, которые позволяют использовать подобные результаты для создания геометрии Dynamo. Мы рассмотрим их в следующем упражнении.
Теперь, когда мы ознакомились с базовыми возможностями обработки изображений, можно приступить к использованию изображений для создания геометрии Dynamo. Ваша минимальная задача в рамках этого упражнения — выполнить так называемую быструю трассировку изображения с помощью AForge и Dynamo. Пока что в целях простоты мы ограничимся извлечением прямоугольников из опорного изображения, однако в AForge доступны инструменты и для более сложных операций. В этом упражнении мы используем файл 02-RectangleCreation.dyn из загруженного набора материалов для упражнения.
С помощью узла File Path задайте путь к файлу grid.jpg в папке материалов для упражнения.
Соедините последовательно оставшиеся узлы, как показано выше, чтобы отобразить грубую параметрическую сетку.
На следующем шаге мы зададим белые прямоугольники из этого изображения в качестве опорных объектов и преобразуем их в геометрию Dynamo. Библиотека AForge включает множество мощных инструментов компьютерного распознавания образов. В этом упражнении будет использован один из ключевых инструментов под названием BlobCounter.
После добавления узла BlobCounter в рабочую область необходимо выполнить обработку изображения (аналогично использованию инструмента BaseFilter.Apply в предыдущем упражнении).
К сожалению, найти узел обработки изображений Process Image в библиотеке Dynamo может быть затруднительно. Это связано с тем, что эта функция может быть не видна в исходном коде библиотеки AForge. Чтобы обойти эту проблему, потребуется временное решение.
Добавьте узел Python в рабочую область и вставьте в него следующий код. Этот код позволяет импортировать библиотеку AForge, а затем обработать импортированное изображение.
При соединении порта вывода image с портом ввода узла Python последний выдает результат AForge.Imaging.BlobCounter.
Следующие шаги включают в себя операции, требующие определенного опыта работы с API-интерфейсом обработки изображений AForge. Это не значит, что для работы с Dynamo обязательно нужно обладать этими знаниями. Мы сделали это в целях демонстрации гибких возможностей работы с внешними библиотеками в среде Dynamo.
Соедините порт вывода узла сценария Python с узлом BlobCounterBase.GetObjectRectangles. При этом объекты изображения считываются в соответствии с заданным пороговым значением, после чего квантифицированные прямоугольники извлекаются из пиксельного пространства.
Добавьте еще один узел Python в рабочую область, соедините его с узлом GetObjectRectangles и введите в него код, указанный ниже. В результате создается упорядоченный список объектов Dynamo.
Добавьте узел Transpose к порту вывода узла Python из предыдущего шага. Создаются четыре списка, содержащие значения координат X и Y, а также ширины и высоты для каждого прямоугольника.
С помощью узла Code Block упорядочим данные таким образом, чтобы их можно было использовать в узле Rectangle.ByCornerPoints (см. код ниже).
Вы увидите массив прямоугольников, представляющих белые квадраты на изображении. Таким образом, с помощью программирования мы смогли выполнить операцию, аналогичную быстрой трассировке в программе Adobe Illustrator.
Теперь нам нужно удалить из изображения все лишнее. Увеличив масштаб, вы увидите маленькие прямоугольники, которые требуется удалить.
Теперь напишем коды, чтобы избавиться от ненужных прямоугольников.
Вставьте узел Python между узлом GetObjectRectangles и другим узлом Python. Приведенный ниже код для этого узла позволяет удалить все прямоугольники, размер которых меньше заданного значения.
Удалив лишние прямоугольники, мы можем поэкспериментировать и создать поверхность из прямоугольников, а затем выдавить их на глубину, соответствующую их площади.
Наконец, измените значение both_sides на false, чтобы получить выдавливание в одном направлении. Если залить то, что у нас здесь получилось, эпоксидной смолой, то у нас был бы модный столик в стиле хай-тек.
Мы выполнили несколько простых упражнений, однако процедуры, которые здесь рассматривались, можно использовать гораздо более интересным образом для самых разных целей. Возможности компьютерного распознавания образов применимы в широчайшем спектре процессов, таких как сканирование штрихкодов, подгонка перспективы, наложение данных проекции, дополненная реальность и многое другое. Дополнительные темы по работе с библиотекой AForge, связанные с этим упражнением, см. в данной статье.
Dynamo for Civil 3D предоставляет возможности визуального программирования инженерам и проектировщикам, работающим над инфраструктурными проектами. Dynamo можно рассматривать как цифровой швейцарский нож для пользователей Civil 3D: какая бы задача перед вами ни стояла, вы сможете найти подходящее решение. Интуитивно понятный интерфейс позволяет создавать эффективные настраиваемые процедуры без написания кода. Для использования Dynamo не нужно быть программистом, но нужно уметь думать, как программист. В этой главе, а также в других главах этого руководства представлены сведения, которые помогут вам развить ваши логические навыки, что позволит вам применять принципы машинного проектирования для решения любых задач.
Программа Dynamo была впервые представлена в составе Civil 3D 2020, и с тех пор ее возможности постоянно расширялись и улучшались. Изначально она устанавливалась отдельно как обновление программного обеспечения. Теперь же она поставляется в пакете со всеми версиями Civil 3D. В зависимости от используемой версии Civil 3D интерфейс Dynamo может немного отличаться от приведенных в этой главе примеров. Это связано с существенными изменениями в интерфейсе Civil 3D 2023.
В предыдущих разделах мы подробно рассмотрели процесс настройки пакета MapToSurface с использованием пользовательских узлов и файлов примеров. Но как опубликовать пакет, разработка которого была выполнена на локальном компьютере? В этом примере мы рассмотрим процесс публикации пакета из набора файлов в локальной папке.
Существует множество способов публикации пакетов. Мы рекомендуем придерживаться следующего процесса: сначала опубликуйте пакет на локальном компьютере, там же выполните его разработку и, наконец, опубликуйте пакет в интернете. В рамках примера мы будем работать с папкой, содержащей все файлы пакета.
Если пакет MapToSurface уже был установлен в рамках предыдущего урока, его необходимо удалить, прежде чем приступать к публикации в рамках этого урока, чтобы избежать дублирования пакетов.
Сначала выберите «Пакеты» > «Package Manager» > «Установленные пакеты», рядом с MapToSurface щелкните значок с вертикальными точками и нажмите «Удалить».
Перезапустите Dynamo. В окне Управление пакетами убедитесь, что пакет MapToSurface отсутствует. Теперь все готово к началу работы.
Пользовательские узлы и пакеты из Dynamo Sandbox можно публиковать в версии 2.17 и более поздних, если они не имеют зависимостей основного API. В более ранних версиях пользовательские узлы и пакеты можно публиковать только в Dynamo for Revit и Dynamo for Civil 3D.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
Это первая версия данного пакета. Все файлы примеров и пользовательские узлы размещены в одной папке. Поскольку папка готова к использованию, можно сразу приступать к выгрузке в Dynamo Package Manager.
Эта папка содержит пять пользовательских узлов (DYF).
В ней также есть пять файлов примеров (DYN) и один импортированный файл векторов (SVG). Эти файлы будут задействованы в рамках вводных упражнений по обучению работе с пользовательскими узлами.
В Dynamo выберите Пакеты > Package Manager > Опубликовать новый пакет.
На вкладке Публикация пакета заполните соответствующие поля в левой части окна.
Теперь добавим файлы пакета. Можно добавлять файлы по одному или целыми папками, выбрав «Добавить папку» (1). Чтобы добавить файлы, отличные от файлов DYF, в окне браузера выберите тип файлов Все файлы (.). Обратите внимание, что будут добавлены все файлы — и файлы пользовательских узлов (DYF), и файлы примеров (DYN). При публикации пакета программа Dynamo автоматически классифицирует их по категориям.
После выбора папки MapToSurface в Package Manager отобразится ее содержимое. Если вы отправляете собственный пакет со сложной структурой папок и не хотите, чтобы программа Dynamo вносила изменения в структуру папок, можно включить параметр «Сохранить структуру папок». Этот параметр предназначен для опытных пользователей. Если пакет не настроен особым образом, лучше не устанавливать этот флажок и позволить Dynamo упорядочить файлы требуемым образом. Нажмите «Далее», чтобы продолжить.
Здесь можно просмотреть, как Dynamo организует файлы пакетов перед публикацией. Нажмите кнопку «Готово» для продолжения.
Нажмите кнопку «Опубликовать локально» (1) для публикации пакета. Обратите внимание, что нужно нажать именно Опубликовать локально, а не Публикация в Интернете, чтобы избежать появления повторяющихся пакетов в Package Manager.
После публикации пользовательские узлы должны быть доступны в группе DynamoPrimer или в библиотеке Dynamo.
Теперь перейдем в корневую папку и посмотрим, как только что созданный пакет был отформатирован в Dynamo. Для этого выберите вкладку «Установленные пакеты», рядом с MapToSurface щелкните значок с вертикальными точками и выберите «Показать корневую папку».
Обратите внимание, что поскольку пакет был опубликован локально, корневая папка находится в локальной папке пакета. Dynamo ссылается на эту папку для чтения пользовательских узлов. Поэтому при локальной публикации пакета важно указывать постоянную папку (а не рабочий стол, например). Структура папок пакета Dynamo выглядит следующим образом.
В папке bin хранятся файлы DLL, созданные с помощью библиотек C# или Zero-Touch. В этот пакет такие файлы не входят, поэтому данная папка пуста.
В папке dyf хранятся пользовательские узлы. Открыв ее, можно просмотреть все пользовательские узлы (файлы DYF), входящие в пакет.
В папке extra хранятся все дополнительные файлы. Сюда входят файлы Dynamo (DYN), а также дополнительные файлы других форматов (SVG, XLS, JPEG, SAT и т. д.).
Файл PKG — это стандартный текстовый файл, определяющий параметры пакета. Он создается в Dynamo автоматически, но если требуется подробная настройка, то параметры можно отредактировать.
Примечание. Данная процедура предназначена только для публикации пакетов, разработанных пользователями.
Когда все будет готово для публикации, в окне «Пакеты» > «Package Manager» > «Установленные пакеты» нажмите кнопку справа от пакета, который требуется опубликовать, и выберите «Опубликовать».
Если требуется обновить ранее опубликованный пакет, выберите «Публикация версии», и приложение Dynamo обновит пакет в интернете с учетом новых файлов в корневой папке этого пакета. Проще простого.
Если файлы в корневой папке опубликованного пакета были изменены, можно также опубликовать новую версию этого пакета, выбрав вариант Публикация версии... на вкладке Мои пакеты. Эта функция позволяет с легкостью вносить в содержимое необходимые обновления и обмениваться данными с сообществом пользователей. Пользоваться функцией Публикация версии могут только разработчики соответствующего пакета.
Revit — это насыщенная данными среда. Она поддерживает самые разные возможности выбора объектов, не ограничиваясь стандартным щелчком кнопкой мыши. Dynamo позволяет опрашивать базу данных Revit и динамически связывать элементы Revit с геометрией Dynamo во время выполнения параметрических операций.
Библиотека Revit, доступная в пользовательском интерфейсе, включает категорию Selection, которая предлагает несколько способов выбора геометрии.
Для использования правильного метода выбора элементов Revit необходимо иметь четкое представление об их иерархии. Необходимо выбрать все стены в проекте? Используйте выбор по категории. Требуется выбрать все кресла фирмы Eames для приемной в стиле 1950-х? Используйте выбор по семейству.
Кратко рассмотрим иерархию Revit.
Помните таксономические ранги, которые проходят на уроках биологии? Согласно им, все организмы в природе делятся на царства, типы, классы, порядки, семейства, рода и виды. Элементы Revit упорядочены аналогичным образом. На базовом уровне иерархию Revit можно разделить на категории, семейства, типы* и экземпляры. Экземпляр представляет собой отдельный элемент модели (с уникальным идентификатором), а категория определяет типовую группу (например, «стены» или «полы»). Такая организация базы данных Revit позволяет выбрать один элемент и все аналогичные ему элементы на основании указанного уровня иерархии.
* Определение типов в Revit отличается от определения типов в программировании. В Revit термин «тип» относится к ветви иерархии, а не к типу данных.
На трех изображениях ниже представлены основные категории выбора элементов Revit в Dynamo. Эти инструменты прекрасно сочетаются друг с другом, в чем вы убедитесь при выполнении последующих упражнений.
Щелчок кнопкой мыши — самый простой способ непосредственного выбора элементов в Revit. Таким образом можно выбрать весь элемент модели или части его топологии (например, грань или ребро). При этом сохраняется динамическая связь с объектом Revit, благодаря чему при обновлении местоположения или параметров файла Revit связанный элемент Dynamo также будет обновлен на графике.
Раскрывающиеся меню отображают список всех доступных элементов в проекте Revit. Их можно использовать для задания ссылок на элементы Revit, которые могут не отображаться на виде. Это удобный инструмент для опроса существующих или создания новых элементов в проекте Revit или редакторе семейств.
![](../.gitbook/assets/selecting _database_navigation_with_dynamo_nodes_02.png)
Кроме того, элементы Revit можно выбирать по определенному уровню в иерархии Revit. Это удобно при адаптации крупных массивов данных для подготовки документации или генеративного создания экземпляров и адаптации.
Теперь, когда вы ознакомились с приведенными выше изображениями, можно переходить к упражнению для выбора элементов базового проекта Revit, чтобы подготовиться к параметрическим операциям, которые вам предстоит создать в последующих разделах этой главы.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
Данный файл примеров Revit содержит три типа элементов стандартного здания. Мы используем его в качестве примера для выбора элементов Revit в контексте иерархии Revit.
Формообразующий элемент здания
Балки (несущий каркас)
Фермы (адаптивные компоненты)
Какие выводы можно сделать на основе элементов, отображаемых на виде проекта Revit? Как глубоко в иерархии находятся соответствующие элементы? Чем масштабнее проект, тем сложнее найти ответы на подобные вопросы. Доступно множество вариантов: элементы можно выбирать по категориям, уровням, семействам, экземплярам и т. д.
Так как мы используем базовую настройку, выберите формообразующий элемент здания, щелкнув Mass в раскрывающемся меню узла Categories. Эта функция также доступна на вкладке Revit > «Выбор».
На выходе узла категории Mass мы получаем только саму категорию. Необходимо выбрать элементы. Для этого используйте узел All Elements of Category.
Обратите внимание, что на этом этапе в Dynamo геометрия не отображается. Вы выбрали элемент Revit, но еще не преобразовали его в геометрию Dynamo. Важно различать эти операции. Когда требуется выбрать большое количество элементов, нежелательно отображать их все в Dynamo, так как это замедлит работу программы. Dynamo — это инструмент для управления проектом Revit без обязательного выполнения операций с геометрией. Мы остановимся на этом подробнее в следующем разделе главы.
В данном случае вы работаете с простой геометрией, поэтому ее вполне можно добавить в область предварительного просмотра Dynamo. Рядом с элементом BldgMass узла Watch отображается число, выделенное зеленым цветом. Это идентификатор элемента, который позволяет понять, что вы работаете с элементом Revit, а не геометрией Dynamo. Теперь необходимо преобразовать этот элемент Revit в геометрию Dynamo.
Используя узел Element.Faces, можно получить список поверхностей, представляющий все грани формообразующего элемента. Теперь можно просмотреть геометрию на видовом экране Dynamo и использовать грань как опорный элемент для параметрических операций.
Есть и другой способ. Вместо выбора с помощью иерархии Revit (узел All Elements of Category) можно выбрать геометрию непосредственно в Revit.
В узле Select Model Element щелкните кнопку Select (или Change). На видовом экране Revit выберите нужный элемент. В данном случае следует выбрать формообразующий элемент здания.
Вместо выбора с помощью узла Element.Faces можно выбрать весь формообразующий элемент как единое геометрическое тело, применив Element.Geometry. При этом будет выбрана вся геометрия в пределах формообразующего элемента.
С помощью Geometry.Explode можно снова сформировать список поверхностей. Эти два узла работают аналогично узлу Element.Faces, но содержат дополнительные параметры для изучения геометрии элемента Revit.
Используя базовые операции для списков, можно запросить нужную грань.
Сначала необходимо вывести выбранные элементы из предыдущего узла в узел Element.Faces.
Узел List.Count показывает, что в пределах формообразующего элемента присутствует 23 поверхности.
Учитывая эти сведения, измените максимальное значение узла Integer Slider на 22.
С помощью узла List.GetItemAtIndex задайте списки в качестве входных данных и соедините Integer Slider с портом ввода index. Изменяя положение регулятора с выбранными элементами, остановитесь на индексе 9, когда будет изолирован главный фасад с фермами.
Предыдущий шаг был довольно трудоемким. Его можно выполнить гораздо проще и быстрее с помощью узла Select Face. Он позволяет изолировать в проекте Revit грань, которая не является самостоятельным элементом. Это же действие можно выполнить с помощью Select Model Element, выбрав поверхность вместо целого элемента.
Предположим, нужно изолировать стены главного фасада здания. Для этого можно использовать узел Select Faces. Нажмите кнопку выбора, а затем выберите четыре основных фасада в Revit.
Выбрав четыре стены, нажмите в Revit кнопку «Готово».
Грани импортируются в Dynamo в качестве поверхностей.
Теперь рассмотрим балки над атриумом.
С помощью узла Select Model Element выберите одну из балок.
Соедините элемент балки с портом ввода узла Element.Geometry, после чего балка появится на видовом экране Dynamo.
С помощью узла Watch 3D можно увеличить геометрию (если балка не отображается в Watch 3D, щелкните правой кнопкой мыши и выберите «Вписать»).
При работе в Revit и Dynamo часто возникает вопрос: как, выбрав один элемент, выделить все аналогичные элементы? Так как выбранный элемент Revit содержит всю иерархическую информацию, можно запросить его типоразмер в семействе и выбрать все элементы данного типа.
Соедините элемент балки с портом ввода узла Element.ElementType.
Изображение в узле Watch показывает, что выходные данные теперь являются обозначением семейства, а не элементом Revit.
Element.ElementType — это простой запрос, который можно легко выполнить в узле Code Block с помощью синтаксиса
x.ElementType;
и получить те же результаты.
Для выбора остальных балок используйте узел All Elements of Family Type.
Узел Watch показывает, что выбрано пять элементов Revit.
Эти пять элементов также можно преобразовать в геометрию Dynamo.
В любом случае, даже если бы мы и хотели импортировать 500 балок, нужны ли нам все поверхности для выполнения задуманной параметрической операции? Или же мы можем извлечь основную информацию из балок и выполнить генеративные задачи с помощью фундаментальной геометрии? Подумайте над этим вопросом, пока мы продолжаем разбирать данную главу. Для примера рассмотрим систему ферм.
С помощью того же графика узлов выберите элемент фермы вместо балки. Перед этим удалите узел Element.Geometry, добавленный на предыдущем шаге.
Теперь можно извлечь основные сведения из типоразмера семейства ферм.
В узле Watch отображается список адаптивных компонентов, выбранных из Revit. Так как необходимо извлечь основную информацию, начните с адаптивных точек.
Соедините узел All Elements of Family Type с узлом AdaptiveComponent.Location. В результате получится список списков, каждый из которых содержит три точки, представляющие местоположения адаптивных точек.
При присоединении узла Polygon.ByPoints образуется сложная кривая. Она отображается на видовом экране Dynamo. Благодаря этому методу вы визуализировали геометрию одного элемента и абстрагировали геометрию оставшегося массива элементов (которых может быть больше, чем в данном примере).
Совет. Если щелкнуть зеленый номер элемента Revit в Dynamo, масштаб этого элемента в видовом экране Revit будет увеличен.
Параметры выпуска документации редактируются по тому же принципу, что и в предыдущих разделах. В этом разделе мы рассмотрим редактирование параметров, которые не влияют на геометрические свойства элементов, но необходимы для подготовки файла Revit к выпуску документации.
В упражнении ниже, чтобы создать лист Revit для документации, будет использоваться стандартный узел Deviation from Plane (отклонение от плоскости). Каждая панель в конструкции крыши, определенной параметрически, имеет собственное значение отклонения. Необходимо указать диапазон значений, используя цвет и составив спецификацию адаптивных точек, для передачи консультанту, инженеру или подрядчику, работающему с фасадом.
Узел Deviation from Plane вычисляет расстояние, на которое набор из четырех точек отклоняется относительно оптимально вписанной между ними плоскости. Это простой и быстрый способ проверки технологичности конструкции.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
Начнем с открытия файла Revit для данного раздела (также можно продолжить работу с файлом из предыдущего раздела). В этом файле представлен массив панелей ETFE на крыше. Эти панели будут использоваться в данном упражнении.
Добавьте узел Family Types в рабочую область и выберите ROOF-PANEL-4PT.
Соедините этот узел с портом ввода узла All Elements of Family Type, чтобы перенести все элементы из Revit в Dynamo.
Запросите местоположение адаптивных точек каждого элемента с помощью узла AdaptiveComponent.Locations.
Создайте полигон по этим четырем точкам с помощью узла Polygon.ByPoints. Обратите внимание, что в Dynamo используется абстрактная версия системы панелей (без необходимости импорта всей геометрии элемента Revit).
Вычислите отклонение от плоскости с помощью узла Polygon.PlaneDeviation.
Просто в качестве дополнения, как и в предыдущем упражнении, укажите коэффициент апертуры каждой панели на основе отклонения от плоскости.
Добавьте узел Element.SetParameterByName в активное окно и соедините адаптивные компоненты с портом ввода element. Соедините узел Code Block, содержащий строку Aperture Ratio, с портом ввода parameterName.
Напрямую соединить результаты отклонения с портом ввода value невозможно, так как необходимо перенастроить значения на другой диапазон параметров.
С помощью узла Math.RemapRange перенастройте значения отклонения на область между 0,15 и 0,45 путем ввода
0.15; 0.45;
в узле Code Block.Соедините эти результаты с портом ввода value узла Element.SetParameterByName.
Вернувшись в Revit, можно примерно оценить изменение в апертуре на поверхности.
При увеличении масштаба становится понятно, что вес замкнутых панелей направлен к углам поверхности. Незамкнутые углы направлены вверх. Углы представляют собой участки более значительных отклонений, в то время как выпуклость имеет минимальную кривизну, так что все логично.
Указание коэффициента апертуры не дает четкой картины отклонения панелей на крыше. Кроме того, изменяется геометрия самого элемента. Предположим, нужно просто изучить отклонение с точки зрения технической осуществимости изготовления. Для этого в документации можно окрасить панели в различные цвета в зависимости от диапазона отклонений. Это можно сделать при помощи следующих шагов, которые очень похожи на действия, описанные выше.
Удалите узел Element.SetParameterByName и узлы, соединенные с его портами ввода, а затем добавьте узел Element.OverrideColorInView.
Добавьте узел Color Range в рабочую область и соедините его с портом ввода color узла Element.OverrideColorInView. Для создания градиента необходимо также соединить значения отклонения с цветовым диапазоном.
При наведении указателя на порт ввода value видно, что значения для этого порта должны быть в диапазоне от 0 до 1. Только в этом случае можно будет сопоставить цвета со значениями. Необходимо перенастроить значения отклонения, задав этот диапазон.
С помощью узла Math.RemapRange перенастройте значения отклонения от плоскости, задав диапазон от 0 до 1. (Примечание. Чтобы задать исходную область, также можно использовать узел MapTo.)
Соедините результаты с портом ввода узла Color Range.
Обратите внимание, что в результате получается диапазон цветов, а не диапазон чисел.
Если используется режим «Вручную», нажмите кнопку Запуск. С этого момента вы, скорее всего, сможете без проблем работать в автоматическом режиме.
Вернувшись в Revit, видим значительно более наглядный градиент, характеризующий отклонение от плоскости на основе цветового диапазона. Но что, если требуется изменить цвета? Обратите внимание, что минимальные значения отклонения обозначены красным цветом, что не вполне логично. Необходимо, чтобы максимальному отклонению соответствовал красный, а минимальному — более спокойный цвет. Вернемся в Dynamo и устраним этот недостаток.
Используя узел Code Block, добавьте два числа в две разные строки:
0;
и255;
.Создайте красный и синий цвета, соединив соответствующие значения с двумя узлами Color.ByARGB.
Создайте список из этих двух цветов.
Соедините этот список с портом ввода colors узла Color Range и посмотрите, как при этом изменится пользовательский цветовой диапазон.
Теперь, вернувшись в Revit, можно получить более наглядное представление об областях максимального отклонения в углах. Помните, что этот узел служит для переопределения цвета на виде, поэтому он может быть очень полезен в случае, когда в наборе чертежей есть лист, предназначенный для определенного типа расчета.
При выборе в Revit одной панели ETFE отображаются четыре параметра экземпляра: XYZ1, XYZ2, XYZ3 и XYZ4. После создания все они будут пустыми. Это текстовые параметры, для которых требуется задать значения. С помощью Dynamo создадим местоположения адаптивных точек для каждого параметра. Это способствует взаимодействию в случаях, когда геометрический объект необходимо отправить инженеру или консультанту по фасадам.
На образце листа представлена большая пустая спецификация. Параметры XYZ являются общедоступными параметрами в файле Revit, благодаря чему их можно добавить в спецификацию.
Если увеличить масштаб, становится видно, что параметры XYZ еще не заполнены. Первые два параметра автоматически заполняются данными из Revit.
Для ввода этих значений выполним сложную операцию со списком. Сам график довольно прост, но его логика строится на основе сопоставления списков, которое рассматривалось в разделе, посвященном спискам.
Выберите все адаптивные компоненты с двумя узлами.
Извлеките местоположение каждой точки с помощью узла AdaptiveComponent.Locations.
Преобразуйте эти точки в строки. Следует помнить, что параметр является текстовым, поэтому входные данные должны иметь правильный тип.
Создайте список из четырех строк, которые определяют изменяемые параметры: XYZ1, XYZ2, XYZ3 и XYZ4.
Соедините этот список с портом ввода parameterName узла Element.SetParameterByName.
Соедините узел Element.SetParameterByName с портом ввода combinator узла List.Combine. Соедините адаптивные компоненты с портом ввода list1. Соедините узел String from Object с портом ввода list2.
В данном случае мы сопоставляем списки, так как вводим четыре значения для каждого элемента, что создает сложную структуру данных. Узел List.Combine управляет операцией, выполняемой на один шаг вниз по иерархии данных. Именно поэтому порты ввода element и value узла Element.SetParameterByName остаются пустыми. Вложенные списки входных параметров узла List.Combine соединяются с пустыми портами ввода узла Element.SetParameterByName в соответствии с порядком их подсоединения.
При выборе панели в Revit становится видно, что для каждого параметра есть строковые значения. В реальном проекте для создания точки (X,Y,Z) использовался бы более простой формат. Это можно сделать с помощью строковых операций в Dynamo, но в рамках данного раздела этот метод не рассматривается.
Вид образца спецификации с заполненными параметрами.
Каждая панель ETFE теперь имеет координаты XYZ, введенные для каждой адаптивной точки и соответствующие углам каждой изготавливаемой панели.
Одной из мощнейших возможностей Dynamo является редактирование параметров на параметрическом уровне. Например, для управления параметрами массива элементов можно использовать генеративный алгоритм или результаты моделирования. Таким образом, в проекте Revit набору экземпляров из одного семейства можно присвоить пользовательские свойства.
Параметры экземпляра определяют апертуру панелей на поверхности крыши в диапазоне значений коэффициента апертуры от 0,1 до 0,4.
Параметры на основе типа применяются к каждому элементу на поверхности, так как они относятся к одному и тому же типоразмеру в семействе. Например, материал каждой панели может определяться параметром на основе типа.
Если вы уже настраивали семейства Revit, помните, что необходимо назначить тип параметра (строка, номер, размер и т. д.). При назначении параметров в Dynamo убедитесь, что выбран правильный тип данных.
Dynamo можно также использовать в сочетании с параметрическими зависимостями, определенными в свойствах семейства Revit.
Напоминаем, что в Revit существуют параметры типа и параметры экземпляра. Их все можно редактировать в Dynamo, но в данном упражнении рассматриваются параметры экземпляра.
Начиная с версии 0.8, в Dynamo практически не используются единицы измерения. Это позволяет модулю оставаться абстрактной средой визуального программирования. Узлы Dynamo, которые взаимодействуют с размерами Revit, будут ссылаться на единицы измерения проекта Revit. Например, если в Revit с помощью Dynamo задается параметр длины, число, указанное в качестве значения в Dynamo, будет соответствовать единицам измерения по умолчанию в проекте Revit. В приведенном ниже упражнении используются метры.
Для быстрого преобразования единиц измерения используйте узел Convert Between Units. Это удобный инструмент для динамического преобразования единиц измерения длины, площади и объема.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
В упражнении ниже используются метры.
В этом упражнении основное внимание уделяется редактированию элементов Revit без выполнения геометрических операций в Dynamo. В данном случае геометрия Dynamo не импортируется, а просто редактируются параметры в проекте Revit. Это упражнение базового уровня. Опытным пользователям Revit следует обратить внимание на то, что хотя речь идет о параметрах экземпляров формообразующего элемента, тот же принцип можно применить и к целому массиву элементов. Все действия выполняются с помощью узла Element.SetParameterByName.
Начнем с файла Revit, используемого в этом разделе в качестве примера. Несущие элементы и адаптивные фермы из предыдущего раздела были удалены. В этом упражнении мы рассмотрим параметрическую оснастку в Revit и манипуляции в Dynamo.
При выборе здания в разделе «Формообразующий элемент» в Revit на панели «Свойства» отображается массив параметров экземпляра.
В Dynamo можно извлечь параметры, выбрав целевой элемент.
Выберите формообразующий элемент здания с помощью узла Select Model Element.
Можно запросить все параметры этого формообразующего элемента с помощью узла Element.Parameters. Сюда входят параметры типа и экземпляра.
См. узел Element. Parameters, чтобы найти целевые параметры. Кроме того, можно выбрать имена параметров для редактирования, изучив панель свойств из предыдущего шага. В данном случае необходимы параметры, которые влияют на большие геометрические перемещения формообразующего элемента здания.
Измените элемент Revit, используя узел Element.SetParameterByName.
Используйте узел Code Block, чтобы определить список параметров, заключив каждый элемент в кавычки для обозначения строки. Кроме того, можно использовать узел List.Create с последовательностью узлов string, подключенных к нескольким входным параметрам, однако применение узла Code Block ускоряет и упрощает эту операцию. Убедитесь, что строка соответствует точному имени в Revit с учетом регистра:
{"BldgWidth","BldgLength","BldgHeight", "AtriumOffset", "InsideOffset","LiftUp"};
.
Кроме того, необходимо указать значения для каждого параметра. Добавьте шесть узлов Integer Slider в рабочую область и переименуйте их в соответствии с параметром в списке. Для каждого регулятора установите значение, показанное на изображении выше (сверху вниз — 62, 92, 25, 22, 8, 12).
Создайте еще один узел Code Block, содержащий список той же длины, что и имена параметров. В этом случае мы присваиваем имена переменным (без кавычек), которые создают входные данные для узла Code Block. Соедините регуляторы с соответствующими входными параметрами:
{bw,bl,bh,ao,io,lu};
.Соедините узел Code Block с входным значением Element.SetParameterByName*. Если установлен флажок «Автоматическое выполнение процесса», результаты отобразятся автоматически.
* В этом примере рассматриваются параметры экземпляра, а не параметры типа.
Как и в Revit, многие параметры зависят друг от друга. Существует множество комбинаций, когда геометрия может нарушаться. Эту проблему можно решить с помощью формул, заданных в свойствах параметров. Кроме того, аналогичный алгоритм можно воспроизвести с помощью математических операций в Dynamo (данную задачу можно выполнить в дополнение к этому упражнению).
С помощью следующей комбинации можно придать оригинальный дизайн формообразующему элементу здания: 100, 92, 100, 25, 13, 51.
Теперь посмотрим, как можно отредактировать фасад, используя аналогичный процесс.
Скопируйте график и рассмотрите остекление фасада, где будет находиться ферма. В данном случае нужно изолировать четыре параметра:
{"DblSkin_SouthOffset","DblSkin_MidOffset","DblSkin_NorthOffset","Facade Bend Location"};
.Кроме того, нужно создать числовые регуляторы и присвоить им имена соответствующих параметров. Первые три регулятора (сверху вниз) необходимо перенастроить на область [0,10], а последний (Facade Bend Location) — на область [0,1]. Эти значения в нисходящем порядке должны начинаться со следующих чисел (хотя сами они произвольные): 2,68; 2,64; 2,29; 0,5.
Задайте новый узел Code Block и присоедините регуляторы:
{so,mo,no,fbl};
.
Изменяя положение регуляторов в этой части графика, можно сделать остекление фасада значительно более прочным: 9,98; 10,0; 9,71; 0,31.
В Dynamo можно создать массив элементов Revit с полным параметрическим управлением. Узлы Revit в Dynamo позволяют импортировать элементы из типовых геометрических объектов в категории определенных типов (например, стены и перекрытия). В этом разделе рассматривается импорт параметрически гибких элементов с адаптивными компонентами.
Адаптивный компонент — это гибкая категория семейства, которая хорошо подходит для генеративных приложений. После создания экземпляра можно построить сложный геометрический элемент, который определяется исходным положением адаптивных точек.
Ниже приведен пример адаптивного компонента на основе трех точек в редакторе семейств. Создается ферма, определяемая положением каждой адаптивной точки. В упражнении ниже с помощью этого компонента будет создана серия ферм по ширине фасада.
Адаптивный компонент — хороший пример применения взаимодействия. Задав опорные адаптивные точки, можно создать массив адаптивных компонентов. В свою очередь, при переносе этих данных в другие программы есть возможность свести геометрию к простым данным. Примерно такая же логическая схема используется при импорте и экспорте в программе Excel.
Предположим, что консультант по фасадным работам хочет узнать местоположение элементов фермы без разбиения готовой геометрии. При подготовке к производству консультант может указать местоположение адаптивных точек для регенерации геометрии в такой программе, как Inventor.
Рабочий процесс, который будет рассмотрен в упражнении ниже, позволяет получить доступ ко всем этим данным во время создания определения формирования элементов Revit. Благодаря этому можно объединить этапы создания концепции, разработки документации и производства в единый рабочий процесс. В результате формируется более интеллектуальный и эффективный механизм взаимодействия.
Еще одним способом импорта параметрической геометрии Dynamo в Revit является DirectShape. В целом элемент DirectShape и связанные классы отвечают за хранение созданных во внешних программах геометрических форм в документах Revit. Геометрия может включать в себя замкнутые тела или сети. Основной задачей DirectShape является импорт форм из других форматов данных, например IFC или STEP, когда недостаточно информации для создания реального элемента Revit. Как и при работе с форматами IFC и STEP, функция DirectShape подходит для импорта созданных в Dynamo геометрических объектов в проекты Revit в качестве реальных элементов.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
Возьмите файл примеров из этого раздела (или продолжите работу с файлом Revit из предыдущего сеанса), содержащий уже знакомый вам формообразующий элемент Revit.
После открытия файл выглядит следующим образом.
Видна система ферм, созданная при помощи Dynamo и интеллектуально связанная с формообразующим элементом Revit.
Теперь, когда мы применили узлы Select Model Element и Select Face, опустимся на одну ступень вниз по иерархии геометрии и воспользуемся узлом Select Edge. Если решатель Dynamo находится в автоматическом режиме, то при внесении изменений в файл Revit график будет постоянно обновляться. Ребро, которое необходимо выбрать, динамически привязано к топологии элементов Revit. Пока топология* остается неизменной, связь между Revit и Dynamo не прерывается.
Выберите самую верхнюю кривую остекленного фасада. Она проходит по всей длине здания. Если выбрать ребро не удается, в Revit можно навести на него указатель и нажимать клавишу TAB до тех пор, пока этот объект не будет выделен.
С помощью двух узлов Select Edge выберите ребра, представляющие скос в центре фасада.
Проделайте то же самое с нижними ребрами фасада в Revit.
Узлы Watch теперь демонстрируют наличие линий в Dynamo. Данные автоматически преобразуются в геометрию Dynamo, так как сами ребра не являются элементами Revit. Эти кривые будут использоваться в качестве опорных элементов для создания экземпляров адаптивных ферм по ширине фасада.
* Чтобы сохранить единообразную топологию, используется модель, в которую не были включены дополнительные грани или ребра. Параметры могут изменять ее форму, однако способ ее построения остается неизменным.
Сначала нужно соединить кривые и объединить их в общем списке. Это позволит «сгруппировать» кривые для выполнения операций с геометрией.
Создайте список для двух кривых по центру фасада.
Объедините эти две кривые в сложную кривую, подключив компонент List.Create к узлу Polycurve.ByJoinedCurves.
Создайте список для двух кривых в нижней части фасада.
Объедините эти две кривые в сложную кривую, подключив компонент List.Create к узлу Polycurve.ByJoinedCurves.
Наконец, объедините три основные кривые (одну линию и две сложные кривые) в один список.
Воспользуйтесь верхней кривой, которая представляет собой линию, расположенную по всей ширине фасада. Создайте плоскости вдоль этой линии для пересечения с набором кривых, которые были сгруппированы в списке.
С помощью узла Code Block задайте диапазон, используя синтаксис
0..1..#numberOfTrusses;
.Соедините узел Integer Slider с портом ввода узла Code Block. Как можно догадаться, он будет задавать количество ферм. Обратите внимание, что регулятор контролирует количество объектов в диапазоне от 0 до 1.
Соедините узел Code Block с портом ввода param узла Curve.PlaneAtParameter, а верхнее ребро — с портом ввода curve. Будет создано десять плоскостей, равномерно распределенных по ширине фасада.
Плоскость — это абстрактный элемент геометрии, представляющий собой бесконечное двумерное пространство. Плоскости отлично подходят для создания контуров и пересечений, что и требуется на данном этапе.
Используя узел Geometry.Intersect (задайте режим переплетения «Векторное произведение»), соедините компонент Curve.PlaneAtParameter с портом ввода entity узла Geometry.Intersect. Соедините основной узел List.Create с портом ввода geometry. Теперь на видовом экране Dynamo можно увидеть точки, обозначающие пересечение кривых с заданными плоскостями.
Обратите внимание, что выходные данные содержат список, в который вложен список с еще одним вложенным списком. Слишком большое число списков для решаемой задачи. Необходимо частично выровнять их. Спустимся на шаг вниз по списку и применим к результату функцию выравнивания. Для этого используем операцию List.Map, описанную в главе руководства, посвященной спискам.
Соедините узел Geometry.Intersect с портом ввода list узла List.Map.
Соедините узел Flatten с портом ввода f(x) узла List.Map. В результате получится 3 списка с количеством элементов, соответствующим количеству ферм.
Необходимо изменить эти данные. Для создания экземпляра фермы следует использовать такое же количество адаптивных точек, какое определено в семействе. Так как адаптивный компонент состоит из трех точек, вместо трех списков, содержащих по 10 элементов (numberOfTrusses), необходимо получить 10 списков с тремя элементами в каждом. Так можно создать 10 адаптивных компонентов.
Соедините узел List.Map с портом ввода узла List.Transpose. Теперь у вас есть нужные выходные данные.
Чтобы убедиться в правильности данных, добавьте узел Polygon.ByPoints в рабочую область и проверьте результат в области предварительного просмотра Dynamo.
Массив адаптивных компонентов создается так же, как полигоны.
Добавьте узел AdaptiveComponent.ByPoints в рабочую область и соедините узел List.Transpose с портом ввода points.
С помощью узла Family Types выберите семейство AdaptiveTruss и соедините его с портом ввода FamilyType узла AdaptiveComponent.ByPoints.
В Revit можно увидеть десять ферм, равномерно размещенных по ширине фасада.
Для «зондирования» графика увеличьте значение numberOfTrusses до 30 с помощью регулятора. В итоге получилось слишком большое и нереальное количество ферм, но при этом параметрическая связь действует. После проверки задайте для параметра numberOfTrusses значение 15.
В качестве финальной проверки выберите формообразующий элемент в Revit и отредактируйте параметры экземпляра. После изменения формы здания ферма тоже должна измениться. Обратите внимание, что это изменение можно наблюдать, только если график Dynamo открыт. Сразу после закрытия связь будет разорвана.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
Сначала откройте файл примеров для этого урока: ARCH-DirectShape-BaseFile.rvt.
На 3D-виде отображается формообразующий элемент здания из предыдущего урока.
Вдоль кромки атриума имеется одна базовая кривая. Она будет использоваться в Dynamo в качестве опорной.
Вдоль противоположной кромки атриума проходит еще одна базовая кривая. Она также будет использоваться в Dynamo в качестве опорной.
Чтобы установить связь с геометрией в Dynamo, используйте узел Select Model Element для каждого элемента в Revit. Выберите формообразующий элемент в Revit и импортируйте геометрию в Dynamo с помощью Element.Faces. Формообразующий элемент должен отображаться в области предварительного просмотра Dynamo.
Импортируйте первую базовую кривую в Dynamo с помощью Select Model Element и CurveElement.Curve.
Импортируйте вторую базовую кривую в Dynamo с помощью Select Model Element и CurveElement.Curve.
Конструкция определяется тремя основными параметрами: Diagonal Shift, Camber и Radius.
Увеличьте масштаб отображения параметров этого графика. Можно выполнить их зондирование, чтобы получить другие выходные данные геометрии.
Если поместить узел DirectShape.ByGeometry в рабочую область, можно увидеть, что у него есть четыре порта ввода: geometry, category, material и name.
Геометрия представляет собой твердое тело, созданное на основе той части графика, с помощью которой формируется геометрия.
Входные параметры категории выбираются с помощью узла Categories. В данном случае используется параметр Structural Framing.
Входные данные материала выбираются с помощью вышеупомянутого массива узлов, хотя в данном случае проще задать значение по умолчанию.
Вернитесь в Revit после выполнения сценария Dynamo. Импортированную геометрию можно видеть на крыше в проекте. Это скорее не обобщенная модель, а элемент несущего каркаса. Параметрическая связь с Dynamo сохраняется.
Ранее мы рассмотрели редактирование базового формообразующего элемента здания. Теперь мы предлагаем подробнее изучить взаимодействие Dynamo и Revit путем редактирования большого количества элементов за один подход. Адаптация усложняется при увеличении масштаба, так как структура данных требует более сложных операций со списками. Однако основные принципы работы при этом остаются прежними. Рассмотрим возможности расчета с помощью набора адаптивных компонентов.
Предположим, что вы создали набор адаптивных компонентов и хотите отредактировать параметры на основании местоположений точек. Например, точки могут определять параметр толщины, который связан с площадью элемента. Кроме того, они могут отвечать за параметр непрозрачности, связанный с уровнем инсоляции за год. Dynamo позволяет связать расчет с параметрами за несколько простых шагов. Основы этого процесса будут приведены в упражнениях ниже.
Опросите адаптивные точки выбранного адаптивного компонента с помощью узла AdaptiveComponent.Locations. Это позволяет выполнить расчет для абстрагированной версии элемента Revit.
Получив местоположение точек адаптивных компонентов, можно запустить несколько расчетов для элемента. Например, адаптивный компонент по четырем точкам позволяет изучить отклонение от плоскости для заданной панели.
Используя повторное сопоставление, можно сопоставить набор данных с диапазоном параметров. Это основной инструмент параметрического моделирования, который вы сможете изучить подробнее, выполнив упражнение ниже.
В Dynamo местоположения точек адаптивных компонентов можно использовать для создания плоскости наилучшего вписывания для каждого элемента. Кроме того, можно запросить положение солнца в файле Revit и изучить относительную ориентацию плоскости к солнцу по сравнению с другими адаптивными компонентами. Давайте выполним это путем создания алгоритмической кровли в упражнении ниже.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
В данном упражнении будут подробнее рассмотрены техники из предыдущего раздела. Вам понадобится определить параметрическую поверхность на основе элементов Revit, создать экземпляры адаптивных компонентов по четырем точкам, а затем отредактировать их на основании ориентации относительно солнца.
Для начала выберите два ребра с помощью узла Select Edge. Два ребра представляют собой длинные пролеты атриума.
Объедините два ребра в один список, используя узел List.Create.
Создайте поверхность между двумя ребрами с помощью узла Surface.ByLoft.
В узле Code Block задайте диапазон от 0 до 1 с 10 равномерно распределенными значениями:
0..1..#10;
.Соедините Code Block с портами ввода \u\ и v узла Surface.PointAtParameter, а также соедините узел Surface.ByLoft с портом ввода surface. Щелкните узел правой кнопкой мыши и задайте для параметра Переплетение значение Векторное произведение. На поверхности появится сетка из точек.
Эта сетка из точек служит в качестве управляющих точек для параметрической поверхности. Необходимо извлечь положения u и v каждой из этих точек, чтобы ввести их в параметрическую формулу и сохранить существующую структуру данных. Это можно сделать, запросив местоположения параметров только что созданных точек.
Добавьте узел Surface.ParameterAtPoint в рабочую область и соедините порты ввода, как показано выше.
Запросите значения u для этих параметров с помощью узла UV.U.
Запросите значения v для этих параметров с помощью узла UV.V.
В выходных данных отображаются соответствующие значения u и v для каждой точки поверхности. Вы получили диапазон от 0 до 1 для каждого значения, обеспечена правильная структура данных, и можно применять параметрический алгоритм.
Добавьте узел Code Block в рабочую область и введите код:
Math.Sin(u*180)*Math.Sin(v*180)*w;
. Это параметрическая функция, которая создает синусоидальную выпуклость на основе плоской поверхности.Соедините UV.U с входным параметром u и UV.V с входным параметром v.
Порт ввода w представляет амплитуду формы, поэтому к нему нужно присоединить узел Number Slider.
Теперь у вас есть список значений в соответствии с алгоритмом. Используйте этот список для перемещения точек вверх по оси +Z. Используя узел Geometry.Translate, соедините Code Block с портом ввода zTranslation, а Surface.PointAtParameter — с портом ввода geometry. В области предварительного просмотра Dynamo отображаются новые точки.
Наконец, создайте поверхность с помощью узла NurbsSurface.ByPoints, соединив узел из предыдущего шага с портом ввода points. В результате получается параметрическая поверхность. Перетаскивайте регулятор, чтобы уменьшить или увеличить выпуклость.
Теперь нам нужно найти способ разбить полученную параметрическую поверхность на панели, чтобы разместить адаптивные компоненты по четырем точкам в формате массива. В Dynamo нет готовой функции для работы с панелями, поэтому обратимся к сообществу пользователей за полезными пакетами Dynamo.
Перейдите к разделу «Пакеты» > «Поиск пакета...».
Найдите LunchBox и скачайте файл LunchBox for Dynamo. Это очень полезный набор инструментов для подобных операций с геометрией.
После скачивания вы получите полный доступ к пакету LunchBox. Найдите Quad Grid и выберите LunchBox Quad Grid By Face. Соедините параметрическую поверхность с портом ввода surface и установите деления U и V на 15. В области предварительного просмотра Dynamo должна отобразиться поверхность с прямоугольными панелями.
Если вас заинтересовала ее настройка, дважды щелкните узел Lunch Box и просмотрите параметры.
Вернитесь в Revit, чтобы узнать, какой адаптивный компонент используется в этой программе. Нет необходимости его повторять, но это панель крыши, которая будет использоваться в качестве экземпляра массива. Это адаптивный компонент по четырем точкам, который является грубым представлением системы ЭТФЭ. Апертура центральной полости находится на параметре ApertureRatio.
Так как вы собираетесь создать большое количество экземпляров геометрии в Revit, убедитесь, что решатель Dynamo находится в ручном режиме.
Добавьте узел Family Types в рабочую область и выберите ROOF-PANEL-4PT.
Добавьте узел AdaptiveComponent.ByPoints в рабочую область, соедините порт вывода Panel Pts узла LunchBox Quad Grid by Face с портом ввода points. Соедините узел Family Types с портом ввода familySymbol.
Нажмите кнопку Запуск. Для создания геометрии программе Revit потребуется немного времени на раздумья. Если это занимает слишком много времени, слегка уменьшите значение 15 в узле Code Block. Это уменьшит количество панелей на крыше.
Примечание. Если Dynamo требуется много времени для расчета узлов, возможно, вам следует воспользоваться функцией заморозки, чтобы поставить на паузу выполнение операций Revit во время создания графика. Дополнительные сведения о замораживании узлов см. в разделен «Замораживание» в главе «Тела».
В Revit мы видим массив панелей на крыше.
Увеличив масштаб, можно детально рассмотреть свойства их поверхности.
Используя результаты, полученные на предыдущем шаге, настройте апертуру каждой панели с учетом инсоляции. Увеличьте масштаб в Revit и выберите одну панель, чтобы увидеть на панели свойств параметр Коэффициент апертуры. В настройках семейства задан диапазон апертуры от 0,05 до 0,45.
Если включить траекторию солнца, можно увидеть текущее положение солнца в Revit.
С помощью узла SunSettings.Current можно задать положение солнца в качестве опорного значения.
Соедините узел SunSettings с узлом Sunsetting.SunDirection, чтобы получить вектор солнца.
На основе значения, полученного из порта вывода Panel Pts, использованного для создания адаптивных компонентов, выполните аппроксимацию плоскости для компонента с помощью узла Plane.ByBestFitThroughPoints.
Запросите нормаль этой плоскости.
Для расчета ориентации инсоляции используйте скалярное произведение. Скалярное произведение — это формула, которая определяет, насколько параллельны или не параллельны два вектора. Чтобы приблизительно смоделировать ориентацию инсоляции, вы сравниваете нормаль плоскости каждого адаптивного компонента с вектором солнца.
Извлеките абсолютное значение результата. Это гарантирует точность скалярного произведения, если нормаль плоскости повернута в обратном направлении.
Нажмите кнопку Запуск.
Скалярное произведение предоставляет широкий диапазон чисел. Нужно использовать их относительное распределение, однако необходимо объединить числа в соответствующем диапазоне редактируемого параметра Коэффициент апертуры.
Узел Math.RemapRange отлично для этого подходит. Он извлекает список входных данных и сопоставляет его пределы с двумя целевыми значениями.
Задайте целевые значения 0,15 и 0,45 с помощью узла Code Block.
Нажмите кнопку Запуск.
Соедините сопоставленные значения с узлом Element.SetParameterByName.
Соедините строку Aperture Ratio с портом ввода parameterName.
Соедините адаптивные компоненты с портом ввода element.
Нажмите кнопку Запуск.
Уменьшив масштаб в Revit, можно изучить влияние ориентации солнца на апертуру панелей ЭТФЭ.
При увеличении изображения видно, что панели ЭТФЭ более закрыты по направлению солнца. Цель данного упражнения — уменьшить перегрев из-за инсоляции. Если требуется увеличить проникновение света в помещение на основании инсоляции, просто смените область на Math.RemapRange.
Рядом с DynamoUnfold выберите меню параметров.
/
/
/
Для получения наиболее актуальной информации о разработке Dynamo рекомендуем посетить . В таблице ниже приведены ключевые этапы развития Dynamo for Civil 3D.
Что, если бы в проекте было 500 балок? Преобразование всех этих элементов в геометрию Dynamo заняло бы очень много времени. Если Dynamo требуется много времени для расчета узлов, возможно, следует воспользоваться функцией заморозки, чтобы приостановить выполнение операций Revit во время создания графика. Для получения дополнительных сведений о замораживании узлов см. раздел в главе «Тела».
По мере изучения новых возможностей, которые обеспечивают параметры редактирования, будет увеличиваться и количество элементов Revit, которые можно изменить с помощью Dynamo. Это может потребовать дополнительных вычислительных ресурсов , что, естественно, повлияет на скорость работы. При редактировании большого количества элементов можно воспользоваться узлом заморозки, чтобы приостановить выполнение операций Revit во время создания графика. Дополнительные сведения о замораживании узлов см. в разделе главы «Тела».
В ниже описывается то, как в Dynamo используются ссылки на данные для создания элементов Revit. Для формирования нескольких адаптивных компонентов необходимо создать список списков, в каждом из которых будет три точки, соответствующие трем точкам адаптивного компонента. Это будет необходимо учитывать при управлении структурами данных в Dynamo.
Во рассматривается использование DirectShape для импорта геометрии Dynamo в проект Revit. С помощью этого метода можно назначить категорию, материал и имя импортированной геометрии, сохранив при этом параметрическую связь с графиком Dynamo.
Если уменьшить масштаб графика и панорамировать его вправо, можно увидеть большую группу узлов. Это геометрические операции, которые создают решетчатую конструкцию на крыше, отображаемую в области предварительного просмотра Dynamo. Эти узлы генерируются с помощью функции Node to Code, описанной в разделе данного руководства, посвященного .
2024.1
2.18
2024
2.17
Обновление пользовательского интерфейса проигрывателя Dynamo
2023.2
2.15
2023
2.13
Обновление пользовательского интерфейса Dynamo
2022.1
2.12
Добавлены параметры хранения данных привязки объектов
Новые узлы для управления привязкой объектов
2022
2.10
Программа включена в основной пакет установки Civil 3D
Переход с IronPython на Python.NET
2021
2.5
2020.2
2.4
2020 Update 2
2.4
Добавлены новые узлы
2020.1
2.2
2020
2.1
Исходная версия
Возможно, со временем, когда базовых возможностей Dynamo станет недостаточно, вы захотите погрузиться в изучение внутреннего устройства этой программы. Информация в этом разделе поможет вам научиться работать с расширенными возможностями Dynamo for Civil 3D, которые позволят вам создавать графики наивысшего уровня.
Автомобильные и железные дороги, землеустройство, инженерные сети, топосъемка, ГИС...
Работа с объектами инфраструктуры включает в себя все это и многое другое. В этом разделе приведено несколько реалистичных и актуальных примеров графиков, которые помогут вам достичь высокого уровня владения Dynamo и раскрыть весь потенциал Dynamo for Civil 3D. Каждый график сопровожден подробным описанием логики, которая применялась при его создании, благодаря чему вы сможете не только использовать его, но и понять, зачем нужен каждый из его компонентов.
Кроме того, эти примеры основаны на проверенных временем передовых рекомендациях по построению эффективных графиков. При работе с примерами рекомендуется также ознакомиться с разделом Практические советы, в котором можно найти дополнительные идеи по созданию мощных, гибких и простых в сопровождении графиков.
Ранее мы упомянули, что узлы являются основными компоновочными блоками графика Dynamo. Узлы хранятся в библиотеке, где они сгруппированы по логическим признакам. В Dynamo for Civil 3D в библиотеке есть две категории (или полки), содержащие специальные узлы для работы с объектами AutoCAD и Civil 3D, такими как трассы, профили, коридоры, вхождения блоков и т. д. Прочие разделы библиотеки содержат универсальные узлы, одинаковые во всех версиях Dynamo (например, в Dynamo для Revit, Dynamo Sandbox и т. д.).
Подробные сведения об организации узлов в корневой библиотеке Dynamo см. в разделе Библиотека.
Специальные узлы для работы с объектами AutoCAD и Civil 3D
Узлы общего назначения
Узлы из пакетов сторонних разработчиков, которые можно установить отдельно
График Dynamo, в котором используются узлы из разделов AutoCAD и Civil 3D библиотеки, будет работать только в Dynamo for Civil 3D. Если открыть такой график Dynamo for Civil 3D в другой версии программы (например, в Dynamo для Revit), эти узлы будут помечены предупреждением и не будут запускаться.
Зачем нужны отдельные полки для AutoCAD и Civil 3D
Такой подход позволяет отделить узлы для собственных объектов AutoCAD (линии, полилинии, вхождения блоков и т. д.) от узлов для объектов Civil 3D (трассы, коридоры, поверхности и т. д.). С технической точки зрения, AutoCAD и Civil 3D — это два разных инструмента. AutoCAD — это базовое приложение, а Civil 3D — приложение, созданное на его основе.
Для работы с узлами AutoCAD и Civil 3D важно иметь четкое представление об иерархии объектов на каждой полке. Помните таксономические ранги, которые проходят на уроках биологии? Согласно им, все организмы в природе делятся на царства, типы, классы, порядки, семейства, рода и виды. Объекты AutoCAD и Civil 3D классифицируются аналогичным образом. Рассмотрим несколько примеров.
Рассмотрим в качестве примера трассу.
Допустим, требуется изменить имя трассы. Для этого добавим к имеющемуся графику узел CivilObject.SetName.
Поначалу все это может показаться довольно сложным. Что это за CivilObject и почему в библиотеке нет узла Alignment.SetName? Все дело в стремлении к возможности многократного использования и простоте. Если подумать, процесс изменения имени объекта Civil 3D всегда одинаков, будь то трасса, коридор, профиль или любой другой объект. Поэтому, вместо того чтобы создавать несколько узлов (например, Alignment.SetName, Corridor.SetName, Profile.SetName и т. д.), по сути выполняющих одну и ту же работу, все эти функции были заложены в один узел. В нашем случае это узел CivilObject.SetName.
Кроме того, к этому вопросу можно подойти со стороны связей между объектами. И трасса, и коридор являются типами объектов Civil, так же как и картофель, и морковь являются типами овощей. Узлы Civil.Object можно применять к объектам любого типа, точно так же как одну и ту же овощечистку можно применять и для очистки картофеля, и для очистки моркови. Представьте, какой хаос царил бы на кухне, если бы для чистки каждого вида овощей или фруктов использовался отдельный инструмент. В этом смысле библиотека узлов Dynamo похожа на кухню.
Идем дальше. Предположим, требуется изменить слой трассы. Для этого нам понадобится узел Object.SetLayer.
Почему он называется не CivilObject.SetLayer? Причина все та же: принципы простоты и возможности повторного использования, которые мы обсуждали ранее. Свойство layer есть у любого объекта AutoCAD, который можно нарисовать или вставить, например у линии, полилинии, текста, вхождения блока и т. д. Такие объекты Civil 3D, как трассы и коридоры, относятся к той же категории, поэтому любой узел, который применяется к категории Object, можно также использовать с любым объектом Civil.
При добавлении труб и колодцев в трубопроводную сеть Civil 3D назначение имен выполняется автоматически по шаблону. Обычно этого достаточно при первом размещении, однако в будущем по мере развития проекта эти имена потребуется изменить. Кроме того, существует множество разных шаблонов именования, таких как последовательное именование колодцев на участке трубопровода, начиная с самого дальнего, или именование в соответствии со схемой данных, принятой местными надзорными органами. В этом примере показано, как с помощью Dynamo можно определить стратегию именования и придерживаться ее.
Работа с ограничивающими рамками
Фильтрация данных с помощью узла List.FilterByBoolMask
Сортировка данных с помощью узла List.SortByKey
Создание и изменение текстовых строк
Этот график будет работать в Civil 3D 2020 и более поздних версиях.
Сначала скачайте файлы примеров ниже, а затем откройте файл DWG и график Dynamo.
Ниже представлен обзор логики, используемой в этом графике.
Выбор колодцев по слою.
Получение местоположений колодцев.
Фильтрация колодцев по смещению с последующей сортировкой по пикетам.
Создание новых имен.
Переименование колодцев.
Приступим!
Сначала необходимо выбрать все колодцы, с которыми мы планируем работать. Для этого просто выберем все объекты на определенном слое. Это означает, что мы сможем выбрать колодцы из разных трубопроводных сетей (при условии, что они находятся на одном слое).
Этот узел позволяет избежать случайного извлечения нежелательных типов объектов, которые могут находиться на том же слое, что и колодцы.
Теперь, когда мы выбрали все колодцы, нужно определить их положение в пространстве, чтобы рассортировать их по местоположению. Для этого воспользуемся ограничивающей рамкой каждого объекта. Ограничивающая рамка объекта — это рамка минимального размера, которая полностью включает геометрические границы этого объекта. Вычислив центр ограничивающей рамки, мы получим приближенное значение точки вставки колодца.
Мы используем эти точки для получения пикетов и смещений колодцев относительно выбранной трассы.
Здесь начинаются сложности. На данный момент у нас есть большой список всех колодцев на слое, который мы указали, и мы также выбрали трассу, вдоль которой их требуется отсортировать. Проблема в том, что в списке могут быть колодцы, которые не нужно переименовывать. Например, такие колодцы могут не принадлежать к интересующей нас ветви.
Выбранная трасса.
Колодцы, которые требуется переименовать.
Колодцы, которые следует игнорировать.
Нужно отфильтровать список колодцев, чтобы проигнорировать те из них, чье смещение от трассы превышает определенное значение. Для этого лучше всего подойдет узел List.FilterByBoolMask. Отфильтровав список колодцев, используем узел List.SortByKey для их сортировки по значениям пикетов.
Если вы еще не знакомы со списками, см. раздел Работа со списками.
Проверка значения смещения колодца относительно порогового значения.
Замена всех нулевых значений на false.
Фильтрация списка колодцев и пикетов.
Сортировка колодцев по пикетам.
Последний шаг — создание новых имен для колодцев. Мы используем следующий формат: <alignment name>-STRC-<number>
. Здесь есть несколько дополнительных узлов, которые при необходимости добавляют дополнительные нули (например, 01 вместо 1).
Наконец, мы может переименовать колодцы.
Ниже приведен пример запуска графика с помощью проигрывателя Dynamo.
Если вы еще не знакомы с проигрывателем Dynamo, см. раздел Проигрыватель Dynamo.
Вместо того чтобы сразу переходить к итоговому результату, можно использовать фоновый просмотр 3D в Dynamo для визуализации промежуточных результатов графика. Например, можно с легкостью отобразить ограничивающие рамки колодцев. Кроме того, в документе этого набора данных есть коридор, так что мы можем добавить геометрию характерных линий коридора в Dynamo, чтобы создать контекст для размещения колодцев в пространстве. Если применить этот график к набору данных, в котором нет коридоров, эти узлы просто не будут выполнять никаких действий.
Теперь мы можем наглядно увидеть, как работает процесс фильтрации колодцев по смещениям.
Вот несколько вариантов того, как можно расширить возможности этого графика.
Переименование колодцев на основе ближайшей трассы вместо выбора конкретной трассы.
Переименование труб в дополнение к переименованию колодцев.
Задание слоев для колодцев на основе их ветвей.
Теперь, когда вы получили общее представление об этой программе, перейдем к созданию вашего первого графика Dynamo в Civil 3D.
Это простой пример, демонстрирующий основные функции Dynamo. Рекомендуем работать с ним в новом, пустом документе Civil 3D.
Сначала откройте пустой документ в Civil 3D. Перейдите на вкладку Управление на ленте Civil 3D и найдите панель Визуальное программирование.
Нажмите кнопку Dynamo, чтобы запустить Dynamo в отдельном окне.
В чем разница между Dynamo и проигрывателем Dynamo
Dynamo — это приложение, используемое для построения и выполнения графиков. Проигрыватель Dynamo — это инструмент для легкого запуска графиков без необходимости открывать их в Dynamo.
Если вы хотите опробовать проигрыватель в действии, см. раздел Проигрыватель Dynamo.
После открытия Dynamo отобразится начальный экран. Нажмите кнопку Создать, чтобы открыть пустое рабочее пространство.
Где найти примеры
Dynamo for Civil 3D содержит несколько готовых графиков, которые помогут понять, как именно можно использовать Dynamo. Рекомендуем ознакомиться с ними, а также с разделом Примеры рабочих процессов данного руководства.
Сейчас перед вами должно быть пустое рабочее пространство. Давайте посмотрим, как работает Dynamo. Вот наша цель:
Звучит несложно, правда? Но прежде чем начать, рассмотрим несколько основных понятий.
Основные компоновочные блоки графика Dynamo называются узлами. Каждый узел подобен маленькому компьютеру: мы вводим в него данные, он их обрабатывает и выводит результат. В Dynamo for Civil 3D есть библиотека узлов, которые можно соединять друг с другом проводами для получения графика. График позволяет решать более масштабные задачи, чем отдельный узел.
Если вы никогда не работали с Dynamo
Некоторые понятия могут быть вам незнакомы, и это нормально. Следующие разделы помогут вам во всем разобраться.
Пользовательский интерфейс Узлы и провода Основные узлы и понятия
Итак, приступим к построению графика. Вот все узлы, которые нам понадобятся.
Чтобы найти эти узлы, введите их имена в строке поиска в библиотеке либо щелкните правой кнопкой мыши в любом месте рабочей области и выполните поиск там.
Как узнать, какие узлы нужно использовать и где их найти
Узлы в библиотеке группируются по логическим категориям в зависимости от назначения. Подробную информацию см. в разделе Библиотека узлов.
Итоговый график должен выглядеть следующим образом.
Подведем итог выполненной работе.
Мы выбрали документ, в котором будем работать. В данном случае (и во многих других) мы работаем с активным документом в Civil 3D.
Мы определили целевой блок, в котором должен быть создан текстовый объект (в данном случае — пространство модели).
Мы использовали узел String, чтобы указать, на каком слое должен находиться текст.
Мы создали точку с помощью узла Point.ByCoordinates, чтобы определить положение, в котором должен быть размещен текст.
Мы задали координаты X и Y точки вставки текста с помощью двух узлов Number Slider.
Мы использовали дополнительный узел String для определения содержимого текстового объекта.
Наконец, мы создали текстовый объект.
Давайте посмотрим, какие результаты выдает наш новый график.
Вернитесь в Civil 3D и убедитесь, что выбрана вкладка Модель. На ней должен отобразиться новый текстовый объект, созданный в Dynamo.
Если текст не отображается, возможно, нужно выполнить команду ПОКАЗАТЬ -> ГРАНИЦЫ, чтобы увеличить изображение.
Отлично! Теперь внесем в этот текст некоторые изменения.
Вернемся к графику Dynamo и изменим некоторые входные значения, например текстовую строку, координаты точки вставки и т. д. Текст в Civil 3D должен автоматически обновиться. Кроме того, обратите внимание, что при отключении одного из входных портов текст удаляется. Если снова подключить все элементы, текст будет создан повторно.
Почему Dynamo не вставляет новый текстовый объект при каждом запуске графика
По умолчанию программа Dynamo «запоминает» объекты, которые создает. При изменении входных значений узлов объекты в Civil 3D обновляются, а не создаются заново. Подробные сведения об этом механизме см. в разделе Привязка объекта.
В этом примере рассматривается лишь малая доля возможностей Dynamo for Civil 3D. Чтобы узнать больше, перейдите к следующему разделу.
Один из многих примеров эффективного применения Dynamo — динамическое размещение отдельных объектов вдоль модели коридора. Часто объекты требуется размещать в местах, не зависящих от вставленных сборок вдоль коридора. Если эту задачу выполнять вручную, она может быть очень утомительной. Кроме того, много приходится переделывать при изменении горизонтальной или вертикальной геометрии коридора.
Чтение данных из внешнего файла (в данном случае Excel)
Организация данных в словарях
Использование систем координат для управления положением, масштабом и поворотом
Размещение вхождений блоков
Визуализация геометрии в Dynamo
Этот график будет работать в Civil 3D 2020 и более поздних версиях.
Сначала скачайте файлы примеров ниже, а затем откройте файл DWG и график Dynamo.
Рекомендуем сохранить файл Excel в одной папке с графиком Dynamo.
Ниже представлен обзор логики, используемой в этом графике.
Чтение файла Excel и импорт данных в Dynamo.
Получение характерных линий из заданной базовой линии коридора.
Создание систем координат вдоль характерной линии коридора на требуемых пикетах.
Использование систем координат для размещения вхождений блоков в пространстве модели.
Приступим!
При работе с этим примером графика мы используем файл Excel для хранения данных, на основе которых Dynamo будет размещать вхождения блоков осветительных столбов. Вот как выглядит наша таблица.
Использование Dynamo для чтения данных из внешнего файла (например, файла Excel) — это отличная стратегия, особенно если эти данные необходимо предоставить другим участникам группы.
Данные Excel импортируются в Dynamo следующим образом.
Теперь, когда мы получили данные, нужно разделить их по столбцам — Corridor, Baseline, PointCode и т. д., — чтобы их можно было использовать в оставшейся части графика. Обычно для этого используется узел List.GetItemAtIndex и указывается порядковый номер каждого нужного столбца. Например, номер столбца Corridor — 0, столбца Baseline — 1 и т. д.
Пока все вроде бы в порядке. Однако при использовании такого подхода может возникнуть проблема. Что будет, если порядок столбцов в файле Excel впоследствии изменится? Или если между двумя столбцами будет вставлен третий? График перестанет работать должным образом, и его нужно будет изменить. Чтобы избежать этого, поместим данные в словарь, записав заголовки столбцов Excel в качестве ключей (keys), а остальные данные в качестве значений (values).
Если вы еще не знакомы со словарями, см. раздел Словари в Dynamo.
При таком подходе график будет более устойчивым, поскольку он сможет адаптироваться к изменению порядка столбцов в Excel. При условии что заголовки столбцов останутся неизменными, данные можно будет просто извлечь из словаря по ключу (заголовку столбца). Именно это мы и сделаем.
Итак, данные Excel импортированы и готовы к использованию. Начнем работать с ними, чтобы получить информацию о моделях коридоров из Civil 3D.
Выбор модели коридора по имени.
Получение нужной базовой линии в коридоре.
Получение характерной линии в пределах базовой линии по коду точки.
Теперь создадим системы координат вдоль характерных линий коридора на пикетах, значения которых заданы в файле Excel. Эти системы координат будут определять положение, поворот и масштаб вхождений блока осветительного столба.
Если вы еще не знакомы с системами координат, см. раздел Вектор, плоскость и система координат.
Обратите внимание, что мы используем Code Block для поворота систем координат в зависимости от того, на какой стороне базовой линии они находятся. Добиться этого можно также с помощью последовательности из нескольких узлов, но в данном случае проще взять и написать код.
Если вы еще не знакомы с элементами Code Block, см. раздел Узлы Code Block и DesignScript.
Мы на финишной прямой. У нас есть вся необходимая информация для размещения вхождений блоков. Сначала необходимо получить нужные определения блоков из столбца BlockName в файле Excel.
Теперь все, что осталось сделать, — это создать вхождения блоков.
При запуске графика в пространстве модели вдоль коридора должны отобразиться новые вхождения блоков. И вот что здорово: если выбран автоматический режим выполнения графика, то при внесении изменений в файл Excel вхождения блоков обновляются автоматически.
Для получения подробностей о режимах выполнения графиков см. раздел Пользовательский интерфейс.
Ниже приведен пример запуска графика с помощью проигрывателя Dynamo.
Если вы еще не знакомы с проигрывателем Dynamo, см. раздел Проигрыватель Dynamo.
Иногда может быть полезно визуализировать геометрию коридора в Dynamo для получения контекста. В этой модели тела коридора уже извлечены в пространство модели, поэтому перенесем их в Dynamo.
Однако нужно учесть еще кое-что. Тела относятся к довольно «тяжелому» типу геометрии. Это значит, что данная операция замедлит работу графика. Здесь нам бы пригодился механизм, позволяющий выбрать, должны тела отображаться или нет. Очевидное решение — просто отключить узел Corridor.GetSolids. Однако это приведет к отображению предупреждений для всех последующих узлов, что сделает просмотр неудобным. В данной ситуации идеальным решением будет узел ScopeIf.
Обратите внимание на серую полосу в нижней части узла Object.Geometry. Она означает, что предварительный просмотр узла отключен (его можно вызвать, щелкнув узел правой кнопкой мыши). Это позволяет узлу GeometryColor.ByGeometryColor избежать «конкуренции» с другой геометрией за приоритет отображения в фоновом просмотре.
По сути, узел ScopeIf позволяет выборочно запускать целую ветвь узлов. Если входной порт test получает значение false, то все узлы, подключенные к узлу ScopeIf, при запуске выполняться не будут.
Так выглядит результат в фоновом просмотре Dynamo.
Вот несколько вариантов того, как можно расширить возможности этого графика.
Добавление столбца rotation в файл Excel и его использование для поворота систем координат.
Добавление значений смещения по горизонтали или по вертикали в файл Excel, чтобы при необходимости осветительные столбы могли отклоняться от характерной линии коридора.
Создание значений пикетов непосредственно в Dynamo (вместо использования файла Excel со значениями пикетов) на основе начального пикета и типового интервала.
Разработка проекта стандартного жилого здания подразумевает работу с определенными подземными коммуникациями, такими как канализация, ливневая канализация, водопровод и т. п. В этом примере демонстрируется использование Dynamo для подключения того или иного участка застройки к распределительной магистрали. Обычно подключение к магистрали требуется на каждом участке, и потому размещение всех коммуникаций отнимает много времени. Dynamo позволяет ускорить этот процесс за счет автоматического создания точных геометрических объектов, а также гибкого ввода данных с возможностью настройки в соответствии со стандартами местных надзорных органов.
Использование узла Select Object для ввода данных пользователем
Работа с системами координат
Использование геометрических операций, таких как Geometry.DistanceTo и Geometry.ClosestPointTo
Создание вхождений блоков
Управление параметрами привязки объектов
Этот график будет работать в Civil 3D 2020 и более поздних версиях.
Сначала скачайте файлы примеров ниже, а затем откройте файл DWG и график Dynamo.
Ниже представлен обзор логики, используемой в этом графике.
Получение геометрии кривой для распределительной магистрали.
Получение геометрии кривой для выбранной пользователем линии участка (при необходимости с обращением ее направления).
Создание точек вставки для счетчиков
Получение точек на распределительной магистрали, ближайших к местоположениям счетчиков
Создание вхождений блоков и линий в пространстве модели
Приступим!
Сначала необходимо добавить геометрию для распределительной магистрали в Dynamo. Вместо того чтобы выбирать отдельные линии или полилинии, мы извлечем все объекты на определенном слое и объединим их в сложную кривую Dynamo.
Если вы еще не знакомы с кривыми Dynamo, см. раздел Кривые.
Теперь необходимо перенести геометрию выбранной линии участка в Dynamo, чтобы с ней можно было работать. Для этого нам понадобится узел Select Object, с помощью которого пользователь график может выбрать определенный объект в Civil 3D.
Нам также необходимо решить одну потенциальную проблему. Линия участка имеет начальную и конечную точки, а это значит, что у нее есть направление. Чтобы график давал последовательные результаты, все линии участка должны иметь одинаковое направление. Это условие можно задать непосредственно в логике графика, что сделает наш график более стабильным.
Получаем начальную и конечную точки линии участка.
Измеряем расстояние от каждой точки до распределительной магистрали, а затем определяем, какое расстояние больше.
Нужно, чтобы начальная точка линии находилась ближе к распределительной магистрали. Если это не так, требуется обратить направление линии участка. Если все правильно, то мы просто возвращаем исходную линию участка.
Теперь нужно решить, где будут размещены счетчики. Обычно их расположение определяется местными органами власти, поэтому мы просто укажем входные значения, которые можно изменить в соответствии с теми или иными условиями. В качестве основы для создания точек используем систему координат, расположенную вдоль линии участка. Это позволит с легкостью определить смещения относительно линии участка независимо от ее ориентации.
Если вы еще не знакомы с системами координат, см. раздел Вектор, плоскость и система координат.
Теперь нужно получить точки на распределительной магистрали, которые находятся ближе всего к счетчикам. Это позволит нам нарисовать линии подключения в пространстве модели так, чтобы они всегда были перпендикулярны к распределительной магистрали. Для этого идеально подойдет узел Geometry.ClosestPointTo.
Сложная кривая распределительной магистрали.
Точки вставки счетчиков.
Наконец, последний шаг — создание объектов в пространстве модели. Сначала мы используем созданные ранее точки вставки для создания вхождений блоков, а затем — точки на распределительной магистрали для построения линий подключения коммуникаций.
При запуске графика в пространстве модели должны отображаться новые вхождения блоков и линии подключения коммуникаций. Попробуйте изменить входные данные, чтобы увидеть, как программа автоматически обновит результаты.
Вы могли заметить, что после размещения объектов для одной линии участка эти объекты «перемещаются» при выборе другой линии участка.
Это стандартное поведение Dynamo, которое является желанным и полезным во многих случаях. Однако иногда может потребоваться разместить несколько последовательных подключений к коммуникациям так, чтобы программа Dynamo создавала при каждом запуске сценария новые объекты, а не изменяла исходные. Этим поведением можно управлять, изменив параметры привязки объекта.
Дополнительные сведения см. в разделе Привязка объекта.
Изменив этот параметр, мы заставляем программу Dynamo «забывать» объекты, создаваемые при каждом запуске графика. Ниже приведен пример запуска графика с отключенной привязкой объектов в проигрывателе Dynamo.
Если вы еще не знакомы с проигрывателем Dynamo, см. раздел Проигрыватель Dynamo.
Вот несколько вариантов того, как можно расширить возможности этого графика.
Размещение нескольких подключений к коммуникациям одновременно вместо выбора каждой линии участка по отдельности.
Изменение входных данных, чтобы вместо водопроводных счетчиков были размещены прочистные люки канализации.
Добавление переключателя, позволяющего разместить подключение к коммуникациям на конкретной стороне линии участка, а не на обеих ее сторонах.
Разработка кинематических границ для проверки зазора — важная часть проектирования железной дороги. С помощью Dynamo можно создавать тела для определения таких границ без необходимости в создании сложных элементов конструкции коридора и управления ими.
Работа с характерными линиями коридора
Преобразование геометрии при переходе между системами координат
Создание тел путем лофтинга
Управление поведением узла с помощью параметров переплетения.
Этот график будет работать в Civil 3D 2020 и более поздних версиях.
Сначала скачайте файлы примеров ниже, а затем откройте файл DWG и график Dynamo.
Ниже представлен обзор логики, используемой в этом графике.
Получение характерных линий из заданной базовой линии коридора.
Создание систем координат вдоль характерной линии коридора с требуемым интервалом.
Преобразование геометрии блока профиля в соответствии с системой координат.
Лофтинг тела между профилями.
Создание тел в Civil 3D.
Приступим!
Сначала необходимо получить данные коридора. Выберем модель коридора по имени, получим нужную базовую линию в коридоре, а затем извлечем характерную линию в пределах базовой линии по коду точки.
Теперь создадим системы координат вдоль характерных линий коридора между заданным начальным и конечным пикетами. Эти системы координат будут использоваться для выравнивания геометрии блока профиля транспортного средства по коридору.
Если вы еще не знакомы с системами координат, см. раздел Вектор, плоскость и система координат.
Обратите внимание на XXX в правом нижнем углу узла. Это означает, что для параметров переплетения узла задано значение Векторное произведение. Это необходимо для создания систем координат с одинаковыми значениями пикетов для обеих характерных линий.
Если вы еще не знакомы с переплетением узлов, см. раздел Что такое список.
Теперь необходимо каким-то образом создать массив профилей транспортных средств вдоль характерных линий. Для этого преобразуем геометрию из определения блока профиля транспортного средства с помощью узла Geometry.Transform. Эту концепцию сложно представить визуально, так что прежде чем перейти к узлам, посмотрим на график, чтобы понять, что именно произойдет.
По сути, мы извлекаем геометрию Dynamo из одного определения блока, а затем перемещаем и поворачиваем ее, в процессе создавая массив вдоль характерной линии. Неплохо, да? Ниже представлена последовательность узлов.
Здесь выполняется получение определения блока из документа.
Эти узлы извлекают геометрию Dynamo для объектов в блоке.
Эти узлы, по сути, определяют исходную систему координат, в которой геометрия находится до преобразования.
Наконец, в этом узле выполняется собственно преобразование геометрии.
Обратите внимание на длинное переплетение в этом узле.
Вот что мы получаем в Dynamo.
У нас для вас хорошая новость. Самое сложное позади! Все, что осталось сделать, — создать тела между профилями. Это можно легко сделать с помощью узла Solid.ByLoft.
Результат можно посмотреть здесь. Помните, что это тела Dynamo, а значит, их все еще нужно создать в Civil 3D.
Последний шаг — вывод сгенерированных тел в пространство модели. Кроме того, мы присвоим им цвет, чтобы сделать их более заметными.
Ниже приведен пример запуска графика с помощью проигрывателя Dynamo.
Если вы еще не знакомы с проигрывателем Dynamo, см. раздел Проигрыватель Dynamo.
Вот несколько вариантов того, как можно расширить возможности этого графика.
Добавление возможности использования разных диапазонов пикетов отдельно для каждого пути.
Разбивка тел на более мелкие сегменты, которые можно проанализировать отдельно на предмет конфликтов.
Проверка того, не пересекаются ли тела границы с элементами, и выделение цветом тех, которые пересекаются.
Dynamo for Civil 3D содержит эффективный механизм «запоминания» объектов, создаваемых каждым узлом. Этот механизм называется привязкой объекта, и он позволяет получать последовательные результаты при каждом запуске графика Dynamo в определенном документе. Во многих случаях подобное поведение программы является желательным, однако в определенных ситуациях пользователям требуется возможность управлять аспектами работы Dynamo более детально. В этом разделе описывается, как работает функция привязки объектов и как ее можно использовать.
Рассмотрим данный график, который позволяет создать окружность в пространстве модели на текущем слое.
Посмотрим, что произойдет при изменении радиуса.
Это функция привязки объекта в действии. По умолчанию программа Dynamo изменяет радиус существующей окружности, а не создает новую окружность при каждом новом входном значении радиуса. Это происходит потому, что при каждом запуске графика узел Object.ByGeometry «вспоминает», что он создал эту конкретную окружность. Кроме того, эта информация сохраняется в Dynamo, чтобы в следующий раз при открытии документа Civil 3D и запуске графика поведение программы было аналогичным.
Рассмотрим пример, в котором требуется изменить стандартное поведение функции привязки объекта в Dynamo. Предположим, требуется создать график, позволяющий разместить текст внутри окружности. При этом предполагается, что график будет запускаться многократно, и при каждом его запуске новый текст должен вставляться в конкретную выбранную окружность. Вот как может выглядеть этот график.
Однако вот что происходит при выборе разных окружностей.
Может показаться, что при каждом запуске графика текст удаляется и создается заново. На самом деле программа изменяет положение текста в зависимости от того, какая окружность выбрана. Это тот же самый текст, который просто помещен в другое место. Чтобы текст создавался заново каждый раз при запуске графика, необходимо изменить параметры привязки объекта Dynamo так, чтобы данные привязки не сохранялись в программе (см. раздел #binding-settings ниже).
Изменив данный параметр, мы получаем нужное поведение.
Dynamo for Civil 3D позволяет изменить поведение привязки объектов по умолчанию с помощью параметров Binding Data Storage (Хранение данных привязки) в меню Dynamo.
Обратите внимание, что параметры хранения данных привязки доступны в Civil 3D 2022.1 и более поздних версиях.
По умолчанию все параметры включены. Ниже приведен обзор каждого параметра.
Если этот параметр включен, Dynamo будет «забывать» объекты, созданные при последнем запуске того или иного графика. Этот график можно запускать в любом чертеже и в любых условиях, и каждый раз при его запуске будут создаваться новые объекты.
Рекомендации по использованию
Используйте этот параметр, если требуется, чтобы программа Dynamo «забывала» сделанное при предшествующих запусках графика и каждый раз создавала новые объекты.
Если этот параметр выбран, метаданные привязки объекта будут проиндексированы в графике (файл DYN) при его сохранении. Если закрыть и заново открыть график, а затем запустить его в том же чертеже, он должен работать точно таким же образом, что и до закрытия. При запуске этого же графика в другом чертеже данные привязки будут из него удалены, и в чертеже будут созданы новые объекты. Это означает, что при открытии исходного чертежа и повторном запуске в нем графика в дополнение к старым объектам будут созданы новые.
Рекомендации по использованию
Используйте этот параметр, если требуется, чтобы программа Dynamo «запоминала» объекты, созданные при последнем запуске графика в конкретном чертеже.
Этот параметр оптимален для ситуаций, когда определенный график Dynamo используется только в конкретном чертеже и больше нигде. Параметры 1 и 3 больше подходят для графиков, предназначенных для использования в нескольких чертежах.
Этот параметр похож на параметр 2, однако при его выборе данные привязки объекта индексируются не в графике (файл DYN), а в чертеже. Если закрыть и заново открыть график, а затем запустить его в том же чертеже, он должен работать точно таким же образом, что и до закрытия. Если запустить этот график в другом чертеже, данные привязки будут по-прежнему доступны в исходном чертеже, поскольку они сохраняются в нем, а не в графике.
Рекомендации по использованию
Используйте этот параметр, если требуется, чтобы программа Dynamo «запоминала» все полученные результаты при запуске определенного графика в нескольких чертежах.
Первое, что следует учесть при выборе этого параметра, — это то, он не влияет на взаимодействие графика с чертежом при запуске графика через основной интерфейс Dynamo. Этот параметр применяется только при запуске графика с помощью проигрывателя Dynamo.
Если вы еще не знакомы с проигрывателем Dynamo, см. раздел Проигрыватель Dynamo.
Если запустить график в основном интерфейсе Dynamo, а затем закрыть и запустить его снова, но уже в проигрывателе Dynamo, то в дополнение к созданным изначально объектам будут созданы новые. Однако после того, как график будет выполнен в проигрывателе Dynamo, данные привязки объектов будут индексированы в чертеже. Таким образом, если запустить один и тот же график несколько раз в проигрывателе Dynamo, то вместо создания новых объектов будут обновляться уже существующие. Если запустить этот же график через проигрыватель Dynamo в другом чертеже, данные привязки будут по-прежнему доступны в исходном чертеже, поскольку они сохраняются в нем, а не в графике.
Рекомендации по использованию
Используйте этот параметр, если требуется, чтобы проигрыватель Dynamo «запоминал» все полученные результаты при запуске определенного графика в нескольких чертежах.
С помощью проигрывателя Dynamo можно легко запускать графики Dynamo в Civil 3D. Используя проигрыватель, можно запустить любой созданный в Dynamo график. Опыт работы с Dynamo для этого не требуется. Это упрощает обмен графиками с другими пользователями, которые могут быть не заинтересованы в глубоком изучении узлов и проводов.
Дополнительные сведения о проигрывателе Dynamo в Civil 3D см. в документации на странице справки по Civil 3D.
Dynamo — это чрезвычайно мощный инструмент визуального программирования, однако его можно использовать не только для работы с узлами и проводами, но и для написания кода в текстовом формате. Сделать это можно двумя способами.
Написать код DesignScript с помощью Code Block.
Написать код Python с помощью узла Python.
В этом разделе рассматривается использование Python в среде Civil 3D для работы с .NET API программ AutoCAD и Civil 3D.
Общие сведения об использовании Python в Dynamo см. в разделе Python.
В AutoCAD и Civil 3D есть несколько API-интерфейсов, которые позволяют разработчикам расширять базовые возможности этих программ за счет пользовательских функций. В отношении Dynamo для этого применяются управляемые .NET API. По ссылкам ниже можно ознакомиться со сведениями, необходимыми для понимания структуры API-интерфейсов и принципа их работы.
Руководство разработчика .NET API AutoCAD (англ.)
Справочное руководство по .NET API AutoCAD (англ.)
Руководство разработчика .NET API Civil 3D (англ.)
Справочное руководство по .NET API Civil 3D (англ.)
В этом разделе могут встречаться незнакомые вам понятия, такие как базы данных, транзакции, методы, свойства и т. д. Многие из этих понятий необходимо знать для работы с .NET API, и они не относятся исключительно к Dynamo или Python. Мы не будем подробно рассматривать эти понятия в данном руководстве и потому рекомендуем обратиться к приведенным выше ссылкам для получения дополнительной информации.
Когда вы впервые откроете новый узел Python для его редактирования, он будет по умолчанию заполнен шаблонным кодом. Ниже приводится описание данного шаблона с пояснениями по каждому блоку.
Импорт модулей
sys
иclr
, необходимых для правильной работы интерпретатора Python. В частности, модульclr
позволяет обрабатывать пространства имен .NET как пакеты Python.Загрузка стандартных сборок (например, файлов DLL) для работы с управляемыми .NET API для AutoCAD и Civil 3D.
Добавление ссылок на стандартные пространства имен AutoCAD и Civil 3D. Эквивалентно директивам
using
иImports
в C# и VB.NET, соответственно.Доступ к входным портам узла осуществляется с помощью предварительно определенного списка
IN
. Для доступа к данным в определенном порте можно использовать его порядковый номер, например:dataInFirstPort = IN[0]
.Получение активных документа и редактора.
Блокировка документа и запуск транзакции базы данных.
Здесь размещается основная часть логики сценария.
Раскомментируйте эту строку, чтобы зафиксировать транзакцию после выполнения основного объема работы.
Если требуется вывести какие-либо данные из узла, назначьте их переменной
OUT
в конце сценария.
Хотите адаптировать шаблон?
Шаблон Python по умолчанию можно изменить, отредактировав файл PythonTemplate.py
, расположенный в папке C:\ProgramData\Autodesk\C3D <version>\Dynamo
.
Чтобы ознакомиться с некоторыми из основных понятий, относящихся к написанию сценариев Python в Dynamo for Civil 3D, рассмотрим пример.
Ниже приведены файлы примеров, которые можно использовать в этом упражнении.
Ниже представлен обзор логики, используемой в этом графике.
Изучить документацию по API Civil 3D.
Выбрать все водосборы в документе по имени слоя.
«Развернуть» объекты Dynamo для доступа ко внутренним элементам API Civil 3D.
Создать точки Dynamo на основе точек AutoCAD.
Создать сложные кривые по точкам.
Приступим!
Прежде чем приступить к созданию графика и написанию кода, ознакомьтесь с документацией по API Civil 3D, чтобы получить представление о доступных возможностях. В данном случае нас интересует свойство в классе Catchment, которое возвращает точки контура водосбора. Обратите внимание, что это свойство возвращает объект Point3dCollection
, но программа Dynamo не умеет обрабатывать такие объекты. Другими словами, мы не сможем создать сложную кривую на основе Point3dCollection
, поэтому нам придется преобразовать все полученные данные в точки Dynamo. Позже мы рассмотрим этот процесс подробнее.
Теперь можно приступить к выстраиванию логики графика. Сначала необходимо получить список всех водосборов в документе. Для решения этой задачи можно использовать узлы, поэтому мы не будем включать ее в сценарий Python. Использование узлов упрощает визуальное восприятие графика (не нужно пробираться через большой объем кода Python), а также позволяет посвятить сценарий Python выполнению одной задачи: получение точек контура водосборов.
Обратите внимание, что выходные данные узла All Objects on Layer представляют собой список элементов CivilObjects. Это связано с тем, что в Dynamo for Civil 3D в данный момент нет узлов для работы с водосборами, и именно поэтому нам требуется получить доступ к API через Python.
Прежде чем продолжить, кратко рассмотрим одну важную концепцию. В разделе Библиотека узлов была рассмотрена взаимосвязь элементов Object и CivilObject. Если рассмотреть эту взаимосвязь чуть глубже, можно увидеть, что каждый элемент Object Dynamo представляет собой оболочку для элемента Entity AutoCAD. Аналогичным образом, элемент CivilObject Dynamo представляет собой оболочку для элемента Entity Civil 3D. Эту оболочку можно снять, «развернув» элемент Object путем доступа к его свойствам InternalDBObject
или InternalObjectId
.
Object Autodesk.AutoCAD.DynamoNodes.Object
Entity Autodesk.AutoCAD.DatabaseServices.Entity
CivilObject Autodesk.Civil.DynamoNodes.CivilObject
Entity Autodesk.Civil.DatabaseServices.Entity
На практике в большинстве случаев надежнее сначала получить идентификатор объекта с помощью свойства InternalObjectId
, а затем получить доступ к объекту-оболочке в транзакции. Причина в том, что свойство InternalDBObject
возвращает элемент DBObject AutoCAD, недоступный для записи.
Вот полный сценарий Python, который обращается к внутренним объектам водосбора и получает их точки контура. В сценарии выделены строки, содержащие измененный шаблонный код или новый пользовательский код.
Для просмотра пояснений щелкните подчеркнутые строки сценария.
На практике основной объем логики сценария рекомендуется размещать внутри транзакции. Это обеспечивает безопасный доступ к объектам, которые сценарий считывает или записывает. Если пропустить транзакцию, во многих случаях это может привести к неустранимой ошибке.
На этом этапе сценарий Python должен вывести список точек Dynamo, который можно увидеть в фоновом просмотре. Нам осталось просто создать сложных кривые на основе этих точек. Обратите внимание, что сделать это можно напрямую в сценарии Python, однако мы намеренно размещаем эту операцию за пределами сценария, в узле, чтобы сделать ее более заметной. Вот как выглядит итоговый график.
А вот итоговая геометрия Dynamo.
Небольшой комментарий перед завершением данного раздела. Настройка узла Python может выполняться по-разному в зависимости от используемой версии Civil 3D. В Civil 3D 2020 и 2021 в Dynamo использовался инструмент IronPython, который позволял переносить данные между объектами .NET и сценариями Python. Однако в Civil 3D 2022 в Dynamo применяется стандартный встроенный интерпретатор Python (CPython), в котором используется Python 3. Переход на этот вариант обеспечивает ряд преимуществ, в том числе доступ к популярным современным библиотекам и новым возможностям платформы, а также установку обновлений и исправлений для системы безопасности.
Подробные сведения об этом переходе и обновлении сценариев предыдущих версий можно найти в блоге Dynamo. Если вы хотите и дальше работать с IronPython, установите пакет DynamoIronPython2.7 с помощью Dynamo Package Manager.
Эта строка позволяет нам получить определенный класс из библиотеки геометрии Dynamo. Обратите внимание, что здесь мы указываем import Point as DynPoint
, а не import *
. Это нужно, чтобы избежать конфликтов имен.
Здесь мы указали, какой именно порт ввода содержит нужные данные, вместо того чтобы использовать значение по умолчанию IN
, которое ссылается на список всех портов ввода.
[^13: Входной список объектов может содержать не только водосборы, но и другие элементы. Необходимо проверить, так ли это, и принять соответствующие меры (итерация цикла продолжается только в том случае, если элемент действительно является водосбором).
Здесь мы получаем точки контура водосбора с помощью соответствующего свойства, которое мы нашли ранее в документации по API. Как уже упоминалось, в результате мы получим объект Point3dCollection
, который по сути является списком точек AutoCAD. Чтобы использовать эти точки, нам потребуется преобразовать их в точки Dynamo.
Запускаем цикл для каждого объекта Point3d
в Point3dCollection
.
Работа с точками COGO и группами точек в Civil 3D является ключевым элементом многих процессов, связанных с завершением обработки полевых данных. Dynamo отлично подходит для управления данными. В этом примере мы рассмотрим один из возможных примеров использования.
Работа со списками
Группировка схожих объектов с помощью узла List.GroupByKey
Отображение пользовательских выходных данных в проигрывателе Dynamo
Этот график будет работать в Civil 3D 2020 и более поздних версиях.
Сначала скачайте файлы примеров ниже, а затем откройте файл DWG и график Dynamo.
Ниже представлен обзор логики, используемой в этом графике.
Получение всех точек COGO в документе.
Группировка точек COGO по описанию.
Создание групп точек.
Вывод сводных данных в проигрывателе Dynamo.
Приступим!
Сначала необходимо получить все группы точек в документе, а затем все точки COGO в каждой группе. В результате мы получим вложенный список, или список списков. Если мы выровняем все элементы в один список с помощью узла List.Flatten, это упростит дальнейшую работу.
Если вы еще не знакомы со списками, см. раздел Работа со списками.
Теперь, когда мы получили все точки COGO, необходимо разделить их на группы на основе их описаний. С этой задаче блестяще справится узел List.GroupByKey. По сути, он группирует все элементы с одинаковым ключом.
Самое сложное позади. Последний шаг — создание новой группы точек Civil 3D на основе сгруппированных точек COGO.
При запуске графика в области фонового просмотра Dynamo не отображается ничего, поскольку у нас нет никакой геометрии. Так что единственный способ убедиться, что график выполняется правильно, — проверить область инструментов или выполнить предварительный просмотр выходных данных узла. Однако если запустить график с помощью проигрывателя Dynamo, можно получить дополнительную информацию о результатах за счет вывода сводки по созданным группам точек. Для этого щелкнем узел правой кнопкой мыши и установим для него значение Является выводом. В данном случае для просмотра результатов используется переименованный узел Watch.
Ниже приведен пример запуска графика с помощью проигрывателя Dynamo.
Если вы еще не знакомы с проигрывателем Dynamo, см. раздел Проигрыватель Dynamo.
Вот несколько вариантов того, как можно расширить возможности этого графика.
Изменение принципа группировки точек, чтобы она выполнялась по полному описанию, а не по исходному.
Группировка точек по другим готовым категориям (например, «Базовые снимки», «Геодезические знаки» и т. д.).
Автоматическое создание поверхностей TIN для точек в определенных группах.
Пакеты Dynamo — это наборы инструментов, созданные сторонними разработчиками и призванные расширить основные функции Dynamo. Они доступны для всех, и их можно загрузить одним щелчком.
Дополнительные сведения по началу работы с пакетами см. в разделе Пакеты.
Ниже приведен список самых популярных пакетов, которые помогут вам создавать графики Dynamo for Civil 3D высшего уровня.
Civil 3D Toolkit — это пакет Dynamo for Civil 3D, который позволяет значительно усовершенствовать возможности Dynamo, поскольку содержит множество дополнительных узлов.
Camber — это пакет Dynamo for Civil 3D с открытым исходным кодом, который включает сотни узлов для работы с метками, внешними ссылками, быстрыми ссылками на данные, стилями и другими элементами.
CivilConnection — это пакет Dynamo для Revit с открытым исходным кодом, который поддерживает обмен данными между Civil 3D, Dynamo и Revit.
Arkance Systems Nodes — это пакет Dynamo for Civil 3D с широким спектром полезных узлов для работы с размерами, таблицами, видами, управлением сверлением и другими элементами.
Dynamo — это отличная возможность начать разработку программного обеспечения для архитектурно-строительной отрасли. Для начала работы с кодом вам будут полезны следующие разделы.
Блоки кода — это своеобразные окна, позволяющие заглянуть в самую глубь языка DesignScript, лежащего в основе Dynamo. DesignScript — это язык программирования, созданный специально для использования в рамках рабочих процессов проектирования. Это понятный и удобный для чтения язык, который позволяет моментально получать обратную связь при работе с небольшими частями кода, а также поддерживает масштабирование для работы с большими и сложными функциями. Кроме того, DesignScript — это основа мощного вычислительного «мотора» Dynamo. Поскольку почти все функциональные возможности узлов и операций Dynamo имеют прямые аналоги в языке создания сценариев, пользователи получают уникальную возможность свободно переходить от работы с узлами к работе со сценарием.
Для удобства начинающих пользователей узлы можно автоматически преобразовать в текстовый синтаксис, чтобы упростить обучение работе с DesignScript или просто уменьшить слишком большие разделы графиков. Это можно сделать с помощью процедуры под названием «от узла к коду» (Node to Code), которая подробно описана в разделе . Опытные пользователи могут применять узлы Code Block для создания уникальных комбинаций существующих функций и пользовательских связей на основе разнообразных стандартных парадигм работы с кодом. Все без исключения пользователи, от начинающих до опытных, могут воспользоваться широким спектром упрощенных методов и фрагментов кода, позволяющих ускорить процесс проектирования. Хотя термин «блок кода» может вызывать робость у пользователей, не занимающихся программированием, на деле эта функция столь же проста в использовании, сколь и эффективна. Начинающий пользователь может работать с блоками кода, практически не прибегая к программированию, а опытный — задавать определения на основе сценариев для вызова из других разделов определения Dynamo.
Говоря простым языком, блоки кода — это интерфейс для текстовой работы со сценарием в среде визуального программирования. Эти блоки можно использовать для задания чисел, строк, формул и других типов данных. Поскольку блоки кода разработаны специально для использования в Dynamo, пользователи могут задавать переменные в блоках кода, и эти переменные будут автоматически добавлены к портам ввода узла.
При работе с блоками кода пользователю предоставляется возможность определить, каким образом будут заданы входные данные. Ниже приведены способы построения базовой точки с координатами (10, 5, 0):
По мере изучения различных функций, доступных в библиотеке, вы можете обнаружить, что ввести в поле поиска Point.ByCoordinates гораздо быстрее, чем искать нужный узел по разделам библиотеки вручную. Например, при вводе Point. в Dynamo отобразится список подходящих функций, которые можно применить к объекту Point. Это делает процесс работы со сценариями интуитивно понятным и упрощает использование функций в Dynamo.
Для доступа к блокам Code Block перейдите в раздел Core >Input >Actions >Code Block. Есть и более быстрый способ: просто дважды щелкните в рабочей области, и в ней появится блок кода. Поскольку этот узел используется крайне часто, его вызов привязан к двойному щелчку.
Блоки кода поддерживают использование разных типов данных. Пользователи могут быстро задавать числа, строки и формулы, а блок кода предоставит требуемый результат.
На изображении ниже представлен традиционный способ работы с узлами, который отнимает у пользователей больше времени: сначала нужно найти требуемый узел в библиотеке, затем добавить его в рабочую область и, наконец, ввести входные данные. В случае с блоками кода пользователям достаточно дважды щелкнуть в рабочей области и ввести в появившийся узел нужный тип данных с использованием базового синтаксиса.
Узлы number, string и formula можно привести в качестве примеров узлов Dynamo, которые являются устаревшими по сравнению с блоками кода.
Традиционные методы
Узлы Code Block
Данное руководство призвано помочь вам начать работу с Dynamo for Civil 3D. Для получения дополнительных знаний вы можете обратиться к активному сообществу пользователей Dynamo. Приведенные ниже ресурсы помогут вам в процессе изучения программы.
Блоки кода (Code Block) — это уникальная функция Dynamo, обеспечивающая динамическую связь между визуальной и текстовой средами программирования. Блоки кода можно подключать ко всем узлам Dynamo, определяя с их помощью весь график в одном узле. Внимательно ознакомьтесь с этой главой, поскольку блок кода — это основополагающий компонент Dynamo.
Возможно, вы уже заметили закономерность в именах узлов Dynamo: для каждого узла используется синтаксис "." без пробелов. Это связано с тем, что текст в верхней части каждого узла представляет собой фактический синтаксис для создания сценариев, а символ "." (или запись через точку) отделяет элемент от доступных методов, которые можно вызвать. Это позволяет легко переходить от визуальных сценариев к текстовым.
В качестве примера использования записи через точку рассмотрим возможные действия с параметрическим яблоком в Dynamo. Ниже представлены несколько методов, которые можно применить к яблоку, перед тем как съесть (разумеется, на самом деле этих методов в Dynamo не существует, не ищите).
Судя по данным в таблице выше, это очень вкусное яблоко. Я бы его с удовольствием Apple.eat().
Используя аналогию с яблоком, рассмотрим узел Point.ByCoordinates и процесс создания точки с помощью узла Code Block.
Синтаксис Point.ByCoordinates(0,10);
для Code Block позволяет получить тот же результат, что и узел Point.ByCoordinates в Dynamo, но его преимущество состоит в том, что для создания точки требуется лишь один узел. Это проще и эффективнее, чем соединять отдельный узел с портами ввода X и Y.
Используя синтаксис Point.ByCoordinates в узле Code Block, необходимо указать входные данные в том же порядке, что и в готовом узле (X,Y).
С помощью узла Code Block можно вызвать любой стандартный узел библиотеки, кроме узлов пользовательского интерфейса, обладающих особыми функциями для пользовательского интерфейса. Например, можно вызвать узел Circle.ByCenterPointRadius, а вот вызывать узел Watch 3D не стоит.
Стандартные узлы, которых в библиотеке большинство, делятся на три типа. Как вы видите, вся библиотека упорядочена с учетом этих категорий. Методы (или узлы) этих трех типов обрабатываются иначе при вызове с помощью Code Block.
Create — узлы, позволяющие создавать или конструировать что-либо.
Action — узлы для выполнения действий с чем-либо.
Query — узлы для получения свойства существующего объекта.
Категория Create позволяет создавать геометрию с нуля. Значения вводятся в Code Block слева направо. Они располагаются в том же порядке, что и порты ввода в узле (сверху вниз).
При сравнении узла Line.ByStartPointEndPoint и соответствующего синтаксиса в узле Code Block мы получаем один и тот же результат.
Действие — это операция, выполняемая с объектами определенного типа. Для применения действий к объектам в Dynamo используется запись через точку, что является распространенным принципом для многих языков программирования. Если у вас есть объект, введите его название, затем точку, а затем название действия, которое с этим объектом нужно выполнить. Входные данные для метода этого типа помещаются в скобки, как и при использовании методов Create, однако для него не требуется указывать первые входные данные, которые отображаются в соответствующем узле. Вместо этого требуется указать элемент, с которым будет выполняться действие:
Поскольку узел Point.Add представляет собой узел типа Action, его синтаксис работает несколько иначе.
Входные данные включают в себя (1) точку и (2) вектор, который требуется к ней добавить. В синтаксисе узла Code Block точка (объект) обозначена как pt. Чтобы добавить вектор (vec) к точке (pt), нужно ввести pt.Add(vec), то есть «объект, точка, действие». Для операции добавления используются все порты ввода узла Point.Add, кроме первого. Первый порт ввода узла Point.Add — это сама точка.
Методы типа Query позволяют получить свойство объекта. Указывать какие-либо входные данные в этом случае не требуется, так как входными данными является сам объект. Скобки также не нужны.
Переплетение при использовании узлов отличается от переплетения с помощью Code Block. В первом случае пользователь щелкает узлы правой кнопкой мыши и выбирает параметр переплетения, который требуется применить. При работе с Code Block у пользователя есть гораздо больше возможностей для управления структурой данных. При объединении нескольких одномерных списков в пары с помощью сокращенного метода Code Block используются руководства по репликации. Цифры в угловых скобках «<>» определяют уровень иерархии итогового вложенного списка: <1>, <2>, <3> и т. д.
В этом примере мы используем сокращенную запись для определения двух диапазонов (подробнее о сокращенном методе можно узнать в следующем разделе этой главы). Проще говоря,
0..1;
эквивалентно{0,1}
, а-3..-7
эквивалентно{-3,-4,-5,-6,-7}
. В результате мы получаем список из двух значений X и пяти значений Y. Если работать с этими несогласованными списками без руководств по репликации, то будет получен список, содержащий две точки, что соответствует длине кратчайшего списка. Использование руководств по репликации позволяет найти все возможные сочетания двух и пяти значений координат (а точнее, их векторное произведение).Синтаксис Point.ByCoordinates
(x_vals<1>,y_vals<2>);
позволяет получить два списка с пятью элементами в каждом.Синтаксис Point.ByCoordinates
(x_vals<2>,y_vals<1>);
позволяет получить пять списков с двумя элементами в каждом.
Такой способ записи позволяет указать, какой список будет основным: два списка из пяти элементов или пять списков из двух. В этом примере результат будет представлять собой список строк точек или список столбцов точек в сетке в зависимости от изменения порядка руководств по репликации.
Чтобы овладеть описанными выше методами работы с Code Block, требуется определенное время. Функция «Узел для кодировки» Dynamo значительно упрощает этот процесс. Чтобы использовать эту функцию, выберите массив узлов в графике Dynamo, щелкните правой кнопкой мыши в рабочей области и выберите «Узел для кодировки». Программа Dynamo объединяет эти узлы в единый узел Code Block, содержащий все входные и выходные данные. Это не только отличный инструмент для изучения принципов работы узлов Code Block, но также он позволяет создавать с более эффективные параметрические графики Dynamo. Рекомендуем выполнить упражнение ниже, так как в нем используется функция «Узел для кодировки».
Скачайте файл с примером, щелкнув ссылку ниже.
Полный список файлов с примерами можно найти в приложении.
Для демонстрации возможностей узла Code Block преобразуйте существующее определение поля притяжения в форму Code Block. Использование существующего определения позволяет продемонстрировать связь Code Block с визуальным программированием, а также помогает в изучении синтаксиса DesignScript.
Для начала повторно создайте определение, показанное на изображении выше (или просто откройте файл примера).
Обратите внимание, что для параметра переплетения узла Point.ByCoordinates задано значение Векторное произведение.
Каждая точка сетки перемещена вверх по оси Z в соответствии с расстоянием до опорной точки.
Поверхность создана повторно и утолщена, что создает прогиб в геометрии относительно расстояния до опорной точки.
Сначала определите опорную точку: Point.ByCoordinates
(x,y,0);
. Используйте синтаксис Point.ByCoordinates, указанный в верхней части узла опорной точки.Переменные x и y вставляются в Code Block, чтобы их можно было динамически обновлять с помощью регуляторов.
Присоедините регуляторы к портам ввода узла Code Block и задайте их значения в диапазоне от –50 до 50. Это позволит работать по всей сетке Dynamo по умолчанию.
Во второй строке Code Block определите сокращенную запись для замены узла порядкового номера:
coordsXY = (-50..50..#11);
. Мы рассмотрим это подробнее в следующем разделе. Обратите внимание, что такая сокращенная запись эквивалентна узлу визуального программирования Number Sequence.
Теперь нужно создать сетку из точек последовательности coordsXY. Для этого необходимо использовать синтаксис Point.ByCoordinates. Кроме того, требуется запустить векторное произведение списка так же, как вы это делали при визуальном программировании. Для этого введите следующую строку:
gridPts = Point.ByCoordinates(coordsXY<1>,coordsXY<2>,0);
. Угловые скобки обозначают векторное произведение.Обратите внимание на узел Watch3D, в котором отображается сетка точек на сетке Dynamo.
Теперь самое сложное: нужно переместить сетку точек вверх в соответствии с расстоянием до опорной точки. Для начала присвойте этому новому набору точек имя transPts. Так как выполняется преобразование уже существующего элемента, вместо узла
Geometry.Translate...
используйте узелgridPts.Translate
.Считывая данные из этого узла в рабочей области, мы видим, что он содержит три порта ввода. Преобразуемая геометрия уже определена, так как действие выполняется с текущим элементом (с использованием gridPts.Translate). Названия двух оставшихся портов (direction и distance) следует поместить в скобки функции.
Определить значение direction несложно, так как для перемещения по вертикали используется
Vector.ZAxis()
.Теперь необходимо рассчитать расстояние между опорной точкой и каждой точкой сетки. Выполните это действие с опорной точкой аналогичным образом:
refPt.DistanceTo(gridPts)
.Последняя строка кода содержит преобразованные точки:
transPts=gridPts.Translate(Vector.ZAxis(),refPt.DistanceTo(gridPts));
.
Теперь у вас есть сетка точек, структура данных которой позволяет создать поверхность NURBS. Поверхность создается с помощью
srf = NurbsSurface.ByControlPoints(transPts);
.
Чтобы придать поверхности глубину, создайте тело с помощью синтаксиса
solid = srf.Thicken(5);
. Данный код увеличивает толщину поверхности на пять единиц, однако толщину также можно сделать переменной (например, с именем thickness), а затем изменять ее значение с помощью регулятора.
Функция «Узел для кодировки» позволяет автоматизировать все действия, которые вы выполнили в предыдущем упражнении, и применять их одним нажатием кнопки. Этот мощный инструмент не только позволяет создавать пользовательские определения и узлы Code Block для многократного использования, но и помогает в изучении процесса создания сценариев в Dynamo.
Для начала откройте существующий визуальный сценарий из первого шага упражнения. Выберите все узлы, щелкните правой кнопкой мыши в рабочей области и выберите Узел для кодировки. Проще простого.
Приложение Dynamo позволяет автоматизировать текстовую версию визуального графика, включая переплетение и прочие операции. Поэкспериментируйте с использованием этой функции при работе с другими визуальными сценариями и ознакомьтесь со всеми возможностями Code Block.
Существует несколько основных способов сокращенной записи команд в блоке кода, что существенно упрощает управление данными. Далее мы подробно рассмотрим, как использовать подобные сокращенные записи для создания и запроса данных.
Метод определения диапазонов и последовательностей можно заменить обычной сокращенной записью. Приведенное ниже изображение можно рассматривать как руководство по использованию синтаксиса «..» для определения списка числовых данных с помощью блока кода. Освоение этой системы записи позволит более эффективно формировать числовые данные.
В этом примере числовой диапазон заменяется элементарной синтаксической конструкцией узла Code Block, определяющей
beginning..end..step-size;
. В числовом выражении получаем0..10..1;
.Обратите внимание, что синтаксис
0..10..1;
эквивалентен синтаксису0..10;
. Значение шага 1 является значением по умолчанию для сокращенного обозначения. Таким образом, значение0..10;
соответствует последовательности от 0 до 10 с шагом 1.Похожий пример наблюдаем с узлом Sequence. Единственное исключение — знак #, указывающий на список из 15 значений, а не на список с увеличением до 15. В данном случае мы определяем
beginning..#ofSteps..step-size:
. Фактический синтаксис для последовательности:0..#15..2
.Разместим символ # из предыдущего шага в компоненте размер шага синтаксической конструкции. Теперь есть диапазон чисел, идущий от начала к концу, а размер шага равномерно распределяет несколько значений между этими двумя точками:
beginning..end..#ofSteps
.
Создание дополнительных диапазонов упрощает работу со списками списков. В примерах ниже переменная изолируется от обозначений основного диапазона и создается другой диапазон этого списка.
1. При создании вложенных диапазонов сравните запись с символом # и без него. Действует тот же принцип, что и в случае с основными диапазонами, но в усложненном варианте.
2. Вложенный диапазон может находиться в любом месте основного диапазона. Обратите внимание на возможность наличия двух вложенных диапазонов.
3. Используя различные значения конца диапазона, можно создавать дополнительные диапазоны с разной длиной.
В качестве упражнения сравните две сокращенные записи на изображении выше и попытайтесь проанализировать, как вложенные диапазоны и символ # влияют на конечный результат.
С помощью сокращений можно не только создавать списки, но и делать это динамически. Эти списки могут содержать множество типов элементов и поддерживают запросы (помните, что списки — это объекты в объектах). Наконец, в узле Code Block для создания списков и запроса элементов из списка используются скобки ( «квадратные скобки»):
1. Быстрое создание списков с помощью строк и запрос содержимого списков с помощью индекса элементов.
2. Создание списков с переменными и запрос содержимого с помощью сокращенной записи диапазонов.
Аналогичным образом можно работать с вложенными списками. Учитывайте порядок расположения списков, а для вызова используйте несколько наборов квадратных скобок:
1. Определение списка списков.
2. Запрос содержимого списка с помощью одного набора квадратных скобок.
3. Запрос содержимого списка с помощью двух наборов квадратных скобок.
Скачайте файл с примером, щелкнув ссылку ниже.
Полный список файлов с примерами можно найти в приложении.
В этом упражнении мы применим навыки сокращенной записи для создания оригинальной яйцевидной поверхности, которая будет определяться диапазонами и формулами. При выполнении упражнения обратите внимание на одновременное использование блока кода и существующих узлов Dynamo. Блок кода используется для обработки больших данных, а узлы Dynamo для наглядности.
Начните с создания поверхности путем соединения узлов, представленных на изображении выше. Вместо использования узла Number для определения ширины и длины поверхности дважды щелкните в рабочей области, а в узле Code Block введите 100;
.
Создайте диапазон от 0 до 1 с 50 делениями. Для этого введите
0..1..#50
в узле Code Block.Соедините диапазон с узлом Surface.PointAtParameter, который извлекает значения u и v в диапазоне от 0 до 1 по всей поверхности. Не забудьте в качестве режима «Переплетение» выбрать «Векторное произведение», щелкнув правой кнопкой мыши узел Surface.PointAtParameter.
На этом этапе с помощью первой функции переместим сетку точек вверх по оси Z. Эта сетка будет управлять поверхностью на основе базовой функции. Добавьте новые узлы, как показано на изображении ниже.
Вместо узла Formula используйте узел Code Block и укажите в нем следующую строку:
(0..Math.Sin(x*360)..#50)*5;
. Для быстроты мы определяем диапазон с помощью формулы внутри него. Эта формула представляет собой функцию синуса. Функция синуса получает входные данные в градусах в Dynamo, поэтому для получения полной синусоиды необходимо умножить значения x (диапазон входных значений от 0 до 1) на 360. Далее необходимо получить количество делений, соответствующее количеству точек управляющей сетки для каждого ряда, поэтому зададим пятьдесят подразделов, введя #50. Наконец, с помощью множителя 5 просто увеличим амплитуду преобразования, чтобы увидеть результат в области предварительного просмотра Dynamo.
Несмотря на то, что предыдущие узлы Code Block работали нормально, процесс не был полностью параметрическим. Поскольку необходимо динамически изменять его параметры, замените строку из предыдущего шага на
(0..Math.Sin(x*360*cycles)..#List.Count(x))*amp;
. Это позволит задавать значения на основе входных данных.
Изменим положение регуляторов (в диапазоне от 0 до 10) и получим интересный результат.
Транспонируйте диапазон чисел, чтобы обратить направление волны:
transposeList = List.Transpose(sineList);
.
Добавьте элементы sineList и tranposeList, чтобы получить деформированную яйцевидную поверхность:
eggShellList = sineList+transposeList;
.
Измените значения регуляторов, указанные ниже, чтобы «усреднить значения» алгоритма.
Осталось запросить отдельные элементы данных с помощью узла Code Block. Чтобы сформировать поверхность с определенным диапазоном точек, добавим блок кода, который показан на изображении выше, между узлами Geometry.Translate и NurbsSurface.ByPoints. В нем содержится строка текста: sineStrips[0..15..1];
. С помощью нее будут выбраны первые 16 рядов точек (из 50). Если снова сгенерировать поверхность, можно увидеть, что была создана отдельная часть сетки точек.
Наконец, чтобы сделать узел Code Block более параметрическим, для запроса используйте регулятор с диапазоном от 0 до 1. Для этого примените следующую строку кода:
sineStrips[0..((List.Count(sineStrips)-1)*u)];
. Для большей ясности — данная строка кода позволяет представить длину списка в виде множителя с диапазоном от 0 до 1.
Значение 0.53
регулятора позволяет создать поверхность сразу за центром сетки.
Как и ожидалось, если с помощью регулятора указать значение 1
, поверхность будет создана из всей сетки точек.
На полученном графике можно выделить узлы Code Block и увидеть их функции.
1. Первый Code Block заменяет узел Number.
2. Второй Code Block заменяет узел Number Range.
3. Третий Code Block заменяет узел Formula (а также узлы List.Transpose, List.Count и Number Range).
4. Четвертый Code Block запрашивает элементы в списке списков, заменяя узел List.GetItemAtIndex.
Переименование колодцев трубопроводной сети в порядке, соответствующем пикетажу трассы.
Миссия выполнена!
Создание графика Dynamo для вставки текста в пространство модели
Миссия выполнена!
Размещение вхождений блока осветительных столбов вдоль коридора со значениями пикетов, заданными в файле Excel.
Миссия выполнена!
Размещение вхождений блоков водомера на заданном смещении от линии участка и нанесение линии для каждого подключения перпендикулярно к распределительной магистрали.
Миссия выполнена!
Использование блока профиля транспортного средства для создания 3D-тел, определяющих границы зазора, вдоль коридора.
Миссия выполнена!
Получение геометрии границ всех водосборов на чертеже.
Миссия выполнена!
Создание группы точек для каждого уникального описания точки COGO.
Миссия выполнена!
В этом разделе представлены упражнения по созданию геометрии с помощью DesignScript. Для их выполнения следует просто скопировать примеры кода DesignScript в узлы Code Block в Dynamo.
Тип данных
Стандартный код Dynamo
Аналог в блоке кода
Числа
Строки
Последовательности
Диапазоны
Получение элемента по индексу
Создание списка
Объединение строк
Условные выражения
Узлы
Аналог в блоке кода
Примечание
Любой оператор (+, &&, >=, Not и т. д.)
+, &&, >=, ! и т. д.
Обратите внимание, что Not заменяется на «!», однако узел называется Not для отличия от Factorial.
Boolean True
true;
Все в нижнем регистре
Boolean False
false;
Все в нижнем регистре
Какого цвета яблоко?
Apple.color
Красный
Яблоко зрелое?
Apple.isRipe
true
Сколько весит это яблоко?
Apple.weight
170 г
Откуда взялось это яблоко?
Apple.parent
дерево
Что останется после яблока?
Apple.children
семена
Это яблоко выращено недалеко отсюда?
Apple.distanceFromOrchard
96,5 км
Создавать кривые произвольной формы в Dynamo можно двумя основными способами: задать набор точек и создать сглаженную кривую между ними путем интерполяции либо, если требуется получить кривую с конкретной степенью сглаживания, задать построение по управляющим точкам. Интерполяционные кривые подходят для случаев, когда проектировщик точно знает, какой формы должна быть линия, или когда в проекте заданы конкретные зависимости, определяющие то, где кривая может проходить, а где не может. Кривые по управляющим точкам представляют собой набор прямолинейных сегментов, который путем применения алгоритма сглаживается до получения требуемой кривой. Построение кривой по управляющим точкам позволяет сравнивать варианты с разными степенями сглаживания, а также обеспечивать последовательное применение сглаживания к криволинейным сегментам.
Для построения интерполяционной кривой достаточно задать набор точек и использовать его в качестве входных данных для метода NurbsCurve.ByPoints.
Полученная кривая пересекает каждую из заданных точек, а ее начало и конец находятся в первой и последней точках заданного набора соответственно. Задав дополнительный параметр периодичности, можно получить замкнутую периодическую кривую. При этом Dynamo автоматически подставит отсутствующий сегмент, так что отдельно задавать конечную точку, совпадающую с начальной точкой, не требуется.
Построение объектов NurbsCurve выполняется схожим образом. В качестве первого параметра задается набор точек (а именно конечных точек прямолинейных сегментов), а в качестве второго — величина и тип (т. е. степень) сглаживания кривой.* Кривая со степенью сглаживания 1 не сглаживается и представляет собой полилинию.
Кривая со степенью сглаживания 2 сглаживается таким образом, чтобы она проходила сквозь и по касательной к средним точкам сегментов полилинии:
В Dynamo поддерживаются NURBS-кривые (неоднородные рациональные B-сплайны) со степенью сглаживания от 1 до 20. Приведенный ниже сценарий демонстрирует, как повышение степени сглаживания влияет на форму кривой.
Обратите внимание, что число управляющих точек должно превышать значение степени сглаживания как минимум на единицу.
Еще одно преимущество построения кривых по управляющим вершинам — возможность сохранения касательности между отдельными криволинейными сегментами. Для этого программа определяет направление при движении от предпоследней управляющей точки сегмента к последней, а затем размещает две первые управляющие точки следующего сегмента в соответствии с этим направлением. В следующем примере показаны две отдельные NURBS-кривые, которые при этом выглядят как единая сглаженная кривая.
* В данной главе приведено упрощенное описание геометрии кривых NURBS. Для получения подробных сведений см. Pottmann, et al, 2007 г., в списке литературы.
Простейший геометрический объект, доступный в библиотеке стандартных геометрических объектов Dynamo, — это точка. Вся геометрия создается с помощью специальных функций (конструкторов), каждая из которых возвращает новый экземпляр геометрического объекта определенного типа. В Dynamo название каждого конструктора начинается с наименования типа объекта (в данном случае Point, точка), за которым следует метод построения объекта. Чтобы построить трехмерную точку на основе значений X, Y и Z в прямоугольной системе координат, используйте конструктор ByCoordinates:
Конструкторы в Dynamo обычно обозначаются приставкой By, и при вызове эти функции возвращают новый объект соответствующего типа. Этот объект сохраняется в переменной, имя которой указано слева от знака равенства.
Для создания большинства объектов можно использовать множество различных конструкторов. Используя конструктор BySphericalCoordinates, можно задать точку на сфере, определяемой по радиусу, а также первому и второму углам поворота (заданным в градусах):
Используя точки, можно создавать геометрические объекты более высокого уровня, например отрезки. С помощью конструктора ByStartPointEndPoint создайте объект Line (отрезок) между двумя точками:
Аналогичным образом из отрезков можно создавать геометрические объекты следующего уровня — поверхности. Для этого можно использовать, например, конструктор Loft, который выполняет интерполяцию поверхности между заданными отрезками или кривыми.
Поверхности также можно использовать для создания геометрии более высокого уровня, а именно тел. Сделать это можно, например, путем увеличения толщины поверхности на заданную величину. Многим объектам изначально назначены определенные функции, называемые методами, которые позволяют программистам выполнять действия с определенным объектом. К методам, доступным для всех геометрических объектов, относятся операции Translate и Rotate, которые позволяют переносить и поворачивать геометрию в соответствии с заданной величиной переноса или поворота. Для поверхностей доступен метод Thicken, для использования которого требуется одно входное значение — число, определяющее новую толщину поверхности.
Команды Intersect позволяют извлекать из геометрии высокого уровня более простые геометрические объекты. Такие объекты могут затем послужить основой для создания другой сложной геометрии. В результате получается циклический процесс создания, извлечения и повторного построения геометрии. В этом примере объект поверхности Surface, извлеченный из объекта тела Solid, используется для создания объекта кривой Curve.
Узлы Code Block позволяют вставлять в график функции, к которым смогут обращаться другие компоненты программы Dynamo. При этом в параметрическом файле создается еще один слой управления, который можно рассматривать как текстовую версию пользовательского узла. При этом «родительский» узел Code Block легко доступен и может находиться в любом месте графика. И никаких проводов!
Первая строка содержит ключевое слово «def», затем название функции и наименования входных данных в скобках. Тело функции заключено в фигурные скобки. Значение возвращается с помощью оператора «return =». В узлах Code Block, определяющих функцию, отсутствуют порты ввода и вывода, так как они вызываются из других блоков кода.
Функцию можно вызвать с помощью другого узла Code Block в том же файле, указав имя и такое же число аргументов. Этот процесс аналогичен использованию готовых узлов из библиотеки.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
В этом упражнении мы создадим типовую программу, которая будет генерировать сферы на основе вводимого списка точек. Радиус сфер определяется свойством Z каждой точки.
Для начала зададим десять числовых значений в диапазоне от 0 до 100. Соединим этот узел с узлом Point.ByCoordinates для создания диагональной линии.
Создайте узел Code Block и введите определение.
Используйте следующие строки кода:
inputPt — это имя, заданное для точек, которые будут определять функцию. В настоящее время эта функция не выполняет никаких действий, но она будет дополнена по ходу работы.
Дополните функцию Code Block, разместив комментарий и переменную sphereRadius, которая запрашивает положение каждой точки по оси Z. Напомним, что метод inputPt.Z не нужно заключать в скобки. Это запрос свойств существующего элемента, поэтому указывать входные данные не требуется.
Вызовите функцию, созданную в другом узле Code Block. Если дважды щелкнуть в активном окне для создания нового узла Code Block и ввести sphereB, то вы увидите, что Dynamo предложит использовать созданную выше функцию sphereByZ. Функция была добавлена в библиотеку IntelliSense! Неплохо.
Теперь вызовем функцию и создадим переменную Pt, чтобы использовать созданные ранее точки.
Обратите внимание, что на выходе мы получили нулевые значения. Почему? При определении функции был задан расчет переменной sphereRadius, но не было указано, что именно функция должна возвращать в качестве выходных данных. Наших следующим шагом будет исправление этого упущения.
Это важный шаг: необходимо задать выходные данные функции, добавив строку
return = sphereRadius;
в функцию sphereByZ.Теперь Code Block выводит координаты Z каждой точки.
Создадим сферы, отредактировав родительскую функцию.
Сначала определите сферу с помощью строки кода:
sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);
.Теперь измените возвращаемое значение на sphere вместо sphereRadius:
return = sphere;
. В области предварительного просмотра Dynamo появятся гигантские сферы.
1. Чтобы уменьшить размер этих сфер, обновите значение sphereRadius, добавив разделитель:
sphereRadius = inputPt.Z/20;
. Теперь видно отдельные сферы, что позволяет понять взаимосвязь между радиусом и значением Z.
В узле Point.ByCoordinates измените режим переплетения с «Самый короткий список» на «Векторное произведение», в результате чего будет создана сетка точек. Функция sphereByZ все еще действует, поэтому все точки создают сферы с радиусами, основанными на значениях Z.
Для проверки соединим исходный список чисел с входным портом X узла Point.ByCoordinates. Мы получили куб из сфер.
Примечание. Если для расчета компьютеру требуется много времени, попробуйте уменьшить значение #10 и задать вместо него, например, #5.
Поскольку созданная нами функция sphereByZ является типовой, можно вызвать спираль из предыдущего урока и применить эту функцию к ней.
И последний шаг: настройка коэффициента радиуса с помощью пользовательских параметров. Для этого необходимо создать новый входной порт для функции и заменить делитель 20 параметром.
Изменим определение sphereByZ на следующее:
Обновите дочерние узлы Code Block, добавив переменную ratio к входным данным:
sphereByZ(Pt,ratio);
. Добавьте регулятор к только что созданному узлу Code Block. Теперь можно изменять размер радиусов на основе коэффициента.
Несмотря на то что в Dynamo можно создавать разнообразные сложные геометрические формы, основу машинного проектирования составляют простые геометрические примитивы. Они либо задают итоговую форму спроектированной конструкции, либо играют роль каркаса, на котором достраивается более сложная геометрия.
Объект CoordinateSystem не является геометрическим объектом в строгом смысле, однако он играет важную роль при построении геометрии. Объект CoordinateSystem позволяет отслеживать как положение, так и геометрические преобразования, такие как поворот, сдвиг и масштабирование.
Для создания объекта CoordinateSystem, центрованного по точке с координатами x = 0, y = 0, z = 0 без поворота, масштабирования или сдвига, достаточно вызвать конструктор Identity:
Объекты CoordinateSystem, к которым были применены геометрические преобразования, в этой главе не рассматриваются, однако стоит упомянуть один конструктор, который позволяет создать систему координат в определенной точке, — CoordinateSystem.ByOriginVectors:
Простейшим геометрическим примитивом является Point (точка), обозначающий расположение, у которого отсутствуют измерения, в трехмерном пространстве. Как уже упоминалось ранее, создать точку в определенной системе координат можно несколькими способами: с помощью Point.ByCoordinates по заданным координатам X, Y и Z; с помощью Point.ByCartesianCoordinates по заданным координатам X, Y и Z в определенной системе координат; с помощью Point.ByCylindricalCoordinates на цилиндре, заданном по радиусу, углу поворота и высоте; и, наконец, с помощью Point.BySphericalCoordinates на сфере, заданной по радиусу и двум углам поворота.
В этом примере показаны точки, созданные в разных системах координат:
Следующим по сложности примитивом Dynamo является отрезок, который представляет собой бесконечное количество точек, лежащее между двумя конечными точками. Чтобы создать отрезок, можно либо явным образом задать две граничные точки с помощью конструктора Line.ByStartPointEndPoint, либо задать начальную точку, направление и длину с помощью конструктора Line.ByStartPointDirectionLength.
В Dynamo доступны объекты, представляющие базовые типы геометрических трехмерных примитивов: кубоиды, для создания которых используется Cuboid.ByLength; конусы, создаваемые с помощью Cone.ByPointsRadius и Cone.ByPointsRadii; цилиндры, получаемые при помощи Cylinder.ByRadiusHeight; и сферы, создаваемые с помощью Sphere.ByCenterPointRadius.
В машинном проектировании редко бывает так, что объекты создаются сразу в своей конечной форме и конечном положении. Чаще всего созданные объекты приходится переносить, поворачивать и иным образом позиционировать относительно существующей геометрии. Векторная математика играет роль своего рода геометрического каркаса, определяющего направление и ориентацию геометрии, а также позволяющего осмыслять перемещения геометрии по 3D-пространству без их визуального представления.
Если отбросить все лишнее, можно сказать, что вектор представляет собой то или иное положение в 3D-пространстве. Под вектором чаще всего подразумевают конечную точку стрелки, исходящей из начала координат (0, 0, 0) и указывающей на это местоположение. Векторы создаются с помощью конструктора ByCoordinates, в котором используются координаты X, Y и Z для нового объекта Vector. Обратите внимание, что объекты Vector не являются геометрическими объектами и не отображаются в окне Dynamo. При этом информацию о созданном или измененном векторе можно вывести на печать в окне консоли:
Объекты Vector поддерживают определенный набор математических операций, которые позволяют складывать, вычитать, умножать и иным образом преобразовывать объекты в 3D-пространстве точно так же, как и при работе с вещественными числами в одномерном пространстве числовой оси.
Операция сложения объектов Vector позволяет получить сумму компонентов двух векторов. Визуально представить себе результат сложения векторов можно, поместив начало второго вектора в конечную точку первого. Операция сложения объектов Vector выполняется с использованием метода Add и представлена на схеме слева.
Аналогичным образом можно вычесть один объект Vector из другого, используя метод Subtract. Результат вычитания двух векторов можно представить как расстояние от конечной точки одного вектора до конечной точки другого.
При умножении объекта Vector на какое-либо число его конечная точка перемещается в направлении, соответствующем направлению вектора, на расстояние, соответствующее длине вектора и множителю.
Зачастую при масштабировании вектора требуется, чтобы его длина стала равна значению коэффициента масштабирования. Этого можно легко добиться, выполнив нормализацию вектора, то есть приведя значение его длины к единице.
Вектор С указывает в том же направлении, что и вектор А (1, 2, 3), но его длина теперь равна 5.
Векторная материка включает два дополнительных метода, не имеющих точных аналогов в одномерной математике: это векторное произведение и скалярное произведение. При векторном произведении создается объект Vector, который ортогонален (т. е. находится под углом 90 градусов) к двум существующим объектам Vector. В качестве примера можно привести ось Z, которая является векторным произведением осей X и Y (хотя исходные объекты Vector, на основе которых вычисляется векторное произведение, не обязательно должны быть ортогональны друг другу). Для вычисления векторного произведения используется метод Cross.
Скалярное произведение — это еще одна дополнительная и чуть более сложная функция векторной математики. Результатом скалярного произведения двух векторов является вещественное число (а не объект Vector), соответствующее углу между этими векторами (но не равняющееся ему). Одним из полезных свойств этой функции является возможность определить, являются ли векторы перпендикулярными, поскольку только в этом случае их скалярное произведение равняется нулю. Для вычисления скалярного произведения используется метод Dot.
В машинном проектировании кривые и поверхности часто используются в качестве каркаса, поверх которого затем надстраивается более сложная геометрия. Чтобы эти базовые геометрические объекты можно было использовать в качестве основы для других объектов, необходимо написать сценарий для извлечения количественных характеристик, таких как положение и ориентация, по всей площади такого объекта. И кривые, и поверхности поддерживают этот процесс, который называется параметризацией.
Представим, что каждой точке на кривой назначен уникальный параметр в диапазоне от 0 до 1. Если мы создаем объект NurbsCurve путем интерполяции или по нескольким управляющим точкам, то первой точке назначается параметр со значением 0, а последней — параметр со значением 1. Заранее узнать, какой именно параметр будет назначен любой из промежуточных точек, невозможно. Эта проблему можно свести к минимуму путем использования нескольких вспомогательных функций. Процесс параметризации поверхностей аналогичен процессу для кривых, за исключением того, что вместо одного параметра назначаются два — u и v. Предположим, что требуется создать поверхность по следующим точкам:
В этом случае точке p1 будут назначены параметры u = 0, v = 0, а точке p9 — u = 1, v = 1.
Для определения точек, на основе которых строится кривая, параметризация не слишком эффективна. Ее основное назначение — определение местоположений промежуточных точек, создаваемых конструкторами NurbsCurve и NurbsSurface.
Для работы с кривыми доступен метод PointAtParameter, который в качестве входных данных использует один двойной аргумент в диапазоне между 0 и 1 и возвращает объект Point, соответствующий этому параметру. Например, при использовании этого сценария были определены точки с параметрами 0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9 и 1:
Для работы с поверхностями доступен аналогичный метод PointAtParameter, который в качестве входных данных использует два аргумента, а именно параметры u и v созданного объекта Point.
Хотя извлечение отдельных точек кривой или поверхности может быть само по себе полезно, для выполнения многих сценариев требуются определенные геометрические характеристики конкретного параметра, например направление кривой или поверхности. Метод CoordinateSystemAtParameter позволяет определить не только положение конкретного параметра кривой или поверхности, но и ориентацию соответствующего объекта CoordinateSystem. Например, следующий сценарий извлекает сведения об ориентации объектов CoordinateSystem относительно поверхности вращения и использует эти сведения для построения отрезков перпендикулярно этой поверхности:
Как уже упоминалось, параметризация не всегда выполняется равномерно по всей длине кривой или поверхности. Это значит, что параметр 0.5 не всегда соответствует средней точке, а параметр 0.25 — точке на отметке в одну четвертую длины кривой или поверхности. Чтобы обойти это ограничение, можно воспользоваться дополнительным набором команд параметризации, доступным для объектов Curve. Эти команды позволяют найти точки, расположенные в определенном месте на кривой.
Методы Intersect, Trim и SelectTrim в основном используются при работе с простыми геометрическими объектами, такими как точки, кривые и поверхности. Для твердотельных геометрических объектов доступны дополнительные методы изменения формы после ее построения. Эти методы включают как удаление материала аналогично методу Trim, так и объединение нескольких элементов для получения единого большого элемента.
Метод Union позволяет создать новый твердотельный объект на основе двух исходных объектов. Итоговый объект занимает в пространстве столько же места, сколько занимали оба исходных. Если объекты накладываются друг на друга в пространстве, то в итоговой форме накладывающиеся участки объединяются. В этом примере из сферы и кубоида путем объединения была получена единая кубо-сферическая твердотельная форма:
Метод Difference, аналогично методу Trim, позволяет удалить из базового тела материал, объем которого соответствует используемому на входе твердотельному инструменту. В этом примере в сфере был создан небольшой вырез:
Результатом использования метода Intersect является тело, образованное наложением двух других тел. В следующем примере вместо метода Difference был использован метод Intersect, в результате чего было получено тело, объем которого соответствует вырезу в предыдущем примере:
Приведенные ниже сценарии Python позволяют создать массивы точек, которые будут использованы в нескольких примерах. Их требуется вставить в узел Python Script следующим образом:
python_points_1
python_points_2
python_points_3
python_points_4
python_points_5
Во многих рассмотренных примерах основное внимание было уделено построению более сложных геометрических объектов на основе более простых объектов. Методы Intersect позволяют делать обратное, а именно получать простые геометрические объекты из сложных. Команды Trim и SelectTrim позволяют использовать сценарии для масштабных преобразований геометрических форм после их создания.
Метод Intersect поддерживается всеми геометрическими объектами в Dynamo. В теории это значит, что любой геометрический объект может пересекаться с любым другим геометрическим объектом. Разумеется, построение определенных пересечений, таких как пересечение объектов Point, не имеет смысла, поскольку результатом пересечения будет тот же объект Point, который был задан на входе. Другие возможные комбинации пересекающихся объектов приведены в следующей таблице. В ней указаны возможные результаты различных операций пересечения.
Где:
Поверхность
Кривая
Плоскость
Тело
Поверхность
Кривая
Точка
Точка, кривая
Поверхность
Кривая
Точка
Точка
Точка
Кривая
Плоскость
Кривая
Точка
Кривая
Кривая
Тело
Поверхность
Кривая
Кривая
Тело
Приведенный ниже пример иллюстрирует пересечение плоскости с поверхностью NurbsSurface. В результате пересечения получается массив NurbsCurve, который можно использовать как любой другой объект NurbsCurve.
Метод Trim очень похож на метод Intersect. Он поддерживается почти для всех геометрических объектов. Однако в отношении метода Trim действует больше ограничений, чем в отношении метода Intersect.
Объект, с помощью которого выполняется обрезка: точка
Кривая
Плоскость
Поверхность
Тело
Объект, на котором выполняется обрезка: кривая
Да
Нет
Нет
Нет
Нет
Полигон
-
Нет
Да
Нет
Нет
Поверхность
-
Да
Да
Да
Да
Тело
-
-
Да
Да
Да
Особенностью методов Trim является обязательное наличие точки «выбора», определяющей, какая геометрия будет обрезана, а какая сохранена. Dynamo использует точку выбора для выявления геометрии, находящейся ближе всего к этой точке, и затем обрезает эту геометрию.
Объект NurbsSurface является двумерным аналогом объекта NurbsCurve. Как и объекты NurbsCurve, объекты NurbsSurfaces создаются двумя основными способами: путем интерполяции набора базовых точек либо указания управляющих точек поверхности. Аналогично кривым произвольной формы интерполяционные поверхности подходят для случаев, когда проектировщик точно знает, какой формы должна быть поверхность, или когда в проекте заданы конкретные точки зависимости, через которые плоскость должна проходить. Поверхности по управляющим точкам подходят для случаев, требующих анализа поведения поверхности при различных уровнях сглаживания.
Для создания интерполяционной поверхности достаточно задать двумерный набор точек, приблизительно соответствующий форме поверхности. Набор должен быть прямоугольным, без изломов. Чтобы создать поверхность из этих точек, используйте метод NurbsSurface.ByPoints.
Кроме того, объекты NurbsSurface произвольной формы можно создавать путем задания базовых управляющих точек. Как и в случае с объектами NurbsCurve, управляющие точки образуют четырехугольную сеть, состоящую из прямолинейных сегментов, к которой применена та или иная степень сглаживания. Для создания объекта NurbsSurface по управляющим точкам в метод NurbsSurface.ByPoints необходимо добавить два дополнительных параметра, которые позволяют указать степень сглаживания базовых кривых по обеим сторонам поверхности.
Увеличив степень сглаживания объекта NurbsSurface, можно изменить итоговую геометрию поверхности.
Интерполяционные поверхности можно создавать не только на основе наборов точек, но и на основе наборов кривых. Это называется лофтингом. Для построения лофтированных поверхностей используется конструктор Surface.ByLoft, где в качестве единственного входного параметра указывается набор кривых.
Поверхности вращения — это дополнительный тип поверхностей, который создается путем сдвига базовой кривой относительно центральной оси. Такие поверхности являются двумерным аналогом окружностей и дуг, точно так же как интерполяционные поверхности являются двумерным аналогом интерполяционных кривых.
Для построения поверхности вращения необходимо задать базовую кривую («кромку» поверхности), начало координат оси (базовую точку поверхности), направление оси (направление «центра», вокруг которого строится поверхность), начальный и конечный углы сдвига. Все эти данные используются в качестве входных параметров конструктора Surface.Revolve.
Определенные геометрические объекты можно создавать путем непосредственного указания их координат по осям X, Y и Z в трехмерном пространстве. Однако в большинстве случаев итоговое положение геометрии задается путем преобразований, применяемых либо к самому объекту, либо к его базовой системе координат (CoordinateSystem).
Простейшим геометрическим преобразованием является перенос, в результате которого объект перемещается на заданное число делений вдоль осей X, Y и Z.
Любой объект в Dynamo можно перенести, просто добавив метод .Translate после имени объекта, однако более сложные преобразования требуют изменения базовой системы координат объекта (CoordinateSystem). Например, чтобы повернуть объект на 45 градусов вокруг оси X, потребуется заменить существующую систему координат (без поворота) на систему координат, повернутую на 45 градусов вокруг оси X с помощью метода .Transform.
Помимо операций переноса и поворота к объектам CoordinateSystem также можно применять операции масштабирования и сдвига. Для масштабирования объектов CoordinateSystem используется метод .Scale.
Для сдвига объекта CoordinateSystem используется конструктор CoordinateSystem, в который нужно ввести неортогональные векторы.
По сравнению с поворотом и переносом операции масштабирования и сдвига являются более сложными и поддерживаются не всеми объектами Dynamo. Объекты Dynamo, которые поддерживают операции изменения масштаба и сдвига системы координат, перечислены в следующей таблице.
Дуга
Нет
Нет
Объект NurbsCurve
Да
Да
Объект NurbsSurface
Нет
Нет
Окружность
Нет
Нет
Отрезок
Да
Да
Плоскость
Нет
Нет
Точка
Да
Да
Полигон
Нет
Нет
Тело
Нет
Нет
Поверхность
Нет
Нет
Текст
Нет
Нет
Python — это широко распространенный язык программирования, получивший большую популярность благодаря стилю используемого синтаксиса. Этот язык значительно доступнее и проще, чем многие другие языки программирования. Python поддерживает модули и пакеты, а также может быть внедрен в существующие приложения. Тем, кто только начинает работу с Python, мы рекомендуем посетить страницу на веб-сайте .
Этот раздел данного руководства является своеобразным сборником полезных советов. В нем рассказывается о разных стратегиях, разработанных на основе опыта и результатов исследований и позволяющих повысить качество параметрических рабочих процессов. Как проектировщики и программисты, мы измеряем качество наших инструментов их стабильностью, надежностью, удобством и эффективностью. В этом разделе вы найдете отдельные примеры для визуальных и текстовых сценариев, однако основополагающие принципы являются универсальными для всех сред программирования и могут использоваться в самых разных вычислительных рабочих процессах.
В предыдущем разделе был приведен пример использования сценариев Python в Dynamo. Теперь рассмотрим подключение библиотек Revit в среде сценариев. Как вы помните, мы импортировали стандартную библиотеку Python и базовые узлы Dynamo с помощью первых четырех строк в блоке кода, представленном ниже. Для импорта узлов Revit, элементов Revit и диспетчера документов Revit необходимо добавить еще несколько строк:
Это обеспечит доступ к API Revit и позволит создавать пользовательские сценарии для любых задач Revit. Благодаря объединению процесса визуального программирования с написанием сценариев в API Revit возможности совместной работы и разработки инструментов значительно увеличиваются. Например, специалист по BIM и проектировщик схем могут совместно работать над одним и тем же графиком. В результате эффективность проектирования и реализации модели повысится.
Создайте новый проект Revit.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
В этих упражнениях рассматриваются простейшие сценарии Python, которые можно использовать в модуле Dynamo для Revit. Данное упражнение посвящено работе с файлами и элементами Revit, а также взаимодействию между Revit и Dynamo.
Рассмотрим стандартный способ извлечения элементов doc, uiapp и app из файла Revit, связанного с сеансом Dynamo. Программистам, которые уже работали с API Revit, могут быть знакомы элементы в списке отслеживания. Однако даже если эти элементы встречаются в первый раз, в последующих упражнениях будут и другие примеры.
Ниже описывается процедура импорта служб Revit и извлечения данных документа в Dynamo.
Посмотрите, как выглядит узел Python в Dynamo. Код также можно найти ниже.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
В этом упражнении будет создана простая кривая модели в Revit с помощью узла Python в Dynamo.
Для начала добавьте в Revit новое семейство концептуальных формообразующих элементов.
Откройте папку Conceptual Mass и используйте файл шаблона Metric Mass.rft.
В Revit используйте комбинацию клавиш un
, чтобы вызвать окно параметров«Единицы проекта», и измените единицы измерения длины на метры.
Запустите Dynamo и сформируйте набор узлов, как показано на изображении ниже. Сначала создайте две опорные точки в Revit с помощью узлов Dynamo.
Создайте узел Code Block и присвойте ему значение
"0;"
.Соедините это значение с портами ввода X, Y и Z узла ReferencePoint.ByCoordinates.
Создайте три регулятора в диапазоне от –100 до 100 с шагом 1.
Соедините каждый из регуляторов с узлом ReferencePoint.ByCoordinates.
Добавьте в рабочее пространство узел Python, нажмите кнопку «+» в узле, чтобы добавить еще один порт ввода, и соедините опорные точки с портами ввода. Откройте узел Python.
Посмотрите, как выглядит узел Python в Dynamo. Полный код см. ниже.
System.Array. Приложению Revit в качестве входного параметра требуется системный массив (а не список Python). Для этого необходима лишь еще одна строка кода, но следует уделить особое внимание типам аргументов, чтобы упростить программирование на языке Python в Revit.
В Dynamo с помощью Python мы создали две опорные точки, соединенные линией. Продолжим работу с этим примером в следующем упражнении.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
Это упражнение довольно несложное, однако оно хорошо иллюстрирует процесс обмена данными и геометрией между Revit и Dynamo. Сначала откройте файл Revit-StructuralFraming.rvt. Затем запустите Dynamo и откройте файл Revit-StructuralFraming.dyn.
Этот файл Revit содержит лишь самые базовые данные. Имеются две опорные кривые: одна на уровне 1, другая — на уровне 2. Эти кривые необходимо добавить в Dynamo, сохранив динамическую связь.
В файле имеется набор узлов, соединяемых с пятью портами ввода узла Python.
Узлы Select Model Element. Нажмите кнопку выбора в каждом узле и выберите соответствующую кривую в Revit.
Code Block. Используя синтаксис
0..1..#x;
, соедините регулятор целых чисел от 0 до 20 с портом ввода x. Этот регулятор задает количество балок, которые будут построены между двумя кривыми.Structural Framing Types. В раскрывающемся меню выберите балку по умолчанию (W12x26).
Levels. Выберите Level 1.
Этот код Python чуть более сложен, но весь процесс снабжен подробными комментариями.
Итак, в Revit появился массив балок, расположенных между двумя кривыми и играющих роль несущих элементов. Примечание. Данный пример не вполне реалистичен. Несущие элементы используются всего лишь в качестве примера собственных экземпляров Revit, созданных в Dynamo.
Результаты также можно увидеть в Dynamo. Балки в узле Watch3D ссылаются на геометрию, запрошенную из элементов Revit.
Обратите внимание, что полученный процесс преобразования данных из среды Revit в среду Dynamo является непрерывным. Вкратце этот процесс происходит следующим образом:
Выбор элемента Revit.
Преобразование элемента Revit в кривую Dynamo.
Разделение кривой Dynamo на серию точек Dynamo.
Использование точек Dynamo между двумя кривыми для создания линий Dynamo.
Создание балок Revit на основе линий Dynamo.
Вывод поверхностей Dynamo путем запроса геометрии балок Revit.
Этот процесс может показаться довольно сложным, однако при использовании сценария достаточно отредактировать кривую в Revit и повторно запустить решатель (хотя при этом может потребоваться удалить ранее созданные балки). Это связано с тем, что при размещении балок в Python связи стандартных узлов по умолчанию разрываются.
Обновив опорные кривые в Revit, мы получим новый массив балок.
В Dynamo 2.0 появилась возможность задавать шаблон по умолчанию (.py extension)
для использования при первом открытии окна Python. Эта функция, о которой нас давно просили пользователи, значительно ускоряет процесс работы со сценариями Python в Dynamo. Благодаря возможности использовать шаблон программисты получают мгновенный доступ к данным, которые требуется импортировать по умолчанию и на основе которых они могут разрабатывать пользовательские сценарии Python.
Этот шаблон размещается в подпапке APPDATA
папки установки Dynamo.
Обычно используется следующий путь: ( %appdata%\Dynamo\Dynamo Core\{version}\ )
.
Для использования этой функции необходимо добавить в файл DynamoSettings.xml
следующую строку (правки вносятся в Блокноте).
Найдите строку <PythonTemplateFilePath />
и замените ее следующим кодом:
Примечание. Замените CURRENTUSER на имя пользователя.
Теперь нужно создать шаблон, включающий функции для встраивания. В данном случае требуется встроить функции импорта определенных данных из Revit, а также некоторые другие функции, обычно используемые при работе с Revit.
Создайте документ в Блокноте и вставьте в него следующий код:
Когда все будет готово, сохраните этот файл под именем PythonTemplate.py
в папке APPDATA
.
После того как шаблон Python задан в приложении Dynamo, каждый раз при размещении узла Python будет выполняться поиск этого шаблона. Если шаблон не найден, отображается стандартное окно Python.
Если шаблон Python найден (как в случае с созданным шаблоном для работы с Revit), отображаются встроенные в него функции по умолчанию.
Подробные сведения об этом дополнении см. в следующем материале (автор: Раду Гидей [Radu Gidei]): https://github.com/DynamoDS/Dynamo/pull/8122
В предыдущих главах было описано, как пользоваться мощными возможностями создания визуальных сценариев в Dynamo. Понимание этих возможностей является основой и первым шагом к созданию надежных визуальных программ. При работе с визуальными программами в полевых условиях, обмене ими с коллегами, устранении неполадок или проверке ограничений приходится сталкиваться и с другими проблемами. Если программа рассчитана на другого пользователя или предполагается открыть ее только через полгода, она должна обладать абсолютно понятной графикой и логикой. В Dynamo есть множество инструментов для работы со сложными программами. В этой главе приводятся рекомендации по их своевременному использованию.
По мере разработки графика Dynamo и проверки различных идей он увеличивается в размере и становится сложнее. Несомненно, очень важно создать работающую программу, однако столь же важно сделать ее максимально простой. Благодаря этому работа графика будет более быстрой и предсказуемой, а пользователи вместе с разработчиком смогут понять его логику по прошествии времени. Ниже представлены варианты того, как можно упорядочить логику графиков.
Благодаря группам можно создавать функционально автономные части при разработке программы.
Группы позволяют перемещать крупные части программы, соблюдая при этом модульность и выравнивание.
Можно менять цвета групп, чтобы различать их предназначение (входные данные или функции).
С помощью групп можно структурировать график таким образом, чтобы упростить создание пользовательских узлов.
Цвета в этой программе обозначают назначение каждой группы. Этот метод может использоваться для создания иерархии в любых разрабатываемых графических стандартах или шаблонах.
Группа функций (синий)
Группа входных данных (оранжевый)
Группа сценариев (зеленый)
Иногда с помощью блока кода можно быстрее ввести число или метод узла, чем при поиске (Point.ByCoordinates, Number, String, Formula).
Блоки кода (узлы Code Blocks) можно использовать для настройки пользовательских функций в DesignScript, уменьшающих количество узлов в графике.
Примеры 1 и 2 выполняют одну и ту же функцию. Получилось значительно быстрее написать несколько строк кода, чем прибегать к функции поиска и добавлять каждый узел по отдельности. Кроме того, блок кода значительно меньше по объему.
Сценарий DesignScript, написанный с помощью блока кода
Аналогичная программа с использованием узлов
Сложность графика можно уменьшить с помощью преобразования узла в код (Node to Code). При этом для набора простых узлов будет создан соответствующий сценарий DesignScript, состоящий из одного блока кода.
Функция «Узел для кодировки» позволяет** сжать код, не усложняя восприятие программы**.
Далее перечислены преимущества использования функции Node to Code.
Простое сжатие кода в один редактируемый компонент.
Упрощение значительной части графика.
Удобство применения к мини-программам, которые редко редактируются.
Возможность встраивания других типов блоков кода, таких как функции.
Ниже представлены недостатки использования функции Node to Code.
Типовые имена ухудшают удобочитаемость.
Сложность восприятия для других пользователей.
Нет простого способа вернуться к визуальной версии программы.
Существующая программа
Блок кода, созданный с помощью функции Node to Code
С помощью функции List@Level можно упростить график, заменив узлы List.Map и List.Combine, которые могут занимать значительное место рабочей области.
При построении логики узла List@Level работает быстрее**, чем List.Map/List.Combine**, так как предоставляет доступ к данным любого уровня в списке непосредственно с порта ввода узла.
Активировав функцию List@Level для входных данных списка CountTrue, можно проверить, сколько истинных значений и в каких списках возвращает функция BoundingBox.Contains. List@Level позволяет определить, с какого уровня данные будут подаваться на ввод. Работа с List@Level отличается гибкостью, эффективностью и более предпочтительна по сравнению с другими методами, где используются функции List.Map и List.Combine.
Подсчет истинных значений на 2 уровне списка.
Подсчет истинных значений на 3 уровне списка.
Помимо простоты и эффективности графиков, необходимо позаботится об их максимальной наглядности. Несмотря на все усилия по созданию интуитивного графика за счет логических группировок, взаимосвязи могут быть видны недостаточно хорошо. Лишних поисков и неопределенности можно избежать благодаря простому примечанию внутри группы или переименованному регулятору. Описанные ниже способы помогут обеспечить визуальное единообразие в одном или нескольких графиках.
Чтобы уменьшить количество доработок после построения графика, попытайтесь сделать компоновку узлов удобочитаемой, периодически выравнивая их.
Если с графиком будут работать другие пользователи, убедитесь, что компоновка проводов и узлов имеет четкую логику.
Для упрощения выравнивания используйте функцию «Очистить компоновку узла», чтобы автоматически выровнять график (однако в таком случае точность будет меньше, чем при выравнивании вручную).
Неупорядоченный график
Выровненный график
Переименование входных данных сделает график более понятным другим пользователям, особенно если требуется подсоединиться к узлу, который не будет виден на экране.
При переименовании любых узлов, кроме узлов входных данных, будьте максимально осторожны. Можно также создать пользовательский узел из кластера узлов и переименовать его: при этом будет понятно, что в нем содержится нечто другое.
Входные данные для управления поверхностью
Входные данные архитектурных параметров
Входные данные в сценарии моделирования водоспуска
Чтобы переименовать узел, щелкните его имя правой кнопкой мыши и выберите «Переименовать узел...».
Примечание добавляется, если для какой-либо части графика требуется пояснение на простом языке, которое не может быть выражено с помощью узла.
Примечание добавляется, если набор узлов или группа имеют слишком большой размер, сложную структуру или логику.
Примечание, описывающее часть программы, которая возвращает примерные расстояния переноса.
Примечание, описывающее код, который сопоставляет эти значения с синусоидальной волной.
При создании программы используйте марки Watch и Preview, чтобы** убедиться в правильности ключевых выходных данных**.
Узлы Watch используются для сравнения следующих данных:
примерные расстояния переноса;
значения, проходящие через уравнение синусоиды.
Весьма вероятно, что рано или поздно вашу программу откроет другой пользователь, даже если вы работаете самостоятельно. На основе входных и выходных данных этому пользователю нужно будет быстро понять, что требуется для работы программы и каковы результаты этой работы. Это особенно важно при разработке пользовательских узлов, которые будут применяться сообществом Dynamo и добавляться в программы других разработчиков. Следующие рекомендации помогут создавать надежные, многократно используемые программы и узлы.
Чтобы обеспечить удобочитаемость и масштабируемость, попробуйте минимизировать входные и выходные данные.
Перед тем, как добавить первый узел в рабочую область, необходимо определить метод построения логики, создав примерный план ее действия. При создании примерного плана отслеживайте, какие входные и выходные данные войдут в сценарии.
При наличии определенных вариантов или условий, которые требуется включить в график, для быстрого доступа к ним следует использовать наборы параметров.
Наборы параметров можно также использовать для уменьшения сложности путем кэширования определенных значений регулятора на графике с длительным временем выполнения.
Пользовательский узел применяется, если программу можно объединить в одном контейнере.
Еще пользовательский узел применяется, если часть графика будет повторно использоваться в других программах.
И, наконец, пользовательский узел применяется, если необходимо сделать функцию доступной сообществу Dynamo.
Если собрать программу преобразования точек в пользовательский узел, получится более надежная и оригинальная переносная программа, в которой легко разобраться. Правильно обозначенные порты ввода помогут другим пользователям понять, как применять узел. Не забудьте добавить описания и требуемые типы данных для каждого входного элемента.
Существующая программа точки притяжения
Пользовательский узел для размещения программы, PointGrid
Шаблоны используются в качестве визуальных стандартов, чтобы обеспечить общий подход к построению графиков среди пользователей, осуществляющих совместную работу.
При создании шаблона можно стандартизировать цвета и размеры шрифтов группы, чтобы отнести типы рабочих процессов или операции с данными к определенным категориям.
При создании шаблона можно даже стандартизировать метки, цвета или стили для обозначения различий между внешними и внутренними рабочими процессами на графике.
Пользовательский интерфейс (внешняя часть программы). Включает в себя имя проекта, регуляторы ввода и импортируемую геометрию.
Внутренняя часть программы.
Цветовые категории групп (проект в целом, входные данные, сценарии на языке Python, импортированная геометрия).
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
Ознакомившись с некоторыми практическими советами, попробуйте применить их к быстро составленной программе. Несмотря на то, что программа успешно создает крышу, график отражает «поток сознания» автора. Отсутствует какая-либо структура и руководство по использованию. Применив практические советы по организации, описанию и анализу программы, мы поможем понять другим пользователям, как ее использовать.
Программа работает, но график не структурирован.
Начните с определения данных и геометрии, возвращаемых программой.
Чтобы создать логические разделы или модули, очень важно понимать, когда данные подвергаются наибольшим изменениям. Перед переходом к следующему шагу попробуйте проверить остальную часть программы с помощью узлов Watch, чтобы убедиться в возможности определить группы.
Этот узел Code Block с математическим уравнением выглядит как ключевая часть программы. Узел Watch возвращает списки расстояний переноса.
Назначение этой области не очевидно. Расположение истинных значений на уровне списка L2 из BoundingBox.Contains и наличие List.FilterByBoolMask говорит о том, что это выборка части из сетки точек.
Разобравшись в компонентах программы, разделите их на группы.
Группы позволяют визуально дифференцировать компоненты программы.
Импорт 3D-модели площадки
Преобразование сетки точек на основе уравнения синусоиды
Выборка части из сетки точек
Создание поверхности архитектурной крыши
Создание стеклянного витража
После определения групп выровняйте узлы, чтобы обеспечить визуальную целостность графика.
Визуальная целостность позволяет видеть ход выполнения программы и скрытые взаимосвязи между узлами.
Сделайте программу более понятной, добавив еще один слой улучшений графического интерфейса. Добавьте примечания, чтобы пояснить, как работает та или иная часть программы, укажите пользовательские имена входных данных и назначьте цвета различным типам групп.
Благодаря этим улучшениям графического интерфейса пользователи лучше поймут назначение этой программы. Различные цвета групп позволяют отличать входные данные от функций.
Примечания
Входные данные с описательными именами
Перед тем как приступить к сжатию программы, определим предполагаемое место вставки сценария Python для моделирования водоспуска. Разместите выходные данные первой масштабированной поверхности крыши в соответствующих входных данных сценария.
Сценарий встраивается в эту часть программы, чтобы можно было запустить моделирование водоспуска на одной исходной поверхности крыши. Данная поверхность не отображается в области предварительного просмотра, но при этом не нужно выбирать верхнюю поверхность на сложной поверхности с фаской.
Исходная геометрия для входных данных сценария
Узел Python
Регуляторы ввода
Переключатель вкл./откл.
Упростите график, чтобы расставить все по местам.
Сжатие программы с помощью функций Node to Code и Custom Node привело к значительному уменьшению размера графика. Группы, отвечающие за создание поверхности крыши и стен, преобразованы в код, так как характерны только для данной программы. Группа преобразования точек содержится в пользовательском узле, так как ее можно использовать в другой программе. Создайте в файле примера собственный пользовательский узел из группы преобразования точек.
Пользовательский узел для размещения группы «преобразование сетки точек»
Функция Node to Code для сжатия групп «Создание поверхности архитектурной крыши и виража»
В завершение создайте наборы параметров для образцов формы крыши.
Эти входные данные в существенной мере определяют форму крыши и помогут пользователям увидеть возможности программы.
Программа, где видны два набора параметров.
Аналитический вид наборов параметров, соответствующих образцам водостока крыши.
Зачем использовать текстовое программирование в среде визуального программирования Dynamo? У много преимуществ. Оно позволяет создавать программы в интуитивно-понятном визуальном интерфейсе, не обладая навыками работы со специальным синтаксисом. Однако визуальная программа может оказаться перегруженной, а порой и недостаточно функциональной. Для сравнения, в Python реализованы гораздо более доступные способы записи условных выражений (если/то) и создания циклов. Python — это мощный инструмент, который позволяет расширить возможности Dynamo и заменить большое количество узлов компактными строками кода.
Визуальная программа
Текстовая программа
Подобно блокам кода узлы Python представляют собой интерфейс сценариев в среде визуального программирования. Узел Python находится в библиотеке в разделе Script > Editor > Python Script.
Двойной щелчок на узле приводит к открытию редактора сценариев Python (можно также щелкнуть узел правой кнопкой мыши и выбрать команду Редактировать...). Сверху находится подсказка, которая поможет обратиться к нужным библиотекам. Входные данные хранятся в массиве IN. Значения возвращаются в Dynamo путем назначения им переменной OUT.
Методы включают в себя конструкторы (например, ByCoordinates), действия (например, Add) и запросы (например, координаты X, Y и Z).
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
В этом примере мы напишем сценарий Python для создания образцов на основе твердотельного модуля и преобразуем этот сценарий в пользовательский узел. Сначала создадим твердотельный модуль с помощью узлов Dynamo.
Rectangle.ByWidthLength. Создайте прямоугольник, который будет служить основой твердого тела.
Surface.ByPatch. Соедините прямоугольник с входным параметром closedCurve для создания нижней поверхности.
Geometry.Translate. Соедините прямоугольник с входным параметром geometry для его перемещения вверх, используя блок кода для указания толщины основания тела.
Polygon.Points. Запросите извлечение угловых точек из преобразованного прямоугольника.
Geometry.Translate. Используйте блок кода для создания списка из четырех значений, соответствующих четырем точкам, перемещающим один угол тела вверх.
Polygon.ByPoints. С помощью преобразованных точек воссоздайте верхний полигон.
Surface.ByPatch. Присоедините полигон для создания верхней поверхности.
Теперь, имея в распоряжении верхнюю и нижнюю поверхности, выполним лофтинг между двумя профилями, чтобы создать стороны тела.
List.Create. Соедините нижний прямоугольник и верхний полигон с входными параметрами индекса.
Surface.ByLoft. Выполните лофтинг двух профилей для создания сторон тела.
List.Create. Соедините верхнюю, боковую и нижнюю поверхности с входными параметрами индекса для создания списка поверхностей.
Solid.ByJoinedSurfaces. Соедините поверхности для создания твердотельного модуля.
Теперь, получив твердое тело, перетащите в рабочее пространство узел сценария Python.
Чтобы добавить дополнительные входные параметры к узлу, закройте редактор и щелкните значок «+» на узле. Входным параметрам присваиваются имена IN[0], IN[1] и т. д. Это говорит о том, что они представляют элементы в списке.
Начнем с определения входных и выходных параметров. Дважды щелкните узел, чтобы открыть редактор Python. Используйте приведенный ниже код, чтобы изменить код в редакторе.
Смысл этого кода будет понятен позже по мере выполнения упражнения. Далее необходимо подумать о том, какая информация необходима для создания массива на основе имеющегося твердотельного модуля. Во-первых, необходимо знать размеры тела, чтобы определить расстояние переноса. Из-за ошибки, связанной с ограничивающей рамкой, для ее создания необходимо использовать геометрию кривой кромки.
Посмотрите, как выглядит узел Python в Dynamo. Обратите внимание, что используется тот же синтаксис, что и в заголовках узлов Dynamo. Ознакомьтесь с кодом, приведенным ниже.
Поскольку твердотельные модули будут не только преобразовываться, но и поворачиваться, воспользуемся операцией Geometry.Transform. Если посмотреть на узел Geometry.Transform, становится понятно, что для преобразования тела потребуется исходная система координат и целевая система координат. В качестве первой выступает контекстная система координат тела, а в качестве второй — система координат, которая различна для каждого модуля массива. Таким образом, чтобы система координат каждый раз преобразовывалась по-разному, необходимо перебирать значения координат по осям X и Y.
Нажмите кнопку «Выполнить», а затем сохраните код. Соедините узел Python с существующим сценарием следующим образом.
Соедините выходные данные узла Python с узлом Solid.ByJoinedSurfaces в качестве первого порта ввода и используйте узел Code Block для определения других входных данных.
Создайте узел Topology.Edges и используйте в качестве входных данных выходные данные узла Python.
Наконец, создайте узел Edge.CurveGeometry и в качестве входных данных используйте выходные данные Topology.Edges.
Попробуйте изменить начальное значение для создания различных образцов. Кроме того, можно изменять параметры самого твердотельного модуля для получения различных эффектов.
Создав нужный сценарий Python, сохраним его как пользовательский узел. Выберите узел сценария Python, щелкните правой кнопкой мыши рабочее пространство и выберите «Создание пользовательского узла».
Присвойте имя, добавьте описание и категорию.
При этом откроется новое рабочее пространство для редактирования пользовательского узла.
Inputs. Измените имена входных параметров, сделав их более описательными, и добавьте типы данных и значения по умолчанию.
Output: измените имя узла Output.
Сохраните узел в виде файла DYF. В пользовательском узле отобразятся внесенные изменения.
Создание сценариев на основе текста в среде разработки визуальных сценариев обеспечивает возможность построения эффективных наглядных взаимосвязей с использованием языков DesignScript, Python и ZeroTouch (C#). В DesignScript можно отображать такие элементы, как регуляторы ввода, и сжимать сложные операции. В том же рабочем пространстве с помощью Python или C# можно получить доступ к мощным инструментам и библиотекам. При грамотном использовании сочетание этих методов может обеспечить высокую степень адаптированности, ясности и эффективности всей программы. Ниже приводится набор рекомендаций по дополнению визуальных сценариев текстовыми.
Текстовые сценарии позволяют устанавливать более сложные взаимосвязи, чем визуальное программирование, хотя их возможности во многом пересекаются. Это следует учитывать, так как узлы представляют собой эффективные пакеты кода, что позволяет написать целую программу для Dynamo в DesignScript или Python. Однако визуальные сценарии используются по причине того, что интерфейс, состоящий из узлов и проводов, позволяет создать интуитивно понятный поток графической информации. Информация о том, в каких случаях возможности текстовых сценариев превосходят возможности визуальных сценариев, — ключ к их использованию без отказа от работы с интуитивно понятными узлами и проводами. Ниже приводятся рекомендации в отношении того, когда следует использовать сценарии, и какой при этом выбрать язык программирования.
Текстовые сценарии используются в следующих случаях:
организация циклов;
использование рекурсии;
доступ к внешним библиотекам.
Выбор языка
При написании сценариев в Dynamo — параметрической среде — имеет смысл структурировать код с учетом системы узлов и проводов, в которой он будет размещен. Рассматривайте узел, содержащий текстовый сценарий, как любой другой узел в программе с некоторыми определенными входными данными, функцией и ожидаемыми выходными данными. При этом код внутри узла получает небольшой набор переменных, на основе которых можно строить работу, а это — ключ к безупречной параметрической системе. Далее приводятся некоторые рекомендации, позволяющие успешнее встроить код в визуальную программу.
Определите внешние переменные.
Попробуйте определить заданные параметры в проектной задаче, чтобы можно было построить модель непосредственно на этих данных.
Перед написанием кода необходимо указать следующие переменные:
минимальный набор входных данных;
ожидаемые выходные данные;
константы.
Перед написанием кода было определено несколько переменных.
Поверхность, на которую будет моделироваться выпадение осадков.
Желаемое количество капель дождя (агентов).
Расстояние перемещения капель дождя.
Переключение между режимом спуска по траектории с наибольшей крутизной и режимом пересечения поверхности.
Узел Python с соответствующим количеством входных данных.
Блок кода для окрашивания возвращаемых кривых синим цветом.
Проектирование внутренних взаимосвязей
Параметрическая архитектура позволяет редактировать определенные параметры или переменные для настройки или изменения конечного результата уравнения или работы системы.
Если объекты в сценарии логически связаны между собой, следует указать, что один является функцией другого и наоборот. Таким образом, при изменении одного объекта другой также будет обновлен.
Сократите количество входных данных, оставив только ключевые параметры.
Если набор параметров может быть сформирован из дополнительных родительских параметров, в качестве входных данных сценария оставьте только эти родительские параметры. Это повышает удобство работы со сценарием за счет некоторого упрощения его интерфейса.
Входные данные.
Внутренние переменные сценария.
Цикл, для выполнения функции которого используются эти входные данные и переменные.
Совет. Уделите столько же внимания процессу, сколько и самому решению.
Если один и тот же фрагмент в сценарии выражается несколькими способами, рано или поздно произойдет рассинхронизация этих совпадений, что потребует значительных исправлений, приведет к ошибкам в расчетах и внутренним противоречиям.
Принцип DRY звучит следующим образом: «Информация, вводимая в компьютер должна быть конкретной и однозначной».
При успешном применении этого принципа все взаимосвязанные элементы в сценарии будут изменяться предсказуемо и единообразно, а все несвязанные элементы не будут иметь логических последствий друг для друга.
Совет. Перед дублированием объектов в сценарии (например, константы в примере выше) подумайте, можно ли вместо этого установить связь с источником.
По мере расширения и усложнения кода основная идея (ключевой алгоритм) становится все менее и менее читаемой. При этом все сложнее отслеживать, что и где может произойти, выявлять ошибки при возникновении проблем, встраивать другой код и назначать задачи по разработке. Чтобы избежать этих сложностей, для написания кода рекомендуется использовать модули. При этой организационной методике код разбивается на части в зависимости от выполняемой задачи. Далее представлены некоторые советы по расширению возможностей управления сценариями благодаря модульности.
Записывайте код в виде модулей.
«Модуль» — это группа данных кода, выполняющая определенную задачу (аналогично узлу Dynamo в рабочем пространстве).
Это может быть любой объект, который визуально отделен от близлежащего кода (функция, класс, группа входных данных или импортируемые библиотеки).
Разработка кода в форме модулей повышает визуальное и интуитивное качество узлов, позволяя строить сложные взаимосвязи, реализуемые только с помощью текстовых сценариев.
Эти циклы вызывают класс с именем agent (агент), который мы будем разрабатывать в упражнении.
Модуль кода, определяющий начальную точку каждого агента.
Модуль кода, обновляющий агента.
Модуль кода, который строит маршрут траектории агента.
Ищите повторяющийся код.
Если выясняется, что код выполняет одно и то же (или почти одно и то же) действие в нескольких местах, рекомендуется кластеризовать его в функцию, доступную для вызова.
Функции Manager управляют ходом выполнения программы и содержат вызовы функций Worker для обработки низкоуровневых задач, например для перемещения данных между конструкциями.
В этом примере создаются сферы с радиусами и цветом, зависящими от значения Z центров.
Имеются две родительские функции Worker: одна из них создает сферы с радиусами и отображает цвета в зависимости от значения Z центра.
В родительской функции Manager объединены две функции Worker. При ее вызове вызываются и обе находящиеся в ней функции.
Отображайте только нужные элементы.
В интерфейсе модуля отображаются элементы, как предоставляемые самим модулем, так и необходимые ему.
После того как интерфейсы между блоками определены, детальная разработка каждого блока может выполняться отдельно.
Разделимость и заменяемость.
Модули никоим образом не зависимы друг от друга.
Основные формы модульной организации.
Группировка кодов
Функции
Классы
При написании текстовых сценариев в Dynamo важно всегда быть уверенным, что создаваемое соответствует ожидаемому. Это позволит быстро обнаружить непредвиденные события, такие как синтаксические ошибки, логические несоответствия, неточности значений, аномальные выходные данные и т. д., и устранить их по мере появления, а не сразу. Так как текстовые сценарии размещаются в узлах рабочей области, они автоматически встроены в поток данных визуальной программы. Благодаря этому последующий мониторинг сценария ограничивается лишь назначением данных для вывода, запуском программы и оценкой результатов, выводимых из сценария с помощью узла наблюдения (Watch). Ниже приводятся советы по непрерывной проверке сценариев в процессе их создания.
Проверка во время работы.
Каждый раз по завершении работы над группой функций рекомендуется выполнять следующие действия.
Сделайте паузу и уделите время проверке кода.
Проявляйте критичность. Ваши коллеги смогут понять, для чего он предназначен? Эта функция действительно необходима? Можно ли повысить ее эффективность? Не создаю ли я лишних копий или зависимостей?
Проведите экспресс-проверку данных на целесообразность.
В качестве выходных данных назначайте наиболее актуальную информацию, обрабатываемую в сценарии, чтобы при обновлении сценария узел всегда выводил релевантные данные.
Убедитесь, что все кромки тела возвращаются в виде кривых, в результате чего вокруг него создается ограничивающая рамка.
Проверьте, чтобы входные данные количества успешно преобразовывались в диапазоны.
Убедитесь, что системы координат в данном цикле правильно преобразованы и повернуты.
Учитывайте пограничные случаи.
При написании сценариев присвойте входным параметрам минимальные и максимальные значения в отведенной им области, чтобы проверить, будет ли программа функционировать при экстремальных условиях.
Даже если программа работает с предельными установками, проверьте, не возвращает ли она нежелательные нулевые или пустые значения.
Иногда неисправности и ошибки, позволяющие обнаружить скрытую проблему в сценарии, проявляются только в таких пограничных случаях.
Определите, что вызывает ошибку, а затем решите, следует ли исправить ее изнутри или перенастроить всю область параметров, чтобы избежать проблемы.
Совет. Всегда исходите из того, что пользователь может выбрать любую комбинацию с любым доступным входным значением. Это поможет избежать неприятных сюрпризов.
Отладкой называется процесс устранения ошибок в сценарии. Под ошибками подразумеваются неполадки, недоработки, неточности и любые нежелательные результаты. Иногда чтобы исправить ошибку, достаточно скорректировать неправильно написанное имя переменной. В других случаях речь может идти о более глобальной проблеме, связанной со структурой сценария. В идеале зондирование сценария в процессе его создания поможет сразу выявить потенциальные проблемы, хотя это и не гарантирует полное отсутствие ошибок. Ниже приведены некоторые практические советы, которые помогут устранять ошибки систематически.
Используйте марки наблюдения.
Проверяйте данные, возвращаемые в различных местах кода, назначая их переменной OUT (аналогично методу зондирования программы).
Оставляйте подробные комментарии.
Модуль кода будет намного проще отладить, если предполагаемый результат его работы будет точно описан.
Обычно это приводит к увеличению количества информации и пустых строк, но при отладке позволяет анализировать данные, разбив их на отдельные части.
Используйте модульный принцип организации кода.
Источник проблемы можно свести к определенным модулям.
После того как проблемный модуль определен, исправить проблему будет значительно проще.
Если необходимо изменить программу, код, который был разработан в отдельных модулях, будет намного проще скорректировать.
В существующую программу можно вставить новый или отлаженный модуль с уверенностью в том, что остальная часть программы не изменится.
Входная геометрия возвращает ограничивающую рамку слишком большого размера. Это можно видеть, назначив переменной OUT значения xDist и yDist.
Кривые ребра входной геометрии имеют подходящую ограничивающую рамку и правильные расстояния xDist и yDist.
Вставлен модуль кода, позволяющий решить проблему со значениями xDist и yDist.
Скачайте файл примера, щелкнув указанную ниже ссылку.
Полный список файлов примеров можно найти в приложении.
Напишем сценарий для моделирования дождевых осадков с учетом представленных здесь практических советов по созданию текстовых сценариев. Несмотря на то, что практические советы были успешно применены к плохо организованной визуальной программе в разделе «Методы создания графиков», данные операции значительно сложнее выполнять с текстовыми сценариями. Логические связи, существующие в текстовых сценариях, сложнее отслеживаются и почти не распознаются в запутанном коде. Вместе с возможностями, которые дают текстовые сценарии, повышаются и требования к организации кода. Рассмотрим каждый из этапов, применяя на деле практические советы.
Наш сценарий применялся к поверхности, деформированной точкой притяжения.
Сначала следует импортировать необходимые библиотеки Dynamo. Сделав это в первую очередь, мы предоставим глобальный доступ к функциональным возможностям Dynamo в Python.
Сюда необходимо импортировать все библиотеки, которые планируется использовать.
Затем следует определить входные и выходные данные сценария, которые будут отображаться в качестве входных портов узла. Эти внешние входные данные являются основой сценария и ключом к созданию параметрической среды.
Необходимо определить входные данные, соответствующие переменным в сценарии Python, и определить желаемый результат.
Поверхность, по которой будут спускаться агенты.
Количество движущихся агентов.
Максимальное количество шагов, которые могут сделать агенты.
Возможность использования кратчайшего пути вниз по поверхности или ее пересечения.
Узел Python с идентификаторами ввода, соответствующими входным данным в сценарии (IN[0], IN[1]).
Выходные кривые, которые могут отображаться другим цветом.
Теперь воспользуемся принципом модульной организации и создадим основную часть сценария. Важной задачей является моделирование кратчайшей траектории вниз по поверхности для нескольких начальных точек. Для этого требуется использование нескольких функций. Вместо того чтобы вызывать различные функции в сценарии, можно создать модули кода, собрав функции в одном классе (агенте). Различные функции этого класса (или модуля) можно вызывать с помощью различных переменных или даже использовать в других сценариях.
Для агента необходимо определить класс (макет), который позволит спускаться по поверхности, выбирая перемещения в направлении с наибольшей крутизной при каждом шаге.
Имя.
Глобальные атрибуты, общие для всех агентов.
Атрибуты экземпляра, уникальные для каждого агента.
Функция для выполнения шага.
Функция каталогизации положения каждого шага в списке маршрутов.
Теперь инициализируйте агентов, определив их начальное положение. Это хорошая возможность для зондирования сценария с целью проверки работоспособности класса агентов.
Необходимо создать экземпляры всех агентов, спуск которых по поверхности будет отслеживаться, и определить их исходные атрибуты.
Новый пустой список маршрутов.
Место начала движения по поверхности.
Мы назначили список агентов в качестве выходных данных, чтобы проверить результат, возвращаемый сценарием. Возвращается правильное количество агентов, но позднее потребуется снова выполнить зондирование сценария для проверки полученной с помощью него геометрии.
Обновляйте агентов при каждом шаге. Затем необходимо вставить вложенный цикл, где положение каждого агента и шага будет обновляться и записываться в списке маршрутов. Кроме того, при выполнении каждого шага нужно проверять, не достиг ли агент точки на поверхности, где невозможно выполнить следующий шаг с направлением вниз. Если это условие выполняется, движение агента прекращается.
Теперь, когда все агенты полностью обновлены, получим соответствующую им геометрию. После того как все агенты достигнут предельного значения спуска или максимального количества шагов, следует создать сложную кривую (PolyCurve), проходящую через точки в списке их маршрутов, и вывести маршруты сложной кривой.
Сценарий для поиска траекторий с наибольшей крутизной.
Набор параметров для моделирования осадков на базовой поверхности.
Вместо поиска траектории с наибольшей крутизной можно переключить агентов на пересечение базовой поверхности.
Полный текстовый сценарий Python.
Данный справочник представляет собой дополнение к практическим советам, рассмотренным в главе «Методы создания сценариев». В нем содержатся дополнительные сведения о библиотеках кодов, метках и стиле. Для иллюстрации будет использоваться язык Python, однако принципы являются общими для Python и C# (Zero Touch) с учетом различий в синтаксисе.
Стандартные библиотеки не входят в состав Dynamo и написаны на языках программирования Python и C# (Zero Touch). В Dynamo также имеется собственный набор библиотек, которые точно отражают иерархию узлов модуля. Благодаря этому пользователи могут создавать программы с помощью узлов и проводов в форме кода. В представленном ниже руководстве описано содержимое каждой из библиотек Dynamo и случаи использования стандартных библиотек.
Стандартные библиотеки и библиотеки Dynamo
Для формирования данных и процессов со сложной структурой в среде Dynamo можно использовать стандартные библиотеки Python и C#.
Библиотеки Dynamo в точности следуют иерархии узлов, что удобно при создании геометрических и других объектов Dynamo.
Библиотеки Dynamo
ProtoGeometry\*
Функции: дуга, ограничивающая рамка, окружность, конус, система координат, кубоид, кривая, цилиндр, ребро, эллипс, дуга эллипса, грань, геометрия, спираль, группа индексов, линия, сеть, NURBS-кривая, NURBS-поверхность, плоскость, точка, полигон, прямоугольник, тело, сфера, поверхность, топология, T-сплайн, UV, вектор, вершина.
Импорт: import Autodesk.DesignScript.Geometry
``
DSCoreNodes
Функции: цвет, диапазон цветов 2D, дата и время, интервал времени, ввод/вывод, формула, логика, список, математическое вычисление, квадрадерево, строка, поток.
Импорт: import DSCore
Tessellation
Функции: выпуклая оболочка, Делоне, Вороной.
Импорт: import Tessellation
DSOffice
Функции: Excel.
Импорт: import DSOffice
\* Примечание. При работе с библиотекой ProtoGeometry в Python или C# создаются неуправляемые объекты, память которых можно освободить только вручную. Дополнительные сведения см. в разделе Неуправляемые объекты ниже.
При написании сценариев постоянно используются идентификаторы, которые служат для обозначения переменных, типов, функций и других элементов. Благодаря этой системе условных обозначений можно строить алгоритмы, ссылаясь на данные посредством меток, которые обычно представляют собой последовательность символов. Правильное присвоение имен очень важно при написании кода, так как позволяет сделать его понятным не только другим пользователям, но и самому автору в будущем. Ниже приводятся рекомендации по присвоению имен элементам сценария.
Использование сокращений допускается, но с поясняющим комментарием:
Избегайте избыточных меток:
В именах переменных используйте положительную, а не отрицательную логику:
Старайтесь использовать обратный порядок слов в обозначениях:
Это более целесообразно с точки зрения структуры.
Для сокращения длинных или часто повторяющихся цепочек наименований используйте псевдонимы:
Однако помните, что использование псевдонимов может сделать программу непонятной и нестандартной.
Используйте только необходимые слова:
«Все должно быть изложено так просто, как только возможно, но не проще» (Альберт Эйнштейн)
Любую программу можно написать несколькими способами, то есть персональный стиль создания сценариев формируется в результате принятия (или непринятия) бесчисленных мелких решений по ходу работы. Это означает, что читаемость и возможность доработки кода — прямой результат внутренней согласованности и соблюдения общих стилистических правил. Главное правило: одинаковый код в двух разных местах должен работать одинаково. Ниже приводятся советы по созданию понятного единообразного кода.
Правила именования (выберите одно из следующих правил для каждого типа объекта в коде и придерживайтесь его)
Переменные, функции, методы, пакеты, модули:
lower_case_with_underscores
Классы и исключения:
CapWords
Защищенные методы и внутренние функции:
_single_leading_underscore(self, ...)
Собственные методы:
__double_leading_underscore(self, ...)
Константы:
ALL_CAPS_WITH_UNDERSCORES
Совет. Следует избегать использования переменных из одной буквы (особенно l, O, I), Исключением могут быть очень короткие блоки, когда значение легко понять из ближайшего контекста.
Использование пустых строк
До и после определения функции верхнего уровня или класса следует оставлять две пустые строки.
До и после определения метода внутри класса следует оставлять одну пустую строку.
Для разделения групп связанных функций можно использовать дополнительные пустые строки (в разумных количествах).
Избегайте ненужных пробелов
После открывающейся или перед закрывающейся круглой скобкой, квадратной скобкой или фигурной скобкой:
Перед запятой, точкой с запятой или двоеточием:
Перед открывающейся скобкой, за которой следует список аргументов вызываемой функции:
Перед открывающейся скобкой, за которой следует индексирование или членение:
До и после следующих двоичных операторов всегда вставляйте одиночный пробел:
Следите за длиной строки
Она не должна превышать 79 символов.
Если ограничить ширину окна редактора, можно открыть несколько файлов рядом. Это также удобно при использовании инструментов проверки кода, когда обе версии кода представлены в соседних столбцах.
Длинные строки можно разбить на несколько строк, заключив выражения в круглые скобки:
Избегайте очевидных и лишних комментариев
Иногда меньшее количество комментариев делает код более читабельным, особенно если вместо них используются понятные идентификаторы.
Хороший стиль написания кода уменьшает зависимость от комментариев:
Совет. Комментарии отвечают на вопрос «Почему?», код — на вопрос «Как?».
Просматривайте открытый исходный код
Проекты с открытым исходным кодом создаются совместными усилиями многих разработчиков. Код, на котором пишутся эти проекты, должен быть максимально понятным, чтобы обеспечить эффективную работу всей группы. Поэтому рекомендуется просматривать исходный код подобных проектов, чтобы понять ход мыслей разработчиков.
Совершенствуйте правила:
Задавайте вопросы о том, срабатывает ли то или иное правило в отношении текущих задач.
Не ухудшается ли функциональность или эффективность?
Посетите эти страницы Wiki, чтобы узнать об особенностях написания кода на C# для Zero Touch и его вставки в Dynamo.
Неуправляемые объекты
Удалять следует только неуправляемые ресурсы, которые не возвращаются в график или на которые не указывают ссылки. Далее в этом разделе подобные объекты будут называться промежуточной геометрией. Этот класс объектов используется в примере кода, приведенном ниже. Функция C# Zero Touch c именем singleCube возвращает один куб, но в процессе выполнения создает еще 10000 кубов. Предположим, что оставшиеся геометрические объекты были использованы в качестве некой промежуточной вспомогательной геометрии.
Скорее всего, эта функция вызовет аварийное завершение работы Dynamo. В результате ее использования было создано 10000 тел, а сохранено и возвращено одно из них. В этом случае необходимо удалить все промежуточные кубы, кроме возвращаемого. Возвращаемый объект удалять не нужно, так как он будет распространен по графику и использован в других узлах.
Постоянный код должен выглядеть примерно так:
Обычно необходимо удалить только геометрию, например Surfaces
, Curves
и Solids
. Однако в целях безопасности можно удалить все типы геометрии (Vectors
, Points
, CoordinateSystems
).
В основе проекта Dynamo лежит план по расширению масштабов внедрения платформ. По мере добавления в Dynamo поддержки новых программ пользователи получают доступ к API-интерфейсам для конкретных платформ из среды создания сценариев Python. Данный раздел посвящен работе с Revit, однако в будущем можно ожидать появления новых разделов, содержащих учебные пособия по созданию сценариев для других платформ. Кроме того, в данный момент доступно множество библиотек , которые можно импортировать в Dynamo.
В приведенных ниже примерах иллюстрируются способы выполнения операций Revit из модуля Dynamo с использованием языка программирования Python. Дополнительные сведения об особенностях использования Python в Dynamo и Revit см. на . Еще один полезный ресурс по Python и Revit — проект .
Сведения об использовании групп см. в разделе .
Сведения о работе с элементами Code Block см. в разделе .
Сведения о работе с функцией Node to Code см. в разделе .
Сведения о работе с функцией List@Level см. в разделе .
Сведения об использовании функции выравнивания узлов см. в разделе .
Сведения о том, как добавить примечание, см. в разделе .
При создании визуального сценария важно убедиться в том, что возвращаемые результаты соответствуют ожидаемым. Не все ошибки или проблемы ведут к немедленному сбою в работе программы. Особенно это касается нулевых значений, которые могут повлиять на работу значительно позже. Этот метод также применяется к текстовым сценариям. См. раздел . Следующие рекомендации помогут получить ожидаемые результаты.
Сведения о работе с узлом Watch см. в разделе .
Сведения о работе с набором параметров см. в разделе .
Сведения о работе с пользовательскими узлами см. в разделе .
Библиотека Autodesk.DesignScript.Geometry позволяет использовать точечные обозначения, аналогичные блокам кода (узлам Code Block). Дополнительные сведения о синтаксисе Dynamo см. в файле , а также в (чтобы скачать этот файл PDF, щелкните правой кнопкой мыши ссылку и выберите «Сохранить как»). При вводе определенного типа геометрии (например Point), отображается список методов, доступных для создания и запроса точек.
Список ресурсов, доступных в библиотеках Dynamo, см. в .
«Модули» кода из примера в .
Отладка файла примера из .
На этой странице рассматриваются некоторые общие стандарты, касающиеся документирования и проверки кода:
На этой странице рассматриваются стандарты именования для библиотек, категорий, имен узлов, имен портов и сокращений:
При использовании библиотеки геометрических объектов Dynamo (ProtoGeometry) в Python или C# управлять геометрическими объектами с помощью виртуальной машины будет невозможно, и память многих из этих объектов необходимо освобождать вручную. Для удаления локальных или неуправляемых объектов можно использовать метод Dispose или ключевое слово using. Дополнительные сведения см. на следующей странице Wiki: .
Циклы
Рекурсия
Сжатие узлов
Внешн. библиотеки
Сокращение
DesignScript
Да
Да
Да
Нет
Да
Python
Да
Да
Частично
Да
Нет
ZeroTouch (C#)
Нет
Нет
Нет
Да
Нет
Процесс визуального программирования может быть очень увлекательным и вдохновляющим, однако работа с потоком выполнения операций и ключевыми входными данными пользователя может очень быстро зайти в тупик из-за запутанности программы или неудачной компоновки рабочего пространства. Далее представлены некоторые практические советы по управлению структурой программы.
Когда рабочее пространство постепенно начнет заполняться узлами, может потребоваться переупорядочить их для большей наглядности. Выберите несколько узлов и щелкните в рабочем пространстве правой кнопкой мыши. Появится всплывающее окно с меню Выбор выравнивания, содержащем параметры выравнивания и распределения по осям X и Y.
Выберите несколько узлов.
Щелкните в рабочем пространстве правой кнопкой мыши.
Воспользуйтесь параметрами меню Выбор выравнивания.
По мере накопления опыта вы научитесь «считывать» содержимое визуальной программы, просматривая имена узлов и следуя последовательности выполнения операций. Чтобы дополнительно упростить работу как опытным пользователям, так и новичкам, мы рекомендуем добавлять простые текстовые метки и описания. Для этого в Dynamo можно использовать узел Notes с редактируемым текстовым полем. Добавить примечания в рабочее пространство можно двумя способами.
Перейдите в меню «Редактировать» > «Создать примечание».
Используйте клавиши быстрого вызова CTRL + W.
После добавления примечания в рабочее пространство появится текстовое поле, позволяющее отредактировать текст примечания. Созданные примечания можно изменить, щелкнув узел примечаний правой кнопкой мыши или щелкнув его дважды.
Когда число компонентов визуальной программы становится по-настоящему большим, для упрощения работы с ними рекомендуется выделить крупные этапы процесса выполнения. Большие наборы узлов можно объединять в группы, в результате чего они помечаются цветным фоновым прямоугольником и заголовком. Создать группу на основе нескольких выбранных узлов можно тремя способами.
Перейдите в меню «Редактировать» > «Создать группу».
Используйте клавиши быстрого вызова CTRL + G.
Щелкните в рабочем пространстве правой кнопкой мыши и выберите «Создать группу».
После создания группы можно отредактировать ее параметры, например название и цвет фона.
Совет. Использование примечаний и групп является эффективным способом аннотирования файла и повышения его читабельности.
Далее представлен пример программы с добавленными примечаниями и группами.
Примечание: «Параметры сетки»
Примечание: «Точки сетки»
Группа: «Создать сетку из точек»
Группа: «Создать точку аттрактора»
Примечание: «Откалибровать значения расстояния»
Примечание: «Переменная сетка окружностей»
Dynamo Mesh Toolkit содержит инструменты для импорта сетей из внешних файлов других форматов, создания сетей из геометрических объектов Dynamo и построения сетей вручную по вершинам и индексам. В библиотеке также содержатся инструменты для редактирования и восстановления сетей, а также для извлечения горизонтальных срезов, используемых в ходе изготовления изделий.
Пакет Dynamo Mesh Toolkit — это результат непрерывной работы специалистов Autodesk, направленной на исследование сетей. В ближайшие годы функциональные возможности пакета будут постоянно улучшаться и пополняться. Разработчики Dynamo с нетерпением ждут ваших отзывов и предложений по новым функциям, а также сообщений об обнаруженных ошибках.
В упражнении ниже демонстрируются некоторые базовые операции с сетями, выполняемые с помощью Mesh Toolkit. В этом упражнении сеть рассекается на несколько частей при помощи плоскостей, что при использовании тел потребовало бы больших вычислительных мощностей. Сеть, в отличие от тела, имеет заданное «разрешение». Кроме того, она определяется не математически, а топологически. Благодаря этому определение сети можно адаптировать в соответствии с поставленной задачей. Дополнительные сведения о взаимосвязях сетей и тел см. в разделе Геометрия для автоматизированного проектирования данного руководства. Подробный обзор пакета Mesh Toolkit см. на странице справки Wiki по Dynamo. Выполните следующее упражнение, чтобы узнать, как использовать этот пакет на практике.
В Dynamo в верхней строке меню выберите «Пакеты» > «Package Manager». В поле поиска введите MeshToolkit одним словом (без пробелов). Нажмите кнопку «Установить» и подтвердите действие, чтобы начать скачивание. Проще простого.
Скачайте файл с примером, щелкнув ссылку ниже.
Полный список файлов с примерами можно найти в приложении.
В этом примере рассматривается работа с узлом Intersect в составе MeshToolkit. Вам потребуется импортировать сеть, а затем рассечь ее с использованием нескольких входных плоскостей для получения срезов. Это первый этап подготовки модели изделия к изготовлению с помощью лазерной или водоструйной резки либо фрезерного станка с ЧПУ.
Для начала откройте в Dynamo файл Mesh-Toolkit_Intersect-Mesh.dyn.
File Path: найдите файл сети для импорта (stanford_bunny_tri.obj). Поддерживаются файлы MIX и OBJ.
Mesh.ImportFile: соедините этот узел с узлом File Path, чтобы импортировать сеть.
Point.ByCoordinates: создайте точку, которая станет центром дуги.
Arc.ByCenterPointRadiusAngle: создайте дугу на основе заданной точки. Эта кривая будет использоваться для размещения серии плоскостей. __ Параметры: __
radius: 40, startAngle: -90, endAngle:0
Создайте серию плоскостей, ориентированных вдоль дуги.
Code Block: создайте 25 чисел в диапазоне от 0 до 1.
Curve.PointAtParameter: соедините порт вывода Arc с портом ввода curve, а порт вывода Code Block — с портом ввода param, чтобы получить набор точек вдоль кривой.
Curve.TangentAtParameter: соедините порты этого узла аналогично портам предыдущего.
Plane.ByOriginNormal: соедините порт вывода Point с портом ввода origin, а порт вывода Vector — с портом ввода normal, чтобы создать набор плоскостей на основе полученных точек.
Рассеките сеть с помощью этих плоскостей.
Mesh.Intersect: плоскости рассекают импортированную сеть, в результате чего создается набор контуров, состоящих из сложных кривых. Щелкните правой кнопкой мыши узел и задайте для переплетения значение «Самый длинный».
PolyCurve.Curves: сложные кривые разбиваются на свои фрагменты кривых.
Curve.EndPoint: извлеките значения конечных точек для каждой кривой.
NurbsCurve.ByPoints: постройте NURBS-кривую на основе полученных точек. Добавьте узел Boolean и установите для него значение True, чтобы замкнуть кривые.
Теперь отключите предварительный просмотр для некоторых узлов, таких как Mesh.ImportFile, Curve.EndPoint, Plane.ByOriginNormal и Arc.ByCenterPointRadiusAngle, чтобы лучше рассмотреть результат.
Surface.ByPatch: создайте участки поверхности для каждого контура, чтобы сформировать срезы сети.
Добавьте второй набор срезов для получения «вафельного» эффекта.
Как вы могли заметить, операции пересечения при работе с сетями выполняются гораздо быстрее, чем при работе с аналогичным телом. Использование сетей позволяет ускорить многие рабочие процессы, подобные представленному в этом упражнении.