Common¶

Bases: BaseModel

Shared base for the config area models: arbitrary_types_allowed plus use_attribute_docstrings.

Bases: Live

Context manager showing a live elapsed-time line for one pipeline step.

Parameters:

• title (str) –

  The step name.

• msg (str, default: '' ) –

  A status message shown after the step name.

• console (Console | None, default: None ) –

  The console to render on; None uses the shared one.

57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

def __init__(self, title: str, msg: str = "", console: Console | None = None) -> None:
    """Prepare the live line for one step.

    Args:
        title: The step name.
        msg: A status message shown after the step name.
        console: The console to render on; None uses the shared one.
    """
    self._timer_renderable = TimerRenderable(title, msg)
    super().__init__(
        self._timer_renderable,
        console=console if console is not None else get_console(),
        refresh_per_second=4,
        auto_refresh=True,
    )

Bases: RichCast

Live-updating timer row; Rich calls __rich__ on every refresh tick.

Methods:

• elapsed –

  Seconds since the timer started.

• elapsed_str –

  The elapsed time as fmt_time formats it.

31
32
33
34
35
36

def __init__(self, title: str, msg: str) -> None:
    """Start timing the step ``title``, shown with the status ``msg``."""
    self.title = title
    self.message = msg
    self.start_time = time.time()
    self.completed = False

elapsed() -> float

38
39
40

def elapsed(self) -> float:
    """Seconds since the timer started."""
    return time.time() - self.start_time

elapsed_str() -> str

42
43
44

def elapsed_str(self) -> str:
    """The elapsed time as [`fmt_time`][femforge.common.progress.fmt_time] formats it."""
    return fmt_time(self.elapsed())

Bases: Protocol

Something that emits its own Elmer sif keywords; materials, conditions, and boundaries all satisfy it.

Methods:

• to_elmer –

  This object's Elmer sif keywords.

to_elmer(**ctx: object) -> dict[str, object]

12
13
14

def to_elmer(self, **ctx: object) -> dict[str, object]:
    """This object's Elmer sif keywords."""
    ...

Bases: Protocol

Something that resolves to one or more gmsh physical groups.

Methods:

• physical_group_name –

  The stable group name the Elmer side references the region by.

physical_group_name() -> str

21
22
23

def physical_group_name(self) -> str:
    """The stable group name the Elmer side references the region by."""
    ...

Annotated metadata marker tying a model field to an external key name.

Example: Annotated[bool, Map("Geometry.OCCImportLabels"), Field(...)] -- the gmsh option name lives on the field.

16
17
18

def __init__(self, map: str) -> None:
    """Tie the field to the external key ``map``."""
    self.map = map

Loguru sink callable; add with format="{message}" and colorize=False so Rich owns all styling.

Parameters:

• console (Console | None, default: None ) –

  The console to print to; None prints to a new stderr console.

• time_format (str, default: '%H:%M:%S.%f' ) –

  The strftime format of the time column.

• show_path (bool, default: True ) –

  Show the module:function column.

• path_width (int, default: 0 ) –

  Truncate the location column to this width, keeping its tail; 0 sizes it to its content.

• rich_tracebacks (bool, default: True ) –

  Render a logged exception as a Rich traceback.

• show_locals (bool, default: False ) –

  Include local variables in Rich tracebacks.

• markup (bool, default: False ) –

  Parse Rich markup in messages.

• hide_keys (frozenset[str], default: frozenset() ) –

  The bound extra keys to leave out of the context column.

44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

def __init__(
    self,
    console: Console | None = None,
    *,
    time_format: str = "%H:%M:%S.%f",
    show_path: bool = True,
    path_width: int = 0,
    rich_tracebacks: bool = True,
    show_locals: bool = False,
    markup: bool = False,
    hide_keys: frozenset[str] = frozenset(),
) -> None:
    """Configure the sink's columns and styling.

    Args:
        console: The console to print to; None prints to a new stderr console.
        time_format: The ``strftime`` format of the time column.
        show_path: Show the ``module:function`` column.
        path_width: Truncate the location column to this width, keeping its tail; 0 sizes it to its content.
        rich_tracebacks: Render a logged exception as a Rich traceback.
        show_locals: Include local variables in Rich tracebacks.
        markup: Parse Rich markup in messages.
        hide_keys: The bound ``extra`` keys to leave out of the context column.
    """
    self.console = console if console is not None else Console(stderr=True)
    self.time_format = time_format
    self.show_path = show_path
    self.path_width = path_width
    self.rich_tracebacks = rich_tracebacks
    self.show_locals = show_locals
    self.markup = markup
    self.hide_keys = hide_keys

Bases: StrEnum

Values of TagKey.CURRENT_DIR: whether an electrode part is a current entry or exit.

Attributes:

• ENTRY –

  The electrode where current enters.

• EXIT –

  The electrode where current leaves.

ENTRY = 'Entry'

EXIT = 'Exit'

A mixin that holds an object's tag key=value pairs.

Methods:

• set_tag –

  Set key to the cleaned value.

• add_tag –

  Set key to the cleaned value, like set_tag.

• get_tag –

  The value of key, or default when it is unset.

• get_tags –

  A copy of the tags, or of only keys with an unset key as an empty string.

• get_key_string –

  Return a string representation of the tags for the given keys.

• remove_tag –

  Drop key when it is set.

• clear_tags –

  Drop every tag.

• set_tags –

  Replace every tag with tags, each value cleaned.

• tags_str –

  The tags as comma-separated key=value pairs.

Attributes:

• current_tags (TagDict) –

  A copy of the tags.

91
92
93

def __init__(self, tags: TagDict | None = None):
    """Start with ``tags``, each value cleaned, or with none."""
    self.tags: TagDict = {key: clean_tag(key, value) for key, value in tags.items()} if tags is not None else {}

current_tags: TagDict

set_tag(key: str, value: str)

95
96
97

def set_tag(self, key: str, value: str):
    """Set ``key`` to the cleaned ``value``."""
    self.tags[key] = clean_tag(key, value)

add_tag(key: str, value: str)

 99
100
101

def add_tag(self, key: str, value: str):
    """Set ``key`` to the cleaned ``value``, like ``set_tag``."""
    self.set_tag(key, value)

get_tag(key: str, default: str | None = None) -> str | None

103
104
105

def get_tag(self, key: str, default: str | None = None) -> str | None:
    """The value of ``key``, or ``default`` when it is unset."""
    return self.tags.get(key, default)

get_tags(keys: list[str] | None = None) -> TagDict

107
108
109
110
111

def get_tags(self, keys: list[str] | None = None) -> TagDict:
    """A copy of the tags, or of only ``keys`` with an unset key as an empty string."""
    if keys is None:
        return self.tags.copy()
    return {key: self.tags.get(key, "") for key in keys}

get_key_string(keys: list[str], default: str = 'default') -> str

113
114
115

def get_key_string(self, keys: list[str], default: str = "default") -> str:
    """Return a string representation of the tags for the given keys."""
    return "_".join([f"{key} {value}" for key, value in self.get_tags(keys).items()]) or default

remove_tag(key: str)

122
123
124
125

def remove_tag(self, key: str):
    """Drop ``key`` when it is set."""
    if key in self.tags:
        del self.tags[key]

clear_tags()

127
128
129

def clear_tags(self):
    """Drop every tag."""
    self.tags.clear()

set_tags(tags: TagDict)

131
132
133

def set_tags(self, tags: TagDict):
    """Replace every tag with ``tags``, each value cleaned."""
    self.tags = {key: clean_tag(key, value) for key, value in tags.items()}

tags_str() -> str

135
136
137

def tags_str(self) -> str:
    """The tags as comma-separated ``key=value`` pairs."""
    return ", ".join([f"{key}={value}" for key, value in self.tags.items()])

Bases: HasTags, list[T]

A list of tagged items or nested groups that carries its own tags.

Methods:

• flatten –

  Roll the hierarchy up into a flat list of leaves, merging each path's tags onto the item (its own tags win only for keys the hierarchy doesn't set). Mutates .tags in place.

• tree –

  Return a tree representation of the tag group.

146
147
148
149

def __init__(self, tags: TagDict, items: Iterable[T] = ()) -> None:
    """Hold ``items`` under ``tags``."""
    list.__init__(self, items)
    HasTags.__init__(self, tags)

flatten() -> list[X]

154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174

def flatten[X: HasTags](self: "TagGroup[X | TagGroup[Any]]") -> list[X]:
    """Roll the hierarchy up into a flat list of leaves, merging each path's tags onto the item (its own tags win only for keys the hierarchy doesn't set). Mutates `.tags` in place."""
    out: list[X] = []

    def visit(node: object, inherited: TagDict) -> None:
        if isinstance(node, TagGroup):
            merged = {**inherited, **node.tags}
            for child in node:
                visit(child, merged)
        else:
            item = cast(X, node)

            item.tags = {**item.tags, **inherited}

            if isinstance(getattr(item, "label", None), str):
                setattr(item, "label", item.tags_str())

            out.append(item)

    visit(self, {})
    return out

tree(parent: Tree | None = None) -> Tree

176
177
178
179
180
181
182
183
184
185
186
187
188

def tree(self, parent: Tree | None = None) -> Tree:
    """Return a tree representation of the tag group."""
    # Tree.add(label) creates-and-appends a child node from a label; passing a Tree object would nest it as a label, not a child.
    label = self.tags_str()
    node = parent.add(label) if parent is not None else Tree(label=label)

    for item in self:
        if isinstance(item, TagGroup):
            item.tree(parent=node)
        else:
            node.add(str(item))

    return node

Bases: HasTags

Groups tagged items into a TagGroup hierarchy, one level per list of tag keys.

Methods:

• then_by –

  A grouper with keys added as the next level.

• apply –

  Group items into a single root TagGroup (root has empty tags).

• map –

  Group items and transform each leaf with fn.

• map_groups –

  Group items and collapse each deepest bucket of leaves with fn.

250
251
252
253

def __init__(self, keys: list[str] | str | None = None, *, _levels: Levels | None = None) -> None:
    """Group by ``keys`` at the first level."""
    super().__init__()
    self._levels: Levels = _levels if _levels is not None else [_normalize(keys)]

then_by(keys: list[str] | str) -> TagGrouper

255
256
257

def then_by(self, keys: list[str] | str) -> "TagGrouper":
    """A grouper with ``keys`` added as the next level."""
    return TagGrouper(_levels=[*self._levels, _normalize(keys)])

apply(items: list[X]) -> TagGroup[Nested[X]]

259
260
261

def apply[X: HasTags](self, items: list[X]) -> TagGroup[Nested[X]]:
    """Group items into a single root TagGroup (root has empty tags)."""
    return TagGroup({}, _group_levels(items, self._levels))

map(items: list[X], fn: Callable[[X], Y]) -> TagGroup[Nested[Y]]

263
264
265

def map[X: HasTags, Y](self, items: list[X], fn: Callable[[X], Y]) -> TagGroup[Nested[Y]]:
    """Group ``items`` and transform each leaf with ``fn``."""
    return map_leaves(self.apply(items), fn)

map_groups(items: list[X], fn: Callable[[list[X]], Y]) -> TagGroup[Nested[Y]]

267
268
269

def map_groups[X: HasTags, Y](self, items: list[X], fn: Callable[[list[X]], Y]) -> TagGroup[Nested[Y]]:
    """Group ``items`` and collapse each deepest bucket of leaves with ``fn``."""
    return map_group_leaves(self.apply(items), fn)

Bases: StrEnum

The shared tag-key vocabulary: geometry authors these on parts, meshing/FEA select by them.

Attributes:

• MATERIAL –

  The registry tag of the body's material.

• PHASE –

  The winding phase a conductor belongs to.

• CURRENT_DIR –

  Whether an electrode is a current entry or exit, a CurrentDir value.

• SEGMENT –

  The winding segment a conductor belongs to.

• LAYER –

  The layer a conductor lies on, such as a PCB copper layer.

• TYPE –

  The kind of part, such as Trace or Via.

• MAGNETIZATION –

  A magnet's magnetization label, such as N or S.

• SLOT –

  The pole or slot position a part occupies.

• NAME –

  The authored part name; when set it is the body's name everywhere (mesh group, Elmer body, entities.json, viewer).

MATERIAL = 'Material'

PHASE = 'Phase'

CURRENT_DIR = 'CurrentDir'

SEGMENT = 'Segment'

LAYER = 'Layer'

TYPE = 'Type'

MAGNETIZATION = 'Magnetization'

SLOT = 'Slot'

NAME = 'Name'

For use in rich console output. Not for physical materials.

Methods:

• gradient –

  Generate steps hex colors interpolating from start_color to end_color.

• Prop –

  Format a property name/value pair with colors for rich console output.

• PropName –

  A property name in the property-name style.

• PropValue –

  A property value in the property-value style.

• H1 –

  A top-level heading.

• H2 –

  A second-level heading.

• H3 –

  A third-level heading.

• Units –

  A unit label in the units style.

gradient(start_color: str, end_color: str, steps: int) -> list[str]

22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

@staticmethod
def gradient(start_color: str, end_color: str, steps: int) -> list[str]:
    """Generate ``steps`` hex colors interpolating from ``start_color`` to ``end_color``.

    Args:
        start_color: The first color, as ``#RRGGBB``.
        end_color: The last color, as ``#RRGGBB``.
        steps: How many colors to generate.
    """
    start_rgb = tuple(int(start_color[i : i + 2], 16) for i in (1, 3, 5))
    end_rgb = tuple(int(end_color[i : i + 2], 16) for i in (1, 3, 5))

    gradient_colors: list[str] = []
    for step in range(steps):
        ratio = step / max(steps - 1, 1)
        intermediate_rgb = tuple(int(start + (end - start) * ratio) for start, end in zip(start_rgb, end_rgb))
        gradient_colors.append("#{:02X}{:02X}{:02X}".format(*intermediate_rgb))

    return gradient_colors

Prop(name: str, value: str) -> Text

42
43
44
45
46
47
48

@staticmethod
def Prop(name: str, value: str) -> Text:
    """Format a property name/value pair with colors for rich console output."""
    if contains_rich_markup(value):
        return COLORS.PropName(name).append(Text(": ", style="bold")).append(preserve_and_format(value))

    return COLORS.PropName(name) + Text(": ", style="bold") + COLORS.PropValue(value)

PropName(name: str) -> Text

50
51
52
53

@staticmethod
def PropName(name: str) -> Text:
    """A property name in the property-name style."""
    return Text(name, style=COLORS.PROPERTY_NAME)

PropValue(value: str) -> Text

55
56
57
58

@staticmethod
def PropValue(value: str) -> Text:
    """A property value in the property-value style."""
    return Text(value, style=COLORS.PROPERTY_VALUE)

H1(text: str) -> Text

60
61
62
63

@staticmethod
def H1(text: str) -> Text:
    """A top-level heading."""
    return Text(text, style=COLORS.HEADER_1 + " bold")

H2(text: str) -> Text

65
66
67
68

@staticmethod
def H2(text: str) -> Text:
    """A second-level heading."""
    return Text(text, style=COLORS.HEADER_2 + " bold")

H3(text: str) -> Text

70
71
72
73

@staticmethod
def H3(text: str) -> Text:
    """A third-level heading."""
    return Text(text, style=COLORS.HEADER_3 + " bold")

Units(text: str) -> Text

75
76
77
78

@staticmethod
def Units(text: str) -> Text:
    """A unit label in the units style."""
    return Text(text, style=COLORS.UNITS)

An axis-aligned 3D box spanned by its min and max corners.

Attributes:

• center (Vec3) –

  The midpoint; setting it moves the box.

• size (Vec3) –

  The edge lengths; setting them resizes the box about its center.

234
235
236
237

def __init__(self, min: Vec3, max: Vec3):
    """Span ``min`` to ``max``."""
    self.min = min
    self.max = max

center: Vec3

size: Vec3

A position and orientation that maps local coordinates to global ones.

Methods:

• transform_position –

  Transform a position from local to global coordinates

• inverse_transform_position –

  Transform a position from global to local coordinates

• transform_direction –

  Transform a direction vector (ignoring translation) from local to global coordinates

• inverse_transform_direction –

  Transform a direction vector (ignoring translation) from global to local coordinates

• __mul__ –

  Combine two coordinate frames by applying this transformation followed by the other

• __rmul__ –

  Allow left multiplication to combine coordinate frames

• __imul__ –

  In-place combination of coordinate frames

463
464
465
466

def __init__(self, origin: Vec3, orientation: Quaternion):
    """Place the frame at ``origin``, rotated by ``orientation``."""
    self.origin = origin
    self.orientation = orientation

transform_position(position: Vec3) -> Vec3

468
469
470
471

def transform_position(self, position: Vec3) -> Vec3:
    """Transform a position from local to global coordinates"""
    rotated_position = self.orientation.rotate_vector(position)
    return self.origin + rotated_position

inverse_transform_position(position: Vec3) -> Vec3

473
474
475
476
477

def inverse_transform_position(self, position: Vec3) -> Vec3:
    """Transform a position from global to local coordinates"""
    translated_position = position - self.origin
    inverse_orientation = self.orientation.conjugate()
    return inverse_orientation.rotate_vector(translated_position)

transform_direction(direction: Vec3) -> Vec3

479
480
481

def transform_direction(self, direction: Vec3) -> Vec3:
    """Transform a direction vector (ignoring translation) from local to global coordinates"""
    return self.orientation.rotate_vector(direction)

inverse_transform_direction(direction: Vec3) -> Vec3

483
484
485
486

def inverse_transform_direction(self, direction: Vec3) -> Vec3:
    """Transform a direction vector (ignoring translation) from global to local coordinates"""
    inverse_orientation = self.orientation.conjugate()
    return inverse_orientation.rotate_vector(direction)

__mul__(other: CoordinateFrame) -> CoordinateFrame

488
489
490
491
492

def __mul__(self, other: "CoordinateFrame") -> "CoordinateFrame":
    """Combine two coordinate frames by applying this transformation followed by the other"""
    new_origin = self.transform_position(other.origin)
    new_orientation = self.orientation * other.orientation
    return CoordinateFrame(new_origin, new_orientation)

__rmul__(other: CoordinateFrame) -> CoordinateFrame

494
495
496

def __rmul__(self, other: "CoordinateFrame") -> "CoordinateFrame":
    """Allow left multiplication to combine coordinate frames"""
    return self.__mul__(other)

__imul__(other: CoordinateFrame) -> CoordinateFrame

498
499
500
501
502
503

def __imul__(self, other: "CoordinateFrame") -> "CoordinateFrame":
    """In-place combination of coordinate frames"""
    combined = self * other
    self.origin = combined.origin
    self.orientation = combined.orientation
    return self

Bases: Vec3

A unit-length orientation, normalized and rounded on construction; arithmetic on it returns a plain Vec3.

Parameters:

• x (float) –

  The x component of any non-zero vector along the direction.

• y (float) –

  The y component.

• z (float) –

  The z component.

212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228

def __init__(self, x: float, y: float, z: float):
    """Normalize ``(x, y, z)`` to unit length and round it to ``DIRECTION_DIGITS`` places.

    Args:
        x: The x component of any non-zero vector along the direction.
        y: The y component.
        z: The z component.
    """
    magnitude: float = math.sqrt(x**2 + y**2 + z**2)

    if magnitude == 0:
        raise ValueError("A direction needs a non-zero vector.")

    # An already-rounded unit vector is kept as given, so a dump and reload cannot shift its last digit.
    scale: float = 1.0 if abs(magnitude - 1.0) <= DIRECTION_SLACK else magnitude
    unit: list[float] = [round(component / scale, DIRECTION_DIGITS) + 0.0 for component in (x, y, z)]
    super().__init__(*unit)

A rotation quaternion w + xi + yj + zk.

Parameters:

• w (float) –

  The scalar part.

• x (float) –

  The i component.

• y (float) –

  The j component.

• z (float) –

  The k component.

Methods:

• __mul__ –

  Hamilton product of two quaternions

• conjugate –

  Conjugate of the quaternion

• magnitude –

  The Euclidean norm of the quaternion.

• normalized –

  The unit quaternion with the same orientation; raises ValueError for a zero quaternion.

• rotate_vector –

  Rotate a vector by this quaternion

• to_rotation_matrix –

  Convert the quaternion to a 3x3 rotation matrix

• to_euler_angles –

  Convert the quaternion to Euler angles (yaw, pitch, roll) in degrees

• from_euler_angles –

  Create a quaternion from Euler angles in degrees.

• from_axis_angle –

  Create a quaternion from an axis and angle in degrees

• slerp –

  Spherical linear interpolation between two quaternions.

286
287
288
289
290
291
292
293
294
295
296
297
298

def __init__(self, w: float, x: float, y: float, z: float):
    """Set the components.

    Args:
        w: The scalar part.
        x: The i component.
        y: The j component.
        z: The k component.
    """
    self.w = w
    self.x = x
    self.y = y
    self.z = z

__mul__(other: Quaternion) -> Quaternion

300
301
302
303
304
305
306
307
308
309
310

def __mul__(self, other: "Quaternion") -> "Quaternion":
    """Hamilton product of two quaternions"""
    w1, x1, y1, z1 = self.w, self.x, self.y, self.z
    w2, x2, y2, z2 = other.w, other.x, other.y, other.z

    w = w1 * w2 - x1 * x2 - y1 * y2 - z1 * z2
    x = w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2
    y = w1 * y2 - x1 * z2 + y1 * w2 + z1 * x2
    z = w1 * z2 + x1 * y2 - y1 * x2 + z1 * w2

    return Quaternion(w, x, y, z)

conjugate() -> Quaternion

312
313
314

def conjugate(self) -> "Quaternion":
    """Conjugate of the quaternion"""
    return Quaternion(self.w, -self.x, -self.y, -self.z)

magnitude() -> float

316
317
318
319
320

def magnitude(self) -> float:
    """The Euclidean norm of the quaternion."""
    import math

    return math.sqrt(self.w**2 + self.x**2 + self.y**2 + self.z**2)

normalized() -> Quaternion

322
323
324
325
326
327

def normalized(self) -> "Quaternion":
    """The unit quaternion with the same orientation; raises ``ValueError`` for a zero quaternion."""
    mag = self.magnitude()
    if mag == 0:
        raise ValueError("Cannot normalize a zero-length quaternion")
    return Quaternion(self.w / mag, self.x / mag, self.y / mag, self.z / mag)

rotate_vector(vec: Vec3) -> Vec3

329
330
331
332
333

def rotate_vector(self, vec: Vec3) -> Vec3:
    """Rotate a vector by this quaternion"""
    q_vec = Quaternion(0, vec.x, vec.y, vec.z)
    rotated_q = self * q_vec * self.conjugate()
    return Vec3(rotated_q.x, rotated_q.y, rotated_q.z)

to_rotation_matrix() -> list[list[float]]

335
336
337
338
339
340
341
342
343

def to_rotation_matrix(self) -> list[list[float]]:
    """Convert the quaternion to a 3x3 rotation matrix"""
    w, x, y, z = self.w, self.x, self.y, self.z

    return [
        [1 - 2 * (y**2 + z**2), 2 * (x * y - z * w), 2 * (x * z + y * w)],
        [2 * (x * y + z * w), 1 - 2 * (x**2 + z**2), 2 * (y * z - x * w)],
        [2 * (x * z - y * w), 2 * (y * z + x * w), 1 - 2 * (x**2 + y**2)],
    ]

to_euler_angles() -> tuple[float, float, float]

345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366

def to_euler_angles(self) -> tuple[float, float, float]:
    """Convert the quaternion to Euler angles (yaw, pitch, roll) in degrees"""
    w, x, y, z = self.w, self.x, self.y, self.z

    # Yaw (Z-axis rotation)
    siny_cosp = 2 * (w * z + x * y)
    cosy_cosp = 1 - 2 * (y**2 + z**2)
    yaw = math.atan2(siny_cosp, cosy_cosp)

    # Pitch (Y-axis rotation)
    sinp = 2 * (w * y - z * x)
    if abs(sinp) >= 1:
        pitch = math.copysign(math.pi / 2, sinp)  # use 90 degrees if out of range
    else:
        pitch = math.asin(sinp)

    # Roll (X-axis rotation)
    sinr_cosp = 2 * (w * x + y * z)
    cosr_cosp = 1 - 2 * (x**2 + y**2)
    roll = math.atan2(sinr_cosp, cosr_cosp)

    return (math.degrees(yaw), math.degrees(pitch), math.degrees(roll))

from_euler_angles(yaw: float, pitch: float, roll: float)

368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393

@staticmethod
def from_euler_angles(yaw: float, pitch: float, roll: float):
    """Create a quaternion from Euler angles in degrees.

    Args:
        yaw: The rotation about Z, in degrees.
        pitch: The rotation about Y, in degrees.
        roll: The rotation about X, in degrees.
    """
    yaw_rad = math.radians(yaw)
    pitch_rad = math.radians(pitch)
    roll_rad = math.radians(roll)

    cy = math.cos(yaw_rad * 0.5)
    sy = math.sin(yaw_rad * 0.5)
    cp = math.cos(pitch_rad * 0.5)
    sp = math.sin(pitch_rad * 0.5)
    cr = math.cos(roll_rad * 0.5)
    sr = math.sin(roll_rad * 0.5)

    return Quaternion(
        w=cy * cp * cr + sy * sp * sr,
        x=cy * cp * sr - sy * sp * cr,
        y=cy * sp * cr + sy * cp * sr,
        z=sy * cp * cr - cy * sp * sr,
    ).normalized()