Wolfram Language & System Documentation Center

AnglePath3D

AnglePath3D[{{α₁,β₁,γ₁},{α₂,β₂,γ₂},…}]

gives the list of 3D coordinates of a path of an object that starts at {0,0,0}, then takes a series of steps of unit length, each in the direction of the axis obtained after successive rotation of the object by the Euler angles α_i, β_i, γ_i.

AnglePath3D[{{α₁,β₁},{α₂,β₂},…}]

assumes the Euler angles γ_i to be 0.

AnglePath3D[{mat₁,mat₂,…}]

takes the successive rotations to be specified by the 3D rotation matrices mat_i.

AnglePath3D[{{r₁,rot₁},{r₂,rot₂},…}]

takes successive steps of length r_i with Euler angles or rotation matrices specified by rot_i.

AnglePath3D[{x₀,y₀,z₀},steps]

starts at the point {x₀,y₀,z₀}.

AnglePath3D[{rot₀},steps]

starts in the axis direction specified by rotating the object according to Euler angles or rotation matrix rot₀.

AnglePath3D[{{x₀,y₀,z₀},rot₀},steps]

starts at point {x₀,y₀,z₀} with the axis direction specified by rot₀.

AnglePath3D[init,steps,form]

returns at each step the data of the form specified by form.

AnglePath3D

AnglePath3D[{{α₁,β₁,γ₁},{α₂,β₂,γ₂},…}]

AnglePath3D[{{α₁,β₁},{α₂,β₂},…}]

assumes the Euler angles γ_i to be 0.

AnglePath3D[{mat₁,mat₂,…}]

takes the successive rotations to be specified by the 3D rotation matrices mat_i.

AnglePath3D[{{r₁,rot₁},{r₂,rot₂},…}]

takes successive steps of length r_i with Euler angles or rotation matrices specified by rot_i.

AnglePath3D[{x₀,y₀,z₀},steps]

starts at the point {x₀,y₀,z₀}.

AnglePath3D[{rot₀},steps]

starts in the axis direction specified by rotating the object according to Euler angles or rotation matrix rot₀.

AnglePath3D[{{x₀,y₀,z₀},rot₀},steps]

starts at point {x₀,y₀,z₀} with the axis direction specified by rot₀.

AnglePath3D[init,steps,form]

returns at each step the data of the form specified by form.

Details and Options

The successive directions taken in AnglePath3D are defined by the axes of successive local frames, which can be thought of as defining the orientation of a 3D object.
By default, the orientation of the initial frame is aligned with the coordinate axes.
At each step, the local frame is rotated, then the path advances by the specified distance along the axis in the new frame.
A triple of angles {α_i,β_i,γ_i} is generally equivalent to the Euler rotation matrix EulerMatrix[{α_i,β_i,γ_i},{3,2,1}]. In this convention, α_i can be thought of as a longitude angle, β_i as a latitude angle and γ_i as a rotation angle about the displacement axis.
The lengths of the steps can be specified with {{r₁,rot₁},{r₂,rot₂},…}, or equivalently with {{r₁,r₂,…},{rot₁,rot₂,…}}.
For a step of length r_i with direction specified by mat_i, the next position p_i={x_i,y_i,z_i} is obtained by p_i=p_i-1+f_i.{r_i,0,0}, with the frame rotation matrix f_i given by f_i=f_i-1.mat_i and f₀=mat₀.
AnglePath3D[steps,form] is equivalent to AnglePath3D[{0,0,0},steps,form].
Possible choices for form in AnglePath3D[…,form] include:

	"Position"	Cartesian coordinates {x_i,y_i,z_i} (default)
	"FrameMatrix"	rotation matrix of the frame f_i with respect to f₀
	"EulerMatrix"	rotation matrix of the frame f_i with respect to f_{i - 1}
	"FrameAngles"	EulerAngles[f_i,{3,2,1}]
	"EulerAngles"	{α_i,β_i,γ_i}
	"Translation"	TranslationTransform[{x_i,y_i,z_i}]
	"Rotation"	AffineTransform[f_i]
	"RotationTranslation"	AffineTransform[{f_i,{x_i,y_i,z_i}}]
	{form₁,form₂,…}	a list of forms

The arguments init and steps can be symbolic. They can also be Quantity objects.
AnglePath3D has the option WorkingPrecision, which determines the precision of numbers generated.
With the default setting WorkingPrecisionAutomatic, exact numbers will be generated for exact input only for fairly short paths; for longer paths, machine precision will be used.

Examples

open all close all

Basic Examples (6)

Starting at {0,0,0} along the axis, move several unit steps, rotating by 90° with respect to the local axis at each step:

Wolfram Language code: AnglePath3D[{{90°, 0, 0}, {90°, 0, 0}, {90°, 0, 0}}]

Move several unit steps, rotating the local frame by Euler angles 30°, 30° and 90° with respect to the local axes , and :

Wolfram Language code: AnglePath3D[{{30°, 30°, 90°}, {30°, 30°, 90°}, {30°, 30°, 90°}}]

Move with steps of different lengths, rotating the local frame by Euler angles 90° with respect to the local axes and :

Wolfram Language code: AnglePath3D[{{1, {90°, 90°}}, {2, {90°, 90°}}, {3, {90°, 90°}}}]

Advance 20 steps, always rotating the local frame by Euler angles 100° with respect to all axes:

Wolfram Language code: Graphics3D[Tube[AnglePath3D[ConstantArray[{100.°, 100.°, 100.°}, 20]]], Boxed -> False]

Draw a helix:

Wolfram Language code: pos = AnglePath3D[ConstantArray[N@{0, -π / 12, π / 25}, 100]];

Wolfram Language code: Graphics3D[Arrow[pos]]

Generate the transformation functions of a path:

Wolfram Language code: transformations = AnglePath3D[{{7, {π / 2, 0}}, {9, {0, π / 2}}}, "RotationTranslation"]

Apply them to a triceratops:

Wolfram Language code:

triceratops = ExampleData[{"Geometry3D", "Triceratops"}, "GraphicsComplex"];
Graphics3D[GeometricTransformation[triceratops, transformations]]

Use symbolic inputs:

Wolfram Language code: AnglePath3D[{{0, 0, Subscript[γ, 1]}, {0, Subscript[β, 2], 0}, {Subscript[α, 3], 0, 0}}]

Scope (22)

Steps Specification (7)

Generate a path of unit steps with triples of Euler angles, starting at position {0,0,0} in the direction of the axis:

Wolfram Language code: AnglePath3D[{{90°, 0, 30°}, {60°, -120°, 0}, {0, 180°, -45°}}]

Generate a path of unit steps with pairs of Euler angles:

Wolfram Language code: AnglePath3D[{{π / 3, 0}, {π / 2, -2π / 3}, {0, π}}]

AnglePath3D[{{α₁,β₁},{α₂,β₂},…}] assumes the third Euler angles to be 0:

Wolfram Language code:

path1 = AnglePath3D[{{Subscript[α, 1], Subscript[β, 1]}, {Subscript[α, 2], Subscript[β, 2]}, {Subscript[α, 3], Subscript[β, 3]}}];
path2 = AnglePath3D[{{Subscript[α, 1], Subscript[β, 1], 0}, {Subscript[α, 2], Subscript[β, 2], 0}, {Subscript[α, 3], Subscript[β, 3], 0}}];

Wolfram Language code: path1 === path2

Specify the lengths of the steps:

Wolfram Language code:

lengths = {2, 5, 7};
angles = {{0, π / 2, -5π / 6}, {3π / 2, 0, π / 3}, {0, -π / 3, 0}};

Wolfram Language code: AnglePath3D[{lengths, angles}]

The lengths and directions of the steps can be given jointly or separately:

Wolfram Language code:

path1 = AnglePath3D[{{Subscript[r, 1], {Subscript[α, 1], Subscript[β, 1], Subscript[γ, 1]}}, {Subscript[r, 2], {Subscript[α, 2], Subscript[β, 2], Subscript[γ, 2]}}, {Subscript[r, 3], {Subscript[α, 3], Subscript[β, 3], Subscript[γ, 3]}}}];
path2 = AnglePath3D[{{Subscript[r, 1], Subscript[r, 2], Subscript[r, 3]}, {{Subscript[α, 1], Subscript[β, 1], Subscript[γ, 1]}, {Subscript[α, 2], Subscript[β, 2], Subscript[γ, 2]}, {Subscript[α, 3], Subscript[β, 3], Subscript[γ, 3]}}}];

Wolfram Language code: path1 === path2

Use three-dimensional rotation matrices instead of Euler angles:

Wolfram Language code:

mat1 = {{1 / 2, -Sqrt[3] / 2, 0}, {Sqrt[3] / 2, 1 / 2, 0}, {0, 0, 1}};
mat2 = {{0, -1, 0}, {-1 / 2, 0, -Sqrt[3] / 2}, {Sqrt[3] / 2, 0, -1 / 2}};

Wolfram Language code: AnglePath3D[{mat1, mat2}]

Use Quantity objects in input:

Wolfram Language code:

lengths = Quantity[{2, 5, 7}, "Meters"];
angles = Quantity[{{4.6, 2.7}, {0.4, 3.2}, {1.5, 8.6}}, "Radians"];

Wolfram Language code: AnglePath3D[{lengths, angles}]

Path Initialization (7)

Generate a path starting at a specific position:

Wolfram Language code:

steps = {{90°, 0, 30°}, {60°, -120°, 0}, {0, 180°, -45°}};
p0 = {5, 15, 10};

Wolfram Language code: AnglePath3D[p0, steps]

Choose the orientation of the initial frame by giving a triple of Euler angles:

Wolfram Language code:

steps = {{90°, 0, 30°}, {60°, -120°, 0}, {0, 180°, -45°}};
ang0 = {π / 6, 0, π};

Wolfram Language code: AnglePath3D[{ang0}, steps]

Specify the initial orientation with a pair of Euler angles:

Wolfram Language code:

steps = {{90°, 0, 30°}, {60°, -120°, 0}, {0, 180°, -45°}};
ang0 = {-π / 3, π / 2};

Wolfram Language code: AnglePath3D[{ang0}, steps]

Specify the initial orientation with a three-dimensional rotation matrix:

Wolfram Language code:

steps = {{90°, 0, 30°}, {60°, -120°, 0}, {0, 180°, -45°}};
mat0 = {{0, Sqrt[3] / 2, 1 / 2}, {0, 1 / 2, -Sqrt[3] / 2}, {-1, 0, 0}};

Wolfram Language code: AnglePath3D[{mat0}, steps]

Generate a path where both initial position and initial orientation are specified:

Wolfram Language code:

steps = {{90°, 0, 30°}, {60°, -120°, 0}, {0, 180°, -45°}};
p0 = {5, 15, 10};
ang0 = {π / 6, 0, π};

Wolfram Language code: AnglePath3D[{p0, ang0}, steps]

The orientation of the initial frame can be alternatively specified at the first step:

Wolfram Language code:

path1 = AnglePath3D[
	{{x, y, z}, {Subscript[α, 0], Subscript[β, 0], Subscript[γ, 0]}}, {{Subscript[r, 1], Subscript[r, 2]}, {{Subscript[α, 1], Subscript[β, 1], Subscript[γ, 1]}, {Subscript[α, 2], Subscript[β, 2], Subscript[γ, 2]}}}
	];

Wolfram Language code:

path2 = AnglePath3D[
	{x, y, z}, {{0, Subscript[r, 1], Subscript[r, 2]}, {{Subscript[α, 0], Subscript[β, 0], Subscript[γ, 0]}, {Subscript[α, 1], Subscript[β, 1], Subscript[γ, 1]}, {Subscript[α, 2], Subscript[β, 2], Subscript[γ, 2]}}}
	];

These are two equivalent paths:

Wolfram Language code: path1 === Rest@path2

Use Quantity objects in input:

Wolfram Language code:

initpos = Quantity[{2, 4, 3}, "Meters"];
lengths = Quantity[{2, 5, 7}, "Meters"];
angles = Quantity[{{4.6, 2.7}, {0.4, 3.2}, {1.5, 8.6}}, "Radians"];

Wolfram Language code: AnglePath3D[initpos, {lengths, angles}]

Forms of Data (8)

By default, AnglePath3D returns the position of the point reached at each step:

Wolfram Language code:

rots = {{Subscript[α, 1], Subscript[β, 1], Subscript[γ, 1]}, {Subscript[α, 2], Subscript[β, 2], Subscript[γ, 2]}, {Subscript[α, 3], Subscript[β, 3], Subscript[γ, 3]}};

Wolfram Language code:

pos1 = AnglePath3D[rots];
pos2 = AnglePath3D[rots, "Position"];

Wolfram Language code: pos1 === pos2

Show the same equivalence starting from an arbitrary point {a,b,c}:

Wolfram Language code:

pos1 = AnglePath3D[{a, b, c}, rots];
pos2 = AnglePath3D[{a, b, c}, rots, "Position"];

Wolfram Language code: pos1 === pos2

Compute the orientation of each local frame with respect to the previous local frame:

Wolfram Language code: AnglePath3D[{{π / 3, 0}, {π / 2, -2π / 3}}, "EulerMatrix"];

Wolfram Language code: Map[MatrixForm, %]

Compute the orientation of each local frame with respect to the global frame:

Wolfram Language code: AnglePath3D[{{π / 3, 0}, {π / 2, -2π / 3}}, "FrameMatrix"];

Wolfram Language code: Map[MatrixForm, %]

Compute the Euler angles determining the orientation of each local frame in the global frame:

Wolfram Language code: AnglePath3D[{{π / 3, 0}, {π / 2, -2π / 3}}, "FrameAngles"]

Generate translation transformations from the initial position:

Wolfram Language code: translations = AnglePath3D[{{4, {π / 2, 0}}, {8, {0, -π / 2}}}, "Translation"]

Apply them to an ellipsoid:

Wolfram Language code:

ellipsoid = Ellipsoid[{0, 0, 0}, {1, 2, 3}];
Graphics3D[GeometricTransformation[ellipsoid, translations]]

Generate rotation transformations with respect to the initial frame:

Wolfram Language code: rotations = AnglePath3D[{{4, {π / 2, 0}}, {8, {0, -π / 2}}}, "Rotation"]

Apply them to an ellipsoid:

Wolfram Language code:

ellipsoid = Ellipsoid[{0, 0, 0}, {1, 2, 3}];
Graphics3D[GeometricTransformation[ellipsoid, rotations]]

Generate rotation-translation transformations from the initial step:

Wolfram Language code: transformations = AnglePath3D[{{4, {π / 2, 0}}, {8, {0, -π / 2}}}, "RotationTranslation"]

Apply them to an ellipsoid:

Wolfram Language code:

ellipsoid = Ellipsoid[{0, 0, 0}, {1, 2, 3}];
Graphics3D[GeometricTransformation[ellipsoid, transformations]]

Produce different forms of data with one AnglePath3D call:

Wolfram Language code:

forms = {"EulerMatrix", "Position", "RotationTranslation"};
path = AnglePath3D[{{π / 2, 0}, {0, -π / 2}}, forms];

The first elements of the triples are the Euler rotations with respect to the previous frame:

Wolfram Language code: Map[MatrixForm, path[[All, 1]]]

The second elements are the positions:

Wolfram Language code: path[[All, 2]]

The third elements are the transformations from the initial frame:

Wolfram Language code: path[[All, 3]]

Options (1)

WorkingPrecision (1)

By default, AnglePath3D with exact input gives exact numbers for short paths and machine numbers for long paths:

Wolfram Language code: AnglePath3D[Table[{Pi / 3, 0, 0}, 7]]//Last

Wolfram Language code: AnglePath3D[Table[{Pi / 3, 0, 0}, 5004]]//Last

Specify infinite working precision to perform exact, but slower, computations:

Wolfram Language code: AnglePath3D[Table[{Pi / 3, 0, 0}, 5004], WorkingPrecision -> Infinity]//Last

Use any specified precision for the computations:

Wolfram Language code: AnglePath3D[Table[{Pi / 3, 0, 0}, 7], WorkingPrecision -> 20]//Last

Applications (7)

Path Visualization of a Pointlike Object (5)

Draw a hexagon in the - plane:

Wolfram Language code: pos = AnglePath3D[ConstantArray[{0, π / 3, 0}, 6]];

Wolfram Language code:

Graphics3D[Line[pos], 
	Axes -> True, AxesLabel -> {"X", "Y", "Z"}, Ticks -> None]

Draw an octagon in the - plane:

Wolfram Language code: pos = AnglePath3D[{{π / 2, 0, 0}}, ConstantArray[{0, π / 4, 0}, 8]];

Wolfram Language code:

Graphics3D[Line[pos], 
	Axes -> True, AxesLabel -> {"X", "Y", "Z"}, Ticks -> None]

Visit all vertices of a cube once:

Wolfram Language code:

rotα = {π / 2, 0};
rotβ = {0, π / 2};
pos = AnglePath3D[{rotα, rotα, rotα, rotβ, rotβ, rotα, rotα}];

Wolfram Language code: edges = Graphics3D[{FaceForm[], EdgeForm[Dotted], Cuboid@@CoordinateBoundingBox[pos]}, Boxed -> False]

Wolfram Language code: travel = Graphics3D[{Arrowheads[{{.05, .5}}], Arrow /@ Subsequences[pos, {2}], PointSize[Large], Red, Point[pos]}];

Wolfram Language code: Show[edges, travel]

Draw a three-dimensional spiral:

Wolfram Language code:

r = Rest@Subdivide[70];
angles = ConstantArray[{π / 12, 0, -π / 24}, 70];
pos = AnglePath3D[N@{r, angles}];

Wolfram Language code: Graphics3D[Arrow[pos]]

Make a random walk where successive steps change direction by at most 20° in any Euler angles:

Wolfram Language code: Graphics3D[Line@AnglePath3D[RandomReal[{-20°, 20°}, {1000, 3}]]]

Make a random walk where successive steps change direction by Euler angles between 0 and :

Wolfram Language code: Graphics3D[Line@AnglePath3D[RandomReal[{0, π}, {10000, 3}]]]

Path Visualization of a Rigid Body (2)

Visualize the orientation of a rigid body after successive rotations about a same axis:

Wolfram Language code:

shuttle = GeometricTransformation[ExampleData[{"Geometry3D", "SpaceShuttle"}, "GraphicsComplex"], RotationMatrix[π, {0, 0, 1}].ScalingMatrix[{.05, .05, .05}]];

Wolfram Language code: Graphics3D[shuttle, Boxed -> False]

About the axis:

Wolfram Language code: pathzaxis = AnglePath3D[{{90°, 0, 0}, {90°, 0, 0}, {90°, 0, 0}}, "RotationTranslation"];

Wolfram Language code: Graphics3D[GeometricTransformation[shuttle, pathzaxis], Boxed -> False]

Generate the position reached at each step at the same time:

Wolfram Language code: path = AnglePath3D[{{90°, 0, 0}, {90°, 0, 0}, {90°, 0, 0}}, {"Position", "RotationTranslation"}];

Wolfram Language code:

graphics[path_] := Graphics3D[{Dotted, Line[path[[All, 1]]], GeometricTransformation[shuttle, path[[All, 2]]]}, Boxed -> False];

Wolfram Language code: graphics[path]

About the axis:

Wolfram Language code: pathyaxis = AnglePath3D[{{0, 90°, 0}, {0, 90°, 0}, {0, 90°, 0}}, {"Position", "RotationTranslation"}];

Wolfram Language code: graphics[pathyaxis]

About the axis:

Wolfram Language code: pathxaxis = AnglePath3D[{{0, 0, 90°}, {0, 0, 90°}, {0, 0, 90°}}, {"Position", "RotationTranslation"}];

Wolfram Language code: graphics[pathxaxis]

Fly to all vertices of a cube once:

Wolfram Language code:

rotα = {π / 2, 0};
rotβ = {0, π / 2};

Wolfram Language code:

pathA = AnglePath3D[{rotα, rotα, rotα, rotβ, rotβ, rotα, rotα}, {"Position", "RotationTranslation"}];
positions = pathA[[All, 1]];
transformations = pathA[[All, 2]];

Wolfram Language code: edges = Graphics3D[{FaceForm[], EdgeForm[Dotted], Cuboid@@CoordinateBoundingBox[positions]}, Boxed -> False];

Wolfram Language code:

shuttle = GeometricTransformation[ExampleData[{"Geometry3D", "SpaceShuttle"}, "GraphicsComplex"], RotationMatrix[π, {0, 0, 1}].ScalingMatrix[{.03, .03, .03}]];

Wolfram Language code:

travelA = 
	Graphics3D[{Arrowheads[{{.03, .5}}], Arrow /@ Subsequences[positions, {2}], GeometricTransformation[shuttle, transformations]}, Boxed -> False];

Wolfram Language code: Show[edges, travelA]

Follow the same directions but with different orientations:

Wolfram Language code:

rotαβ = {π, π / 2};
pathB = AnglePath3D[{rotα, rotα, rotα, rotαβ, -rotβ, -rotα, -rotα}, {"Position", "RotationTranslation"}];

Wolfram Language code:

positions = pathB[[All, 1]];
transformations = pathB[[All, 2]];

Wolfram Language code:

travelB = Graphics3D[{Arrowheads[{{.03, .5}}], Arrow /@ Subsequences[positions, {2}], GeometricTransformation[shuttle, transformations]}];

Wolfram Language code: Show[edges, travelB]

Properties & Relations (7)

AnglePath3D[{{θ₁,0,0},{θ₂,0,0},…}] returns a path in the - plane:

Wolfram Language code: path3D = AnglePath3D[{{Subscript[θ, 1], 0, 0}, {Subscript[θ, 2], 0, 0}}]

Wolfram Language code: path3D[[All, 3]]

The generated path is equivalent to that of AnglePath[{θ₁,θ₂,…}]:

Wolfram Language code: Simplify[path3D[[All, {1, 2}]] - AnglePath[{Subscript[θ, 1], Subscript[θ, 2]}]]

Paths start at point {0,0,0} by default:

Wolfram Language code: angles = RandomReal[{-Pi, Pi}, {4, 3}]

Wolfram Language code: path0 = AnglePath3D[angles, "Position"]

Specify an alternative initial point:

Wolfram Language code: path = AnglePath3D[{1, 3, -2}, angles, "Position"]

Then all points are shifted by the vector corresponding to the initial point:

Wolfram Language code: path - path0

Specifying Euler angles is equivalent to specifying -- Euler matrices:

Wolfram Language code:

eulerangles = {{Subscript[α, 1], Subscript[β, 1], Subscript[γ, 1]}, {Subscript[α, 2], Subscript[β, 2], Subscript[γ, 2]}, {Subscript[α, 3], Subscript[β, 3], Subscript[γ, 3]}};
eulermatrices = EulerMatrix[#, {3, 2, 1}]& /@ eulerangles;

Wolfram Language code: AnglePath3D[eulerangles] === AnglePath3D[eulermatrices]

Specifying initial Euler angles is equivalent to specifying an initial -- Euler matrix:

Wolfram Language code:

initialangles = {Subscript[α, 0], Subscript[β, 0], Subscript[γ, 0]};
initialmatrix = EulerMatrix[initialangles, {3, 2, 1}];

Wolfram Language code:

angles = {{Subscript[α, 1], Subscript[β, 1], Subscript[γ, 1]}, {Subscript[α, 2], Subscript[β, 2], Subscript[γ, 2]}, {Subscript[α, 3], Subscript[β, 3], Subscript[γ, 3]}};

Wolfram Language code: AnglePath3D[{initialangles}, angles] === AnglePath3D[{initialmatrix}, angles]

Take a collection of random rotation matrices and compute the corresponding angle path:

Wolfram Language code: rots = EulerMatrix /@ RandomReal[{-Pi, Pi}, {4, 3}]

Wolfram Language code: path = AnglePath3D[{0, 0, 0}, rots]

This formula computes the rotations that produce the same path but traversed in opposite order:

Wolfram Language code: irots = Prepend[Reverse[Inverse /@ Rest[rots]], -Fold[Dot, rots]]

Wolfram Language code: ipath = AnglePath3D[Last[path], irots]

Check that the paths are identical if one of them is reversed, except for numerical error:

Wolfram Language code: Reverse[path] - ipath//Chop

Global frame rotations can be obtained as multiplications of all previous relative Euler rotations:

Wolfram Language code: angles = N@{{π / 3, 0}, {π / 2, -π / 6}};

Wolfram Language code:

framematrices = AnglePath3D[angles, "FrameMatrix"];
Map[MatrixForm, %]

Wolfram Language code: framematrices == FoldList[#1.#2&, AnglePath3D[angles, "EulerMatrix"]]

Compute the positions for a path with the following inputs:

Wolfram Language code:

p0 = {x0, y0, z0};
angles = {{Subscript[α, 1], Subscript[β, 1], Subscript[γ, 1]}, {Subscript[α, 2], Subscript[β, 2], Subscript[γ, 2]}, {Subscript[α, 3], Subscript[β, 3], Subscript[γ, 3]}};

Wolfram Language code: positions = AnglePath3D[p0, angles];

An alternative way to compute these positions is using the form "FrameMatrix":

Wolfram Language code: framematrices = AnglePath3D[angles, "FrameMatrix"];

Wolfram Language code: positions == FoldList[#1 + #2.{1, 0, 0}&, p0, Rest[framematrices]]

Interactive Examples (1)

Interactively chart a path for the space shuttle:

Wolfram Language code:

DynamicModule[{shuttle, lengths = {}, angles = {}, path, points}, 
	shuttle = GeometricTransformation[ExampleData[{"Geometry3D", "SpaceShuttle"}, "GraphicsComplex"], RotationMatrix[π, {0, 0, 1}].ScalingMatrix[{.1, .1, .1}]];
	Manipulate[
	path = AnglePath3D[{lengths, angles}, {"Position", "FrameMatrix"}];
	points = path[[All, 1]];
	Graphics3D[{
	Line[points], GeometricTransformation[shuttle, AffineTransform[{path[[-1, 2]].EulerMatrix[{α, β, γ}, {3, 2, 1}], Last[points]}]], 
	Point[points], White, Point[{{-3, -3, -3}, {3, 3, 3}}]}, 
	Axes  -> True, 
	PlotRange -> All, 
	ImageSize -> {420, 420}
	], 
	Row[{Control[{{r, 1}, 0, 10}], Spacer[24], Control[{{fixr, True, "Fixed"}, {True, False}}]}], 
	Row[{Control[{{α, 0}, -Pi, Pi}], Spacer[20], Control[{{fixα, False, "Fixed"}, {True, False}}]}], 
	Row[{Control[{{β, 0}, -Pi / 2, Pi / 2}], Spacer[21], Control[{{fixβ, False, "Fixed"}, {True, False}}]}], 
	Row[{Control[{{γ, 0}, -Pi, Pi}], Spacer[21], Control[{{fixγ, False, "Fixed"}, {True, False}}]}], 
	Button["Next step", AppendTo[lengths, r];AppendTo[angles, {α, β, γ}];{If[Not[fixr], r = 1.], If[Not[fixα], α = 0.], If[Not[fixβ], β = 0.], If[Not[fixγ], γ = 0.]}], 
	Button["Restart", {lengths = {}, angles = {}, r = 1., α = 0., β = 0., γ = 0.}]
	]
	]

Neat Examples (3)

Draw a space curve with incrementally increasing and constant :

Wolfram Language code:

alphas = Range[0, 20, .001];
betas = ConstantArray[0.01, Length[alphas]];

Wolfram Language code: Graphics3D[Line@AnglePath3D[Transpose[{alphas, betas}]], Boxed -> False]

Draw a space curve with incrementally increasing and constant and :

Wolfram Language code:

alphas = Range[0, 20, .001];
betas = ConstantArray[0.01, Length[alphas]];
gammas = ConstantArray[0.01, Length[alphas]];

Wolfram Language code: Graphics3D[Line@AnglePath3D[Transpose[{alphas, betas, gammas}]], Boxed -> False]

Animate a shuttle looping in the - plane:

Wolfram Language code:

DynamicModule[{shuttle, path}, 
	shuttle = GeometricTransformation[
	ExampleData[{"Geometry3D", "SpaceShuttle"}, "GraphicsComplex"], 
	RotationMatrix[π, {0, 0, 1}]];
	path = AnglePath3D[N@ConstantArray[{0, -π / 100}, 200], {"Position", "RotationTranslation"}];
	Animate[
	Graphics3D[{
	Line[path[[All, 1]]], 
	GeometricTransformation[shuttle, path[[i, 2]]]
	}, 
	ImageSize -> 350, 
	Boxed -> False, 
	PlotRange -> {{-35, 35}, {-5, 5}, {-5, 65}}
	], 
	{{i, 1, "step"}, 1, Length[path], 1}, 
	AnimationRunning -> False, SaveDefinitions -> True
	]
	]

Top

More Learning

Tech Support

Wolfram Solutions

Wolfram Solutions For Education

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

AnglePath3D

Details and Options

Examples

Basic Examples (6)

Scope (22)

Steps Specification (7)

Path Initialization (7)

Forms of Data (8)

Options (1)

WorkingPrecision (1)

Applications (7)

Path Visualization of a Pointlike Object (5)

Path Visualization of a Rigid Body (2)

Properties & Relations (7)

Interactive Examples (1)

Neat Examples (3)

Text

CMS

APA

BibTeX

BibLaTeX

AnglePath3D

Details and Options

Examples

Basic Examples (6)

Scope (22)

Steps Specification (7)

Path Initialization (7)

Forms of Data (8)

Options (1)

WorkingPrecision (1)

Applications (7)

Path Visualization of a Pointlike Object (5)

Path Visualization of a Rigid Body (2)

Properties & Relations (7)

Interactive Examples (1)

Neat Examples (3)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX