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

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

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

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

Для создания объекта CoordinateSystem, центрованного по точке с координатами x = 0, y = 0, z = 0 без поворота, масштабирования или сдвига, достаточно вызвать конструктор Identity:

// create a CoordinateSystem at x = 0, y = 0, z = 0,
// no rotations, scaling, or sheering transformations

cs = CoordinateSystem.Identity();

Объекты CoordinateSystem, к которым были применены геометрические преобразования, в этой главе не рассматриваются, однако стоит упомянуть один конструктор, который позволяет создать систему координат в определенной точке, — CoordinateSystem.ByOriginVectors:

// create a CoordinateSystem at a specific location,
// no rotations, scaling, or sheering transformations
x_pos = 3.6;
y_pos = 9.4;
z_pos = 13.0;

origin = Point.ByCoordinates(x_pos, y_pos, z_pos);
identity = CoordinateSystem.Identity();

cs = CoordinateSystem.ByOriginVectors(origin,
    identity.XAxis, identity.YAxis, identity.ZAxis);

Точка

Простейшим геометрическим примитивом является Point (точка), обозначающий расположение, у которого отсутствуют измерения, в трехмерном пространстве. Как уже упоминалось ранее, создать точку в определенной системе координат можно несколькими способами: с помощью Point.ByCoordinates по заданным координатам X, Y и Z; с помощью Point.ByCartesianCoordinates по заданным координатам X, Y и Z в определенной системе координат; с помощью Point.ByCylindricalCoordinates на цилиндре, заданном по радиусу, углу поворота и высоте; и, наконец, с помощью Point.BySphericalCoordinates на сфере, заданной по радиусу и двум углам поворота.

В этом примере показаны точки, созданные в разных системах координат:

// create a point with x, y, and z coordinates
x_pos = 1;
y_pos = 2;
z_pos = 3;

pCoord = Point.ByCoordinates(x_pos, y_pos, z_pos);

// create a point in a specific coordinate system
cs = CoordinateSystem.Identity();
pCoordSystem = Point.ByCartesianCoordinates(cs, x_pos,
    y_pos, z_pos);

// create a point on a cylinder with the following
// radius and height
radius = 5;
height = 15;
theta = 75.5;

pCyl = Point.ByCylindricalCoordinates(cs, radius, theta,
    height);

// create a point on a sphere with radius and two angles

phi = 120.3;

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

Линия

Следующим по сложности примитивом Dynamo является отрезок, который представляет собой бесконечное количество точек, лежащее между двумя конечными точками. Чтобы создать отрезок, можно либо явным образом задать две граничные точки с помощью конструктора Line.ByStartPointEndPoint, либо задать начальную точку, направление и длину с помощью конструктора Line.ByStartPointDirectionLength.

p1 = Point.ByCoordinates(-2, -5, -10);
p2 = Point.ByCoordinates(6, 8, 10);

// a line segment between two points
l2pts = Line.ByStartPointEndPoint(p1, p2);

// a line segment at p1 in direction 1, 1, 1 with
// length 10
lDir = Line.ByStartPointDirectionLength(p1,
    Vector.ByCoordinates(1, 1, 1), 10);

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

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

// create a cuboid with specified lengths
cs = CoordinateSystem.Identity();

cub = Cuboid.ByLengths(cs, 5, 15, 2);

// create several cones
p1 = Point.ByCoordinates(0, 0, 10);
p2 = Point.ByCoordinates(0, 0, 20);
p3 = Point.ByCoordinates(0, 0, 30);

cone1 = Cone.ByPointsRadii(p1, p2, 10, 6);
cone2 = Cone.ByPointsRadii(p2, p3, 6, 0);

// make a cylinder
cylCS = cs.Translate(10, 0, 0);

cyl = Cylinder.ByRadiusHeight(cylCS, 3, 10);

// make a sphere
centerP = Point.ByCoordinates(-10, -10, 0);

sph = Sphere.ByCenterPointRadius(centerP, 5);

Точка

Простейший геометрический объект, доступный в библиотеке стандартных геометрических объектов 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)));

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

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

// construct a Vector object
v = Vector.ByCoordinates(1, 2, 3);

s = v.X + " " + v.Y + " " + v.Z;

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

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

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

a = Vector.ByCoordinates(5, 5, 0);
b = Vector.ByCoordinates(4, 1, 0);

// c has value x = 9, y = 6, z = 0
c = a.Add(b);

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

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

a = Vector.ByCoordinates(5, 5, 0);
b = Vector.ByCoordinates(4, 1, 0);

// c has value x = 1, y = 4, z = 0
c = a.Subtract(b);

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

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

a = Vector.ByCoordinates(4, 4, 0);

// c has value x = 20, y = 20, z = 0
c = a.Scale(5);

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

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

a = Vector.ByCoordinates(1, 2, 3);
a_len = a.Length;

// set the a's length equal to 1.0
b = a.Normalized();
c = b.Scale(5);

// len is equal to 5
len = c.Length;

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

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

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

a = Vector.ByCoordinates(1, 0, 1);
b = Vector.ByCoordinates(0, 1, 1);

// c has value x = -1, y = -1, z = 1
c = a.Cross(b);

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

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

a = Vector.ByCoordinates(1, 2, 1);
b = Vector.ByCoordinates(5, -8, 4);

// d has value -7
d = a.Dot(b);

Создавать кривые произвольной формы в 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);

Объект 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, которые поддерживают операции изменения масштаба и сдвига системы координат, перечислены в следующей таблице.

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

Объединение

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

Разница

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

Пересечение

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

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

Представим, что каждой точке на кривой назначен уникальный параметр в диапазоне от 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. Эти команды позволяют найти точки, расположенные в определенном месте на кривой.

Приведенные ниже сценарии 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 использует точку выбора для выявления геометрии, находящейся ближе всего к этой точке, и затем обрезает эту геометрию.