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

• Узлы Code Block и DesignScript

• Создание геометрии с помощью DesignScript

• Python

Узлы Code Block позволяют вставлять в график функции, к которым смогут обращаться другие компоненты программы Dynamo. При этом в параметрическом файле создается еще один слой управления, который можно рассматривать как текстовую версию пользовательского узла. При этом «родительский» узел Code Block легко доступен и может находиться в любом месте графика. И никаких проводов!

Родительский узел Code Block

Первая строка содержит ключевое слово «def», затем название функции и наименования входных данных в скобках. Тело функции заключено в фигурные скобки. Значение возвращается с помощью оператора «return =». В узлах Code Block, определяющих функцию, отсутствуют порты ввода и вывода, так как они вызываются из других блоков кода.

/*This is a multi-line comment,
which continues for
multiple lines*/
def FunctionName(in1,in2)
{
//This is a comment
sum = in1+in2;
return sum;
};

Дочерние узлы Code Block

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

FunctionName(in1,in2);

Упражнение «Сфера по оси Z»

Скачайте файл примера, щелкнув указанную ниже ссылку.

Полный список файлов примеров можно найти в приложении.

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

Для начала зададим десять числовых значений в диапазоне от 0 до 100. Соединим этот узел с узлом Point.ByCoordinates для создания диагональной линии.

Создайте узел Code Block и введите определение.

1. Используйте следующие строки кода:

   Copy

   def sphereByZ(inputPt)
   {
   
   };

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

1. Дополните функцию Code Block, разместив комментарий и переменную sphereRadius, которая запрашивает положение каждой точки по оси Z. Напомним, что метод inputPt.Z не нужно заключать в скобки. Это запрос свойств существующего элемента, поэтому указывать входные данные не требуется.

Copy

def sphereByZ(inputPt,radiusRatio)
{
//get Z Value, ise ot to drive radius of sphere
sphereRadius=inputPt.Z;
};

1. Вызовите функцию, созданную в другом узле Code Block. Если дважды щелкнуть в активном окне для создания нового узла Code Block и ввести sphereB, то вы увидите, что Dynamo предложит использовать созданную выше функцию sphereByZ. Функция была добавлена в библиотеку IntelliSense! Неплохо.

1. Теперь вызовем функцию и создадим переменную Pt, чтобы использовать созданные ранее точки.

   Copy

   sphereByZ(Pt)

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

1. Это важный шаг: необходимо задать выходные данные функции, добавив строку return = sphereRadius; в функцию sphereByZ.

2. Теперь Code Block выводит координаты Z каждой точки.

Создадим сферы, отредактировав родительскую функцию.

1. Сначала определите сферу с помощью строки кода: sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);.

2. Теперь измените возвращаемое значение на sphere вместо sphereRadius: return = sphere;. В области предварительного просмотра Dynamo появятся гигантские сферы.

1. Чтобы уменьшить размер этих сфер, обновите значение sphereRadius, добавив разделитель: sphereRadius = inputPt.Z/20;. Теперь видно отдельные сферы, что позволяет понять взаимосвязь между радиусом и значением Z.

1. В узле Point.ByCoordinates измените режим переплетения с «Самый короткий список» на «Векторное произведение», в результате чего будет создана сетка точек. Функция sphereByZ все еще действует, поэтому все точки создают сферы с радиусами, основанными на значениях Z.

1. Для проверки соединим исходный список чисел с входным портом X узла Point.ByCoordinates. Мы получили куб из сфер.

2. Примечание. Если для расчета компьютеру требуется много времени, попробуйте уменьшить значение #10 и задать вместо него, например, #5.

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

И последний шаг: настройка коэффициента радиуса с помощью пользовательских параметров. Для этого необходимо создать новый входной порт для функции и заменить делитель 20 параметром.

1. Изменим определение sphereByZ на следующее:

   Copy

   def sphereByZ(inputPt,radiusRatio)
   {
   //get Z Value, use it to drive radius of sphere
   sphereRadius=inputPt.Z/radiusRatio;
   //Define Sphere Geometry
   sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);
   //Define output for function
   return sphere;
   };

2. Обновите дочерние узлы Code Block, добавив переменную ratio к входным данным: sphereByZ(Pt,ratio);. Добавьте регулятор к только что созданному узлу Code Block. Теперь можно изменять размер радиусов на основе коэффициента.

Сокращение

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

Дополнительный синтаксис

Диапазоны и последовательности

Метод определения диапазонов и последовательностей можно заменить обычной сокращенной записью. Приведенное ниже изображение можно рассматривать как руководство по использованию синтаксиса «..» для определения списка числовых данных с помощью блока кода. Освоение этой системы записи позволит более эффективно формировать числовые данные.

1. В этом примере числовой диапазон заменяется элементарной синтаксической конструкцией узла Code Block, определяющей beginning..end..step-size;. В числовом выражении получаем 0..10..1;.

2. Обратите внимание, что синтаксис 0..10..1; эквивалентен синтаксису 0..10;. Значение шага 1 является значением по умолчанию для сокращенного обозначения. Таким образом, значение 0..10; соответствует последовательности от 0 до 10 с шагом 1.

3. Похожий пример наблюдаем с узлом Sequence. Единственное исключение — знак #, указывающий на список из 15 значений, а не на список с увеличением до 15. В данном случае мы определяем beginning..#ofSteps..step-size:. Фактический синтаксис для последовательности: 0..#15..2.

4. Разместим символ # из предыдущего шага в компоненте размер шага синтаксической конструкции. Теперь есть диапазон чисел, идущий от начала к концу, а размер шага равномерно распределяет несколько значений между этими двумя точками: beginning..end..#ofSteps.

Дополнительные диапазоны

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

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

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

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

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

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

С помощью сокращений можно не только создавать списки, но и делать это динамически. Эти списки могут содержать множество типов элементов и поддерживают запросы (помните, что списки — это объекты в объектах). Наконец, в узле Code Block для создания списков и запроса элементов из списка используются скобки ( «квадратные скобки»):

1. Быстрое создание списков с помощью строк и запрос содержимого списков с помощью индекса элементов.

2. Создание списков с переменными и запрос содержимого с помощью сокращенной записи диапазонов.

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

1. Определение списка списков.

2. Запрос содержимого списка с помощью одного набора квадратных скобок.

3. Запрос содержимого списка с помощью двух наборов квадратных скобок.

Упражнение «Синусоидальная поверхность»

Скачайте файл с примером, щелкнув ссылку ниже.

Полный список файлов с примерами можно найти в приложении.

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

Начните с создания поверхности путем соединения узлов, представленных на изображении выше. Вместо использования узла Number для определения ширины и длины поверхности дважды щелкните в рабочей области, а в узле Code Block введите 100;.

1. Создайте диапазон от 0 до 1 с 50 делениями. Для этого введите 0..1..#50 в узле Code Block.

2. Соедините диапазон с узлом Surface.PointAtParameter, который извлекает значения u и v в диапазоне от 0 до 1 по всей поверхности. Не забудьте в качестве режима «Переплетение» выбрать «Векторное произведение», щелкнув правой кнопкой мыши узел Surface.PointAtParameter.

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

1. Вместо узла Formula используйте узел Code Block и укажите в нем следующую строку: (0..Math.Sin(x*360)..#50)*5;. Для быстроты мы определяем диапазон с помощью формулы внутри него. Эта формула представляет собой функцию синуса. Функция синуса получает входные данные в градусах в Dynamo, поэтому для получения полной синусоиды необходимо умножить значения x (диапазон входных значений от 0 до 1) на 360. Далее необходимо получить количество делений, соответствующее количеству точек управляющей сетки для каждого ряда, поэтому зададим пятьдесят подразделов, введя #50. Наконец, с помощью множителя 5 просто увеличим амплитуду преобразования, чтобы увидеть результат в области предварительного просмотра Dynamo.

1. Несмотря на то, что предыдущие узлы Code Block работали нормально, процесс не был полностью параметрическим. Поскольку необходимо динамически изменять его параметры, замените строку из предыдущего шага на (0..Math.Sin(x*360*cycles)..#List.Count(x))*amp;. Это позволит задавать значения на основе входных данных.

Изменим положение регуляторов (в диапазоне от 0 до 10) и получим интересный результат.

1. Транспонируйте диапазон чисел, чтобы обратить направление волны: transposeList = List.Transpose(sineList);.

1. Добавьте элементы sineList и tranposeList, чтобы получить деформированную яйцевидную поверхность: eggShellList = sineList+transposeList;.

Измените значения регуляторов, указанные ниже, чтобы «усреднить значения» алгоритма.

Осталось запросить отдельные элементы данных с помощью узла Code Block. Чтобы сформировать поверхность с определенным диапазоном точек, добавим блок кода, который показан на изображении выше, между узлами Geometry.Translate и NurbsSurface.ByPoints. В нем содержится строка текста: sineStrips[0..15..1];. С помощью нее будут выбраны первые 16 рядов точек (из 50). Если снова сгенерировать поверхность, можно увидеть, что была создана отдельная часть сетки точек.

1. Наконец, чтобы сделать узел 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, — это точка. Вся геометрия создается с помощью специальных функций (конструкторов), каждая из которых возвращает новый экземпляр геометрического объекта определенного типа. В Dynamo название каждого конструктора начинается с наименования типа объекта (в данном случае Point, точка), за которым следует метод построения объекта. Чтобы построить трехмерную точку на основе значений X, Y и Z в прямоугольной системе координат, используйте конструктор ByCoordinates:

// create a point with the following x, y, and z
// coordinates:
x = 10;
y = 2.5;
z = -6;

p = Point.ByCoordinates(x, y, z);

Конструкторы в Dynamo обычно обозначаются приставкой By, и при вызове эти функции возвращают новый объект соответствующего типа. Этот объект сохраняется в переменной, имя которой указано слева от знака равенства.

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

// create a point on a sphere with the following radius,
// theta, and phi rotation angles (specified in degrees)
radius = 5;
theta = 75.5;
phi = 120.3;
cs = CoordinateSystem.Identity();

p = Point.BySphericalCoordinates(cs, radius, theta,
    phi);

От точки к отрезку

Используя точки, можно создавать геометрические объекты более высокого уровня, например отрезки. С помощью конструктора ByStartPointEndPoint создайте объект Line (отрезок) между двумя точками:

// create two points:
p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);

// construct a line between p1 and p2
l = Line.ByStartPointEndPoint(p1, p2);

От отрезка к поверхности

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

// create points:
p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);

p3 = Point.ByCoordinates(5, -3, 5);
p4 = Point.ByCoordinates(-5, -6, 2);

p5 = Point.ByCoordinates(9, -10, -2);
p6 = Point.ByCoordinates(-11, -12, -4);

// create lines:
l1 = Line.ByStartPointEndPoint(p1, p2);
l2 = Line.ByStartPointEndPoint(p3, p4);
l3 = Line.ByStartPointEndPoint(p5, p6);

// loft between cross section lines:
surf = Surface.ByLoft([l1, l2, l3]);

От поверхности к телу

Поверхности также можно использовать для создания геометрии более высокого уровня, а именно тел. Сделать это можно, например, путем увеличения толщины поверхности на заданную величину. Многим объектам изначально назначены определенные функции, называемые методами, которые позволяют программистам выполнять действия с определенным объектом. К методам, доступным для всех геометрических объектов, относятся операции Translate и Rotate, которые позволяют переносить и поворачивать геометрию в соответствии с заданной величиной переноса или поворота. Для поверхностей доступен метод Thicken, для использования которого требуется одно входное значение — число, определяющее новую толщину поверхности.

p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);

p3 = Point.ByCoordinates(5, -3, 5);
p4 = Point.ByCoordinates(-5, -6, 2);

l1 = Line.ByStartPointEndPoint(p1, p2);
l2 = Line.ByStartPointEndPoint(p3, p4);

surf = Surface.ByLoft([l1, l2]);

// true indicates to thicken both sides of the Surface:
solid = surf.Thicken(4.75, true);

Пересечение

Команды Intersect позволяют извлекать из геометрии высокого уровня более простые геометрические объекты. Такие объекты могут затем послужить основой для создания другой сложной геометрии. В результате получается циклический процесс создания, извлечения и повторного построения геометрии. В этом примере объект поверхности Surface, извлеченный из объекта тела Solid, используется для создания объекта кривой Curve.

p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);

p3 = Point.ByCoordinates(5, -3, 5);
p4 = Point.ByCoordinates(-5, -6, 2);

l1 = Line.ByStartPointEndPoint(p1, p2);
l2 = Line.ByStartPointEndPoint(p3, p4);

surf = Surface.ByLoft([l1, l2]);

solid = surf.Thicken(4.75, true);

p = Plane.ByOriginNormal(Point.ByCoordinates(2, 0, 0),
    Vector.ByCoordinates(1, 1, 1));

int_surf = solid.Intersect(p);

int_line = int_surf.Intersect(Plane.ByOriginNormal(
    Point.ByCoordinates(0, 0, 0),
    Vector.ByCoordinates(1, 0, 0)));

Блоки кода (Code Block) — это уникальная функция Dynamo, обеспечивающая динамическую связь между визуальной и текстовой средами программирования. Блоки кода можно подключать ко всем узлам Dynamo, определяя с их помощью весь график в одном узле. Внимательно ознакомьтесь с этой главой, поскольку блок кода — это основополагающий компонент Dynamo.

Блоки кода — это своеобразные окна, позволяющие заглянуть в самую глубь языка DesignScript, лежащего в основе Dynamo. DesignScript — это язык программирования, созданный специально для использования в рамках рабочих процессов проектирования. Это понятный и удобный для чтения язык, который позволяет моментально получать обратную связь при работе с небольшими частями кода, а также поддерживает масштабирование для работы с большими и сложными функциями. Кроме того, DesignScript — это основа мощного вычислительного «мотора» Dynamo. Поскольку почти все функциональные возможности узлов и операций Dynamo имеют прямые аналоги в языке создания сценариев, пользователи получают уникальную возможность свободно переходить от работы с узлами к работе со сценарием.

Для удобства начинающих пользователей узлы можно автоматически преобразовать в текстовый синтаксис, чтобы упростить обучение работе с DesignScript или просто уменьшить слишком большие разделы графиков. Это можно сделать с помощью процедуры под названием «от узла к коду» (Node to Code), которая подробно описана в разделе . Опытные пользователи могут применять узлы Code Block для создания уникальных комбинаций существующих функций и пользовательских связей на основе разнообразных стандартных парадигм работы с кодом. Все без исключения пользователи, от начинающих до опытных, могут воспользоваться широким спектром упрощенных методов и фрагментов кода, позволяющих ускорить процесс проектирования. Хотя термин «блок кода» может вызывать робость у пользователей, не занимающихся программированием, на деле эта функция столь же проста в использовании, сколь и эффективна. Начинающий пользователь может работать с блоками кода, практически не прибегая к программированию, а опытный — задавать определения на основе сценариев для вызова из других разделов определения Dynamo.

Code Block: краткий обзор

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

При работе с блоками кода пользователю предоставляется возможность определить, каким образом будут заданы входные данные. Ниже приведены способы построения базовой точки с координатами (10, 5, 0):

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

Создание узлов Code Block

Для доступа к блокам Code Block перейдите в раздел Core >Input >Actions >Code Block. Есть и более быстрый способ: просто дважды щелкните в рабочей области, и в ней появится блок кода. Поскольку этот узел используется крайне часто, его вызов привязан к двойному щелчку.

Числа, строки и формулы

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

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

Узлы number, string и formula можно привести в качестве примеров узлов Dynamo, которые являются устаревшими по сравнению с блоками кода.

1. Традиционные методы

2. Узлы Code Block

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

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

Судя по данным в таблице выше, это очень вкусное яблоко. Я бы его с удовольствием Apple.eat().

Запись через точку в узлах Code Block

Используя аналогию с яблоком, рассмотрим узел Point.ByCoordinates и процесс создания точки с помощью узла Code Block.

Синтаксис Point.ByCoordinates(0,10); для Code Block позволяет получить тот же результат, что и узел Point.ByCoordinates в Dynamo, но его преимущество состоит в том, что для создания точки требуется лишь один узел. Это проще и эффективнее, чем соединять отдельный узел с портами ввода X и Y.

1. Используя синтаксис Point.ByCoordinates в узле Code Block, необходимо указать входные данные в том же порядке, что и в готовом узле (X,Y).

Вызов узлов Create, Actions, Query

С помощью узла Code Block можно вызвать любой стандартный узел библиотеки, кроме узлов пользовательского интерфейса, обладающих особыми функциями для пользовательского интерфейса. Например, можно вызвать узел Circle.ByCenterPointRadius, а вот вызывать узел Watch 3D не стоит.

Стандартные узлы, которых в библиотеке большинство, делятся на три типа. Как вы видите, вся библиотека упорядочена с учетом этих категорий. Методы (или узлы) этих трех типов обрабатываются иначе при вызове с помощью Code Block.

1. Create — узлы, позволяющие создавать или конструировать что-либо.

2. Action — узлы для выполнения действий с чем-либо.

3. Query — узлы для получения свойства существующего объекта.

Создание

Категория Create позволяет создавать геометрию с нуля. Значения вводятся в Code Block слева направо. Они располагаются в том же порядке, что и порты ввода в узле (сверху вниз).

При сравнении узла Line.ByStartPointEndPoint и соответствующего синтаксиса в узле Code Block мы получаем один и тот же результат.

Действие

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

1. Поскольку узел Point.Add представляет собой узел типа Action, его синтаксис работает несколько иначе.

2. Входные данные включают в себя (1) точку и (2) вектор, который требуется к ней добавить. В синтаксисе узла Code Block точка (объект) обозначена как pt. Чтобы добавить вектор (vec) к точке (pt), нужно ввести pt.Add(vec), то есть «объект, точка, действие». Для операции добавления используются все порты ввода узла Point.Add, кроме первого. Первый порт ввода узла Point.Add — это сама точка.

Query

Методы типа Query позволяют получить свойство объекта. Указывать какие-либо входные данные в этом случае не требуется, так как входными данными является сам объект. Скобки также не нужны.

Использование переплетения

Переплетение при использовании узлов отличается от переплетения с помощью Code Block. В первом случае пользователь щелкает узлы правой кнопкой мыши и выбирает параметр переплетения, который требуется применить. При работе с Code Block у пользователя есть гораздо больше возможностей для управления структурой данных. При объединении нескольких одномерных списков в пары с помощью сокращенного метода Code Block используются руководства по репликации. Цифры в угловых скобках «<>» определяют уровень иерархии итогового вложенного списка: <1>, <2>, <3> и т. д.

1. В этом примере мы используем сокращенную запись для определения двух диапазонов (подробнее о сокращенном методе можно узнать в следующем разделе этой главы). Проще говоря, 0..1; эквивалентно {0,1}, а -3..-7 эквивалентно {-3,-4,-5,-6,-7}. В результате мы получаем список из двух значений X и пяти значений Y. Если работать с этими несогласованными списками без руководств по репликации, то будет получен список, содержащий две точки, что соответствует длине кратчайшего списка. Использование руководств по репликации позволяет найти все возможные сочетания двух и пяти значений координат (а точнее, их векторное произведение).

2. Синтаксис Point.ByCoordinates(x_vals<1>,y_vals<2>); позволяет получить два списка с пятью элементами в каждом.

3. Синтаксис 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.

Для начала повторно создайте определение, показанное на изображении выше (или просто откройте файл примера).

1. Обратите внимание, что для параметра переплетения узла Point.ByCoordinates задано значение Векторное произведение.

2. Каждая точка сетки перемещена вверх по оси Z в соответствии с расстоянием до опорной точки.

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

1. Сначала определите опорную точку: Point.ByCoordinates(x,y,0);. Используйте синтаксис Point.ByCoordinates, указанный в верхней части узла опорной точки.

2. Переменные x и y вставляются в Code Block, чтобы их можно было динамически обновлять с помощью регуляторов.

3. Присоедините регуляторы к портам ввода узла Code Block и задайте их значения в диапазоне от –50 до 50. Это позволит работать по всей сетке Dynamo по умолчанию.

1. Во второй строке Code Block определите сокращенную запись для замены узла порядкового номера: coordsXY = (-50..50..#11);. Мы рассмотрим это подробнее в следующем разделе. Обратите внимание, что такая сокращенная запись эквивалентна узлу визуального программирования Number Sequence.

1. Теперь нужно создать сетку из точек последовательности coordsXY. Для этого необходимо использовать синтаксис Point.ByCoordinates. Кроме того, требуется запустить векторное произведение списка так же, как вы это делали при визуальном программировании. Для этого введите следующую строку: gridPts = Point.ByCoordinates(coordsXY<1>,coordsXY<2>,0);. Угловые скобки обозначают векторное произведение.

2. Обратите внимание на узел Watch3D, в котором отображается сетка точек на сетке Dynamo.

1. Теперь самое сложное: нужно переместить сетку точек вверх в соответствии с расстоянием до опорной точки. Для начала присвойте этому новому набору точек имя transPts. Так как выполняется преобразование уже существующего элемента, вместо узла Geometry.Translate... используйте узел gridPts.Translate.

2. Считывая данные из этого узла в рабочей области, мы видим, что он содержит три порта ввода. Преобразуемая геометрия уже определена, так как действие выполняется с текущим элементом (с использованием gridPts.Translate). Названия двух оставшихся портов (direction и distance) следует поместить в скобки функции.

3. Определить значение direction несложно, так как для перемещения по вертикали используется Vector.ZAxis().

4. Теперь необходимо рассчитать расстояние между опорной точкой и каждой точкой сетки. Выполните это действие с опорной точкой аналогичным образом: refPt.DistanceTo(gridPts).

5. Последняя строка кода содержит преобразованные точки: transPts=gridPts.Translate(Vector.ZAxis(),refPt.DistanceTo(gridPts));.

1. Теперь у вас есть сетка точек, структура данных которой позволяет создать поверхность NURBS. Поверхность создается с помощью srf = NurbsSurface.ByControlPoints(transPts);.

1. Чтобы придать поверхности глубину, создайте тело с помощью синтаксиса solid = srf.Thicken(5);. Данный код увеличивает толщину поверхности на пять единиц, однако толщину также можно сделать переменной (например, с именем thickness), а затем изменять ее значение с помощью регулятора.

Упрощение графика с помощью функции «Узел для кодировки»

Функция «Узел для кодировки» позволяет автоматизировать все действия, которые вы выполнили в предыдущем упражнении, и применять их одним нажатием кнопки. Этот мощный инструмент не только позволяет создавать пользовательские определения и узлы Code Block для многократного использования, но и помогает в изучении процесса создания сценариев в Dynamo.

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

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

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

Если отбросить все лишнее, можно сказать, что вектор представляет собой то или иное положение в 3D-пространстве. Под вектором чаще всего подразумевают конечную точку стрелки, исходящей из начала координат (0, 0, 0) и указывающей на это местоположение. Векторы создаются с помощью конструктора ByCoordinates, в котором используются координаты X, Y и Z для нового объекта Vector. Обратите внимание, что объекты Vector не являются геометрическими объектами и не отображаются в окне Dynamo. При этом информацию о созданном или измененном векторе можно вывести на печать в окне консоли:

Объекты Vector поддерживают определенный набор математических операций, которые позволяют складывать, вычитать, умножать и иным образом преобразовывать объекты в 3D-пространстве точно так же, как и при работе с вещественными числами в одномерном пространстве числовой оси.

Сложение объектов Vector

Операция сложения объектов Vector позволяет получить сумму компонентов двух векторов. Визуально представить себе результат сложения векторов можно, поместив начало второго вектора в конечную точку первого. Операция сложения объектов Vector выполняется с использованием метода Add и представлена на схеме слева.

Вычитание объектов Vector

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

Умножение объектов Vector

При умножении объекта Vector на какое-либо число его конечная точка перемещается в направлении, соответствующем направлению вектора, на расстояние, соответствующее длине вектора и множителю.

Нормализация длины вектора

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

Вектор С указывает в том же направлении, что и вектор А (1, 2, 3), но его длина теперь равна 5.

Векторное произведение

Векторная материка включает два дополнительных метода, не имеющих точных аналогов в одномерной математике: это векторное произведение и скалярное произведение. При векторном произведении создается объект Vector, который ортогонален (т. е. находится под углом 90 градусов) к двум существующим объектам Vector. В качестве примера можно привести ось Z, которая является векторным произведением осей X и Y (хотя исходные объекты Vector, на основе которых вычисляется векторное произведение, не обязательно должны быть ортогональны друг другу). Для вычисления векторного произведения используется метод Cross.

Скалярное произведение

Скалярное произведение — это еще одна дополнительная и чуть более сложная функция векторной математики. Результатом скалярного произведения двух векторов является вещественное число (а не объект Vector), соответствующее углу между этими векторами (но не равняющееся ему). Одним из полезных свойств этой функции является возможность определить, являются ли векторы перпендикулярными, поскольку только в этом случае их скалярное произведение равняется нулю. Для вычисления скалярного произведения используется метод Dot.

В этом разделе представлены упражнения по созданию геометрии с помощью DesignScript. Для их выполнения следует просто скопировать примеры кода DesignScript в узлы Code Block в Dynamo.

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

Представим, что каждой точке на кривой назначен уникальный параметр в диапазоне от 0 до 1. Если мы создаем объект NurbsCurve путем интерполяции или по нескольким управляющим точкам, то первой точке назначается параметр со значением 0, а последней — параметр со значением 1. Заранее узнать, какой именно параметр будет назначен любой из промежуточных точек, невозможно. Эта проблему можно свести к минимуму путем использования нескольких вспомогательных функций. Процесс параметризации поверхностей аналогичен процессу для кривых, за исключением того, что вместо одного параметра назначаются два — u и v. Предположим, что требуется создать поверхность по следующим точкам:

pts = [ [p1, p2, p3],
        [p4, p5, p6],
        [p7, p8, p9] ];

В этом случае точке 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:

pts = {};
pts[0] = Point.ByCoordinates(4, 0, 0);
pts[1] = Point.ByCoordinates(6, 0, 1);
pts[2] = Point.ByCoordinates(4, 0, 2);
pts[3] = Point.ByCoordinates(4, 0, 3);
pts[4] = Point.ByCoordinates(4, 0, 4);
pts[5] = Point.ByCoordinates(3, 0, 5);
pts[6] = Point.ByCoordinates(4, 0, 6);

crv = NurbsCurve.ByPoints(pts);

pts_at_param = crv.PointAtParameter(0..1..#11);

// draw Lines to help visualize the points
lines = Line.ByStartPointEndPoint(pts_at_param,
    Point.ByCoordinates(4, 6, 0));

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

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

pts = {};
pts[0] = Point.ByCoordinates(4, 0, 0);
pts[1] = Point.ByCoordinates(3, 0, 1);
pts[2] = Point.ByCoordinates(4, 0, 2);
pts[3] = Point.ByCoordinates(4, 0, 3);
pts[4] = Point.ByCoordinates(4, 0, 4);
pts[5] = Point.ByCoordinates(5, 0, 5);
pts[6] = Point.ByCoordinates(4, 0, 6);
pts[7] = Point.ByCoordinates(4, 0, 7);

crv = NurbsCurve.ByPoints(pts);

axis_origin = Point.ByCoordinates(0, 0, 0);
axis = Vector.ByCoordinates(0, 0, 1);

surf = Surface.ByRevolve(crv, axis_origin, axis, 90,
    140);

cs_array = surf.CoordinateSystemAtParameter(
    (0..1..#7)<1>, (0..1..#7)<2>);

def make_line(cs : CoordinateSystem) {
	lines_start = cs.Origin;
    lines_end = cs.Origin.Translate(cs.ZAxis, -0.75);

    return = Line.ByStartPointEndPoint(lines_start,
        lines_end);
}

lines = make_line(Flatten(cs_array));

Как уже упоминалось, параметризация не всегда выполняется равномерно по всей длине кривой или поверхности. Это значит, что параметр 0.5 не всегда соответствует средней точке, а параметр 0.25 — точке на отметке в одну четвертую длины кривой или поверхности. Чтобы обойти это ограничение, можно воспользоваться дополнительным набором команд параметризации, доступным для объектов Curve. Эти команды позволяют найти точки, расположенные в определенном месте на кривой.

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

Интерполированная кривая

Для построения интерполяционной кривой достаточно задать набор точек и использовать его в качестве входных данных для метода NurbsCurve.ByPoints.

num_pts = 6;

s = Math.Sin(0..360..#num_pts) * 4;

pts = Point.ByCoordinates(1..30..#num_pts, s, 0);

int_curve = NurbsCurve.ByPoints(pts);

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

pts = Point.ByCoordinates(Math.Cos(0..350..#10),
    Math.Sin(0..350..#10), 0);

// create an closed curve
crv = NurbsCurve.ByPoints(pts, true);

// the same curve, if left open:
crv2 = NurbsCurve.ByPoints(pts.Translate(5, 0, 0),
    false);

Кривая по управляющим точкам

Построение объектов NurbsCurve выполняется схожим образом. В качестве первого параметра задается набор точек (а именно конечных точек прямолинейных сегментов), а в качестве второго — величина и тип (т. е. степень) сглаживания кривой.* Кривая со степенью сглаживания 1 не сглаживается и представляет собой полилинию.

num_pts = 6;

pts = Point.ByCoordinates(1..30..#num_pts,
    Math.Sin(0..360..#num_pts) * 4, 0);

// a B-Spline curve with degree 1 is a polyline
ctrl_curve = NurbsCurve.ByControlPoints(pts, 1);

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

num_pts = 6;

pts = Point.ByCoordinates(1..30..#num_pts,
    Math.Sin(0..360..#num_pts) * 4, 0);

// a B-Spline curve with degree 2 is smooth
ctrl_curve = NurbsCurve.ByControlPoints(pts, 2);

В Dynamo поддерживаются NURBS-кривые (неоднородные рациональные B-сплайны) со степенью сглаживания от 1 до 20. Приведенный ниже сценарий демонстрирует, как повышение степени сглаживания влияет на форму кривой.

num_pts = 6;

pts = Point.ByCoordinates(1..30..#num_pts,
    Math.Sin(0..360..#num_pts) * 4, 0);

def create_curve(pts : Point[], degree : int)
{
	return = NurbsCurve.ByControlPoints(pts,
        degree);
}

ctrl_crvs = create_curve(pts, 1..11);

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

Еще одно преимущество построения кривых по управляющим вершинам — возможность сохранения касательности между отдельными криволинейными сегментами. Для этого программа определяет направление при движении от предпоследней управляющей точки сегмента к последней, а затем размещает две первые управляющие точки следующего сегмента в соответствии с этим направлением. В следующем примере показаны две отдельные NURBS-кривые, которые при этом выглядят как единая сглаженная кривая.

pts_1 = {};

pts_1[0] = Point.ByCoordinates(0, 0, 0);
pts_1[1] = Point.ByCoordinates(1, 1, 0);
pts_1[2] = Point.ByCoordinates(5, 0.2, 0);
pts_1[3] = Point.ByCoordinates(9, -3, 0);
pts_1[4] = Point.ByCoordinates(11, 2, 0);

crv_1 = NurbsCurve.ByControlPoints(pts_1, 3);

pts_2 = {};

pts_2[0] = pts_1[4];
end_dir = pts_1[4].Subtract(pts_1[3].AsVector());

pts_2[1] = Point.ByCoordinates(pts_2[0].X + end_dir.X,
    pts_2[0].Y + end_dir.Y, pts_2[0].Z + end_dir.Z);

pts_2[2] = Point.ByCoordinates(15, 1, 0);
pts_2[3] = Point.ByCoordinates(18, -2, 0);
pts_2[4] = Point.ByCoordinates(21, 0.5, 0);

crv_2 = NurbsCurve.ByControlPoints(pts_2, 3);

Во многих рассмотренных примерах основное внимание было уделено построению более сложных геометрических объектов на основе более простых объектов. Методы Intersect позволяют делать обратное, а именно получать простые геометрические объекты из сложных. Команды Trim и SelectTrim позволяют использовать сценарии для масштабных преобразований геометрических форм после их создания.

Метод Intersect поддерживается всеми геометрическими объектами в Dynamo. В теории это значит, что любой геометрический объект может пересекаться с любым другим геометрическим объектом. Разумеется, построение определенных пересечений, таких как пересечение объектов Point, не имеет смысла, поскольку результатом пересечения будет тот же объект Point, который был задан на входе. Другие возможные комбинации пересекающихся объектов приведены в следующей таблице. В ней указаны возможные результаты различных операций пересечения.

Пересечение

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

// python_points_5 is a set of Points generated with
// a Python script found in Chapter 12, Section 10

surf = NurbsSurface.ByPoints(python_points_5, 3, 3);

WCS = CoordinateSystem.Identity();

pl = Plane.ByOriginNormal(WCS.Origin.Translate(0, 0,
    0.5), WCS.ZAxis);

// intersect surface, generating three closed curves
crvs = surf.Intersect(pl);

crvs_moved = crvs.Translate(0, 0, 10);

Метод Trim очень похож на метод Intersect. Он поддерживается почти для всех геометрических объектов. Однако в отношении метода Trim действует больше ограничений, чем в отношении метода Intersect.

Обрезка

Особенностью методов Trim является обязательное наличие точки «выбора», определяющей, какая геометрия будет обрезана, а какая сохранена. Dynamo использует точку выбора для выявления геометрии, находящейся ближе всего к этой точке, и затем обрезает эту геометрию.

// python_points_5 is a set of Points generated with
// a Python script found in Chapter 12, Section 10

surf = NurbsSurface.ByPoints(python_points_5, 3, 3);

tool_pts = Point.ByCoordinates((-10..20..10)<1>,
    (-10..20..10)<2>, 1);

tool = NurbsSurface.ByPoints(tool_pts);

pick_point = Point.ByCoordinates(8, 1, 3);

result = surf.Trim(tool, pick_point);

Объект NurbsSurface является двумерным аналогом объекта NurbsCurve. Как и объекты NurbsCurve, объекты NurbsSurfaces создаются двумя основными способами: путем интерполяции набора базовых точек либо указания управляющих точек поверхности. Аналогично кривым произвольной формы интерполяционные поверхности подходят для случаев, когда проектировщик точно знает, какой формы должна быть поверхность, или когда в проекте заданы конкретные точки зависимости, через которые плоскость должна проходить. Поверхности по управляющим точкам подходят для случаев, требующих анализа поведения поверхности при различных уровнях сглаживания.

Интерполированная поверхность

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

// python_points_1 is a set of Points generated with
// a Python script found in Chapter 12, Section 10

surf = NurbsSurface.ByPoints(python_points_1);

Точки управления поверхностью

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

// python_points_1 is a set of Points generated with
// a Python script found in Chapter 12, Section 10

// create a surface of degree 2 with smooth segments
surf = NurbsSurface.ByPoints(python_points_1, 2, 2);

Увеличив степень сглаживания объекта NurbsSurface, можно изменить итоговую геометрию поверхности.

// python_points_1 is a set of Points generated with
// a Python script found in Chapter 12, Section 10

// create a surface of degree 6
surf = NurbsSurface.ByPoints(python_points_1, 6, 6);

Поверхность по сечениям

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

// python_points_2, 3, and 4 are generated with
// Python scripts found in Chapter 12, Section 10

c1 = NurbsCurve.ByPoints(python_points_2);
c2 = NurbsCurve.ByPoints(python_points_3);
c3 = NurbsCurve.ByPoints(python_points_4);

loft = Surface.ByLoft([c1, c2, c3]);

Вращение поверхности

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

Для построения поверхности вращения необходимо задать базовую кривую («кромку» поверхности), начало координат оси (базовую точку поверхности), направление оси (направление «центра», вокруг которого строится поверхность), начальный и конечный углы сдвига. Все эти данные используются в качестве входных параметров конструктора Surface.Revolve.

pts = {};
pts[0] = Point.ByCoordinates(4, 0, 0);
pts[1] = Point.ByCoordinates(3, 0, 1);
pts[2] = Point.ByCoordinates(4, 0, 2);
pts[3] = Point.ByCoordinates(4, 0, 3);
pts[4] = Point.ByCoordinates(4, 0, 4);
pts[5] = Point.ByCoordinates(5, 0, 5);
pts[6] = Point.ByCoordinates(4, 0, 6);
pts[7] = Point.ByCoordinates(4, 0, 7);

crv = NurbsCurve.ByPoints(pts);

axis_origin = Point.ByCoordinates(0, 0, 0);
axis = Vector.ByCoordinates(0, 0, 1);

surf = Surface.ByRevolve(crv, axis_origin, axis, 0,
    360);

Определенные геометрические объекты можно создавать путем непосредственного указания их координат по осям X, Y и Z в трехмерном пространстве. Однако в большинстве случаев итоговое положение геометрии задается путем преобразований, применяемых либо к самому объекту, либо к его базовой системе координат (CoordinateSystem).

Перемещение

Простейшим геометрическим преобразованием является перенос, в результате которого объект перемещается на заданное число делений вдоль осей X, Y и Z.

// create a point at x = 1, y = 2, z = 3
p = Point.ByCoordinates(1, 2, 3);

// translate the point 10 units in the x direction,
// -20 in y, and 50 in z
// p2’s new position is x = 11, y = -18, z = 53
p2 = p.Translate(10, -20, 50);

Поворот

Любой объект в Dynamo можно перенести, просто добавив метод .Translate после имени объекта, однако более сложные преобразования требуют изменения базовой системы координат объекта (CoordinateSystem). Например, чтобы повернуть объект на 45 градусов вокруг оси X, потребуется заменить существующую систему координат (без поворота) на систему координат, повернутую на 45 градусов вокруг оси X с помощью метода .Transform.

cube = Cuboid.ByLengths(CoordinateSystem.Identity(),
    10, 10, 10);

new_cs = CoordinateSystem.Identity();
new_cs2 = new_cs.Rotate(Point.ByCoordinates(0, 0),
    Vector.ByCoordinates(1,0,0.5), 25);

// get the existing coordinate system of the cube
old_cs = CoordinateSystem.Identity();

cube2 = cube.Transform(old_cs, new_cs2);

Масштаб

Помимо операций переноса и поворота к объектам CoordinateSystem также можно применять операции масштабирования и сдвига. Для масштабирования объектов CoordinateSystem используется метод .Scale.

cube = Cuboid.ByLengths(CoordinateSystem.Identity(),
    10, 10, 10);

new_cs = CoordinateSystem.Identity();
new_cs2 = new_cs.Scale(20);

old_cs = CoordinateSystem.Identity();

cube2 = cube.Transform(old_cs, new_cs2);

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

new_cs = CoordinateSystem.ByOriginVectors(
    Point.ByCoordinates(0, 0, 0),
	Vector.ByCoordinates(-1, -1, 1),
	Vector.ByCoordinates(-0.4, 0, 0));

old_cs = CoordinateSystem.Identity();

cube = Cuboid.ByLengths(CoordinateSystem.Identity(),
    5, 5, 5);

new_curves = cube.Transform(old_cs, new_cs);

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

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

python_points_1

python_points_2

python_points_3

python_points_4

python_points_5

В Dynamo 2.0 появилась возможность задавать шаблон по умолчанию (.py extension) для использования при первом открытии окна Python. Эта функция, о которой нас давно просили пользователи, значительно ускоряет процесс работы со сценариями Python в Dynamo. Благодаря возможности использовать шаблон программисты получают мгновенный доступ к данным, которые требуется импортировать по умолчанию и на основе которых они могут разрабатывать пользовательские сценарии Python.

Этот шаблон размещается в подпапке APPDATA папки установки Dynamo.

Обычно используется следующий путь: ( %appdata%\Dynamo\Dynamo Core\{version}\ ).

Настройка шаблона

Для использования этой функции необходимо добавить в файл DynamoSettings.xml следующую строку (правки вносятся в Блокноте).

Найдите строку <PythonTemplateFilePath /> и замените ее следующим кодом:

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

Создайте документ в Блокноте и вставьте в него следующий код:

Когда все будет готово, сохраните этот файл под именем PythonTemplate.py в папке APPDATA.

Дальнейшее поведение сценария Python

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

Если шаблон Python найден (как в случае с созданным шаблоном для работы с Revit), отображаются встроенные в него функции по умолчанию.

Подробные сведения об этом дополнении см. в следующем материале (автор: Раду Гидей [Radu Gidei]): https://github.com/DynamoDS/Dynamo/pull/8122

Зачем использовать текстовое программирование в среде визуального программирования Dynamo? У много преимуществ. Оно позволяет создавать программы в интуитивно-понятном визуальном интерфейсе, не обладая навыками работы со специальным синтаксисом. Однако визуальная программа может оказаться перегруженной, а порой и недостаточно функциональной. Для сравнения, в Python реализованы гораздо более доступные способы записи условных выражений (если/то) и создания циклов. Python — это мощный инструмент, который позволяет расширить возможности Dynamo и заменить большое количество узлов компактными строками кода.

Визуальная программа

Текстовая программа

Узел Python

Подобно блокам кода узлы Python представляют собой интерфейс сценариев в среде визуального программирования. Узел Python находится в библиотеке в разделе Script > Editor > Python Script.

Двойной щелчок на узле приводит к открытию редактора сценариев Python (можно также щелкнуть узел правой кнопкой мыши и выбрать команду Редактировать...). Сверху находится подсказка, которая поможет обратиться к нужным библиотекам. Входные данные хранятся в массиве IN. Значения возвращаются в Dynamo путем назначения им переменной OUT.

Методы включают в себя конструкторы (например, ByCoordinates), действия (например, Add) и запросы (например, координаты X, Y и Z).

Упражнение «Пользовательский узел со сценарием Python для создания массивов из твердотельного модуля»

Часть I. Настройка сценария Python

Скачайте файл примера, щелкнув указанную ниже ссылку.

Полный список файлов примеров можно найти в приложении.

В этом примере мы напишем сценарий Python для создания образцов на основе твердотельного модуля и преобразуем этот сценарий в пользовательский узел. Сначала создадим твердотельный модуль с помощью узлов Dynamo.

1. Rectangle.ByWidthLength. Создайте прямоугольник, который будет служить основой твердого тела.

2. Surface.ByPatch. Соедините прямоугольник с входным параметром closedCurve для создания нижней поверхности.

1. Geometry.Translate. Соедините прямоугольник с входным параметром geometry для его перемещения вверх, используя блок кода для указания толщины основания тела.

2. Polygon.Points. Запросите извлечение угловых точек из преобразованного прямоугольника.

3. Geometry.Translate. Используйте блок кода для создания списка из четырех значений, соответствующих четырем точкам, перемещающим один угол тела вверх.

4. Polygon.ByPoints. С помощью преобразованных точек воссоздайте верхний полигон.

5. Surface.ByPatch. Присоедините полигон для создания верхней поверхности.

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

1. List.Create. Соедините нижний прямоугольник и верхний полигон с входными параметрами индекса.

2. Surface.ByLoft. Выполните лофтинг двух профилей для создания сторон тела.

3. List.Create. Соедините верхнюю, боковую и нижнюю поверхности с входными параметрами индекса для создания списка поверхностей.

4. Solid.ByJoinedSurfaces. Соедините поверхности для создания твердотельного модуля.

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

1. Чтобы добавить дополнительные входные параметры к узлу, закройте редактор и щелкните значок «+» на узле. Входным параметрам присваиваются имена IN[0], IN[1] и т. д. Это говорит о том, что они представляют элементы в списке.

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

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

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

Поскольку твердотельные модули будут не только преобразовываться, но и поворачиваться, воспользуемся операцией Geometry.Transform. Если посмотреть на узел Geometry.Transform, становится понятно, что для преобразования тела потребуется исходная система координат и целевая система координат. В качестве первой выступает контекстная система координат тела, а в качестве второй — система координат, которая различна для каждого модуля массива. Таким образом, чтобы система координат каждый раз преобразовывалась по-разному, необходимо перебирать значения координат по осям X и Y.

Нажмите кнопку «Выполнить», а затем сохраните код. Соедините узел Python с существующим сценарием следующим образом.

1. Соедините выходные данные узла Python с узлом Solid.ByJoinedSurfaces в качестве первого порта ввода и используйте узел Code Block для определения других входных данных.

2. Создайте узел Topology.Edges и используйте в качестве входных данных выходные данные узла Python.

3. Наконец, создайте узел Edge.CurveGeometry и в качестве входных данных используйте выходные данные Topology.Edges.

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

Часть II. Преобразование узла сценария Python в пользовательский узел

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

Присвойте имя, добавьте описание и категорию.

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

1. Inputs. Измените имена входных параметров, сделав их более описательными, и добавьте типы данных и значения по умолчанию.

2. Output: измените имя узла Output.

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

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

Методы Intersect, Trim и SelectTrim в основном используются при работе с простыми геометрическими объектами, такими как точки, кривые и поверхности. Для твердотельных геометрических объектов доступны дополнительные методы изменения формы после ее построения. Эти методы включают как удаление материала аналогично методу Trim, так и объединение нескольких элементов для получения единого большого элемента.

Объединение

Метод Union позволяет создать новый твердотельный объект на основе двух исходных объектов. Итоговый объект занимает в пространстве столько же места, сколько занимали оба исходных. Если объекты накладываются друг на друга в пространстве, то в итоговой форме накладывающиеся участки объединяются. В этом примере из сферы и кубоида путем объединения была получена единая кубо-сферическая твердотельная форма:

Разница

Метод Difference, аналогично методу Trim, позволяет удалить из базового тела материал, объем которого соответствует используемому на входе твердотельному инструменту. В этом примере в сфере был создан небольшой вырез:

Пересечение

Результатом использования метода Intersect является тело, образованное наложением двух других тел. В следующем примере вместо метода Difference был использован метод Intersect, в результате чего было получено тело, объем которого соответствует вырезу в предыдущем примере:

Python и Revit

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

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

API для конкретных платформ

Упражнение 1

Создайте новый проект Revit.

Скачайте файл примера, щелкнув указанную ниже ссылку.

Полный список файлов примеров можно найти в приложении.

В этих упражнениях рассматриваются простейшие сценарии Python, которые можно использовать в модуле Dynamo для Revit. Данное упражнение посвящено работе с файлами и элементами Revit, а также взаимодействию между Revit и Dynamo.

Рассмотрим стандартный способ извлечения элементов doc, uiapp и app из файла Revit, связанного с сеансом Dynamo. Программистам, которые уже работали с API Revit, могут быть знакомы элементы в списке отслеживания. Однако даже если эти элементы встречаются в первый раз, в последующих упражнениях будут и другие примеры.

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

Посмотрите, как выглядит узел Python в Dynamo. Код также можно найти ниже.

Упражнение 2

Скачайте файл примера, щелкнув указанную ниже ссылку.

Полный список файлов примеров можно найти в приложении.

В этом упражнении будет создана простая кривая модели в Revit с помощью узла Python в Dynamo.

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

Откройте папку Conceptual Mass и используйте файл шаблона Metric Mass.rft.

В Revit используйте комбинацию клавиш un, чтобы вызвать окно параметров«Единицы проекта», и измените единицы измерения длины на метры.

Запустите Dynamo и сформируйте набор узлов, как показано на изображении ниже. Сначала создайте две опорные точки в Revit с помощью узлов Dynamo.

1. Создайте узел Code Block и присвойте ему значение "0;".

2. Соедините это значение с портами ввода X, Y и Z узла ReferencePoint.ByCoordinates.

3. Создайте три регулятора в диапазоне от –100 до 100 с шагом 1.

4. Соедините каждый из регуляторов с узлом ReferencePoint.ByCoordinates.

5. Добавьте в рабочее пространство узел Python, нажмите кнопку «+» в узле, чтобы добавить еще один порт ввода, и соедините опорные точки с портами ввода. Откройте узел Python.

Посмотрите, как выглядит узел Python в Dynamo. Полный код см. ниже.

1. System.Array. Приложению Revit в качестве входного параметра требуется системный массив (а не список Python). Для этого необходима лишь еще одна строка кода, но следует уделить особое внимание типам аргументов, чтобы упростить программирование на языке Python в Revit.

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

Упражнение 3

Скачайте файл примера, щелкнув указанную ниже ссылку.

Полный список файлов примеров можно найти в приложении.

Это упражнение довольно несложное, однако оно хорошо иллюстрирует процесс обмена данными и геометрией между Revit и Dynamo. Сначала откройте файл Revit-StructuralFraming.rvt. Затем запустите Dynamo и откройте файл Revit-StructuralFraming.dyn.

Этот файл Revit содержит лишь самые базовые данные. Имеются две опорные кривые: одна на уровне 1, другая — на уровне 2. Эти кривые необходимо добавить в Dynamo, сохранив динамическую связь.

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

1. Узлы Select Model Element. Нажмите кнопку выбора в каждом узле и выберите соответствующую кривую в Revit.

2. Code Block. Используя синтаксис 0..1..#x;, соедините регулятор целых чисел от 0 до 20 с портом ввода x. Этот регулятор задает количество балок, которые будут построены между двумя кривыми.

3. Structural Framing Types. В раскрывающемся меню выберите балку по умолчанию (W12x26).

4. Levels. Выберите Level 1.

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

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

Результаты также можно увидеть в Dynamo. Балки в узле Watch3D ссылаются на геометрию, запрошенную из элементов Revit.

Обратите внимание, что полученный процесс преобразования данных из среды Revit в среду Dynamo является непрерывным. Вкратце этот процесс происходит следующим образом:

1. Выбор элемента Revit.

2. Преобразование элемента Revit в кривую Dynamo.

3. Разделение кривой Dynamo на серию точек Dynamo.

4. Использование точек Dynamo между двумя кривыми для создания линий Dynamo.

5. Создание балок Revit на основе линий Dynamo.

6. Вывод поверхностей Dynamo путем запроса геометрии балок Revit.

Этот процесс может показаться довольно сложным, однако при использовании сценария достаточно отредактировать кривую в Revit и повторно запустить решатель (хотя при этом может потребоваться удалить ранее созданные балки). Это связано с тем, что при размещении балок в Python связи стандартных узлов по умолчанию разрываются.

Обновив опорные кривые в Revit, мы получим новый массив балок.

СистемаКоординат

Несмотря на то что в 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.

3D-примитивы: кубоид, конус, цилиндр, сфера и т. д.

В Dynamo доступны объекты, представляющие базовые типы геометрических трехмерных примитивов: кубоиды, для создания которых используется Cuboid.ByLength; конусы, создаваемые с помощью Cone.ByPointsRadius и Cone.ByPointsRadii; цилиндры, получаемые при помощи Cylinder.ByRadiusHeight; и сферы, создаваемые с помощью Sphere.ByCenterPointRadius.