Math & Geometry Types

Vec3

class dazpy.Vec3(x, y, z)

Bases: object

Immutable 3-component vector.

All arithmetic operators return new Vec3 instances.

Parameters:

• x (float) – X component.

• y (float) – Y component.

• z (float) – Z component.

classmethod from_dict(d)

Create from an {"x", "y", "z"} dict (e.g. from position).

classmethod from_list(v)

Create from a [x, y, z] list (e.g. a vertex from vertex_positions_all()).

classmethod zero()

Return the zero vector (0, 0, 0).

to_dict()

Return {"x": float, "y": float, "z": float}.

to_list()

Return [x, y, z].

dot(other)

Dot product.

cross(other)

Cross product (right-hand rule).

length_sq()

Squared length (avoids a sqrt).

length()

Euclidean length.

normalize()

Return a unit-length copy. Returns the zero vector unchanged.

distance_sq(other)

Squared distance to other.

distance(other)

Euclidean distance to other.

lerp(other, t)

Linearly interpolate toward other. t=0 → self, t=1 → other.

reflect(normal)

Reflect this vector about normal (normal must be unit length).

x

y

z

Quat

class dazpy.Quat(x, y, z, w)

Bases: object

Unit quaternion representing a 3D rotation.

Stored as (x, y, z, w) — imaginary components first, scalar last. This matches the dict format returned by the dazpy API (DazNode.rotation, DazBone.local_rotation).

All methods return new Quat instances. The object is immutable.

Parameters:

• x (float) – i component.

• y (float) – j component.

• z (float) – k component.

• w (float) – Scalar component.

classmethod identity()

Return the identity quaternion (0, 0, 0, 1) (no rotation).

classmethod from_dict(d)

Create from an {"x", "y", "z", "w"} dict (e.g. from rotation).

classmethod from_euler(x, y, z, order='XYZ')

Create from Euler angles in degrees using intrinsic rotations.

Intrinsic means each rotation is applied in the frame left by the previous rotation — the same convention DAZ Studio uses for bone rotation channels.

Parameters:

• x (float) – Rotation around the X axis in degrees.

• y (float) – Rotation around the Y axis in degrees.

• z (float) – Rotation around the Z axis in degrees.

• order (str) – Application order — one of XYZ, XZY, YXZ, YZX, ZXY, ZYX. Matches rotation_order.

Returns:

A unit quaternion.

Return type:

Quat

classmethod from_axis_angle(axis, angle_deg)

Create from an axis and angle in degrees.

Parameters:

• axis (Vec3) – Rotation axis (need not be unit length — normalised internally).

• angle_deg (float) – Rotation magnitude in degrees.

Returns:

A unit quaternion.

Return type:

Quat

to_dict()

Return {"x": float, "y": float, "z": float, "w": float}.

to_matrix()

Return the equivalent 3×3 rotation matrix (row-major, right-handed).

to_euler(order='XYZ')

Extract Euler angles in degrees.

The inverse of from_euler() for the same order. Gimbal-lock configurations (singularities) are handled by setting the last rotation in the order to zero.

Parameters:

order (str) – One of XYZ, XZY, YXZ, YZX, ZXY, ZYX.

Returns:

(x, y, z) in degrees.

Return type:

tuple[float, float, float]

multiply(other)

Hamilton product self * other.

Composing rotations: a.multiply(b) applies a first, then b in the rotated frame (intrinsic), or equivalently b first then a in the world frame (extrinsic).

conjugate()

Return the conjugate (-x, -y, -z, w).

length()

Quaternion norm.

normalize()

Return a unit-length copy.

dot(other)

4D dot product (used internally by slerp()).

rotate(v)

Rotate vector v by this quaternion.

Uses the sandwich product q * v * q⁻¹.

slerp(other, t)

Spherical linear interpolation.

Always takes the shortest arc between the two orientations.

Parameters:

• other (Quat) – Target rotation (t=1.0 produces an exact copy of other).

• t (float) – Blend factor in [0, 1].

Returns:

A unit quaternion at the interpolated orientation.

Return type:

Quat

x

y

z

w

BoundingBox

class dazpy.BoundingBox(min, max)

Bases: object

Axis-aligned bounding box.

Parameters:

• min (Vec3) – Corner with the smallest coordinates.

• max (Vec3) – Corner with the largest coordinates.

classmethod from_dict(d)

Create from the dict returned by bounding_box().

Expected shape: {"min": {"x":..., "y":..., "z":...}, "max": {...}}.

classmethod from_points(points)

Compute the tight bounding box around a list of Vec3 points.

to_dict()

Return {"min": {...}, "max": {...}}.

property center: Vec3

Geometric center of the box.

property size: Vec3

Width, height, and depth as a Vec3.

property volume: float

Signed volume (positive for valid boxes where min ≤ max on all axes).

contains(point)

Return True if point is inside or on the surface of the box.

overlaps(other)

Return True if this box and other share any volume.

expand(amount)

Return a box uniformly expanded by amount on all sides.

union(other)

Return the smallest box that contains both this box and other.

min

max

AxisRemap

class dazpy.AxisRemap(x, y, z)

Bases: object

Converts Vec3, Quat, and BoundingBox values between axis conventions (e.g. Y-up to Z-up).

A generic signed-axis-permutation remap — no application-specific knowledge (Blender/Unreal naming, camera or figure orientation fixups) is baked in beyond the Y_UP_TO_Z_UP preset.

Each of x, y, z names which source axis (optionally signed) the corresponding output axis is derived from. All three of the source axes x, y, z must be referenced exactly once (signs aside).

Example:

# DAZ Studio (Y-up) -> Blender-style Z-up
remap = AxisRemap(x="x", y="-z", z="y")
blender_pos = remap.apply_vec3(daz_pos)

Parameters:

• x (str) – Source axis for the output X component, e.g. "x" or "-z".

• y (str) – Source axis for the output Y component.

• z (str) – Source axis for the output Z component.

apply_vec3(v)

Remap a vector or point. Works for any remap, proper or reflective.

apply_quat(q)

Remap a rotation.

Raises:

ValueError – If this remap is a reflection (determinant -1). Reflections cannot be represented by a quaternion; use apply_vec3() for vectors/points instead.

apply_bbox(b)

Remap a bounding box.

Both corners are remapped and the result is re-sorted per axis, since a sign-flipping remap can swap which corner is the minimum on a given axis.

dazpy.Y_UP_TO_Z_UP = AxisRemap(x='x', y='-z', z='y')

Converts Vec3, Quat, and BoundingBox values between axis conventions (e.g. Y-up to Z-up).

A generic signed-axis-permutation remap — no application-specific knowledge (Blender/Unreal naming, camera or figure orientation fixups) is baked in beyond the Y_UP_TO_Z_UP preset.

Each of x, y, z names which source axis (optionally signed) the corresponding output axis is derived from. All three of the source axes x, y, z must be referenced exactly once (signs aside).

Example:

# DAZ Studio (Y-up) -> Blender-style Z-up
remap = AxisRemap(x="x", y="-z", z="y")
blender_pos = remap.apply_vec3(daz_pos)

Parameters:

• x – Source axis for the output X component, e.g. "x" or "-z".

• y – Source axis for the output Y component.

• z – Source axis for the output Z component.