| import operator |
|
|
| import numpy as np |
| import numpy.core.umath_tests as ut |
|
|
| from visualization.Quaternions import Quaternions |
|
|
|
|
| class Animation: |
| """ |
| Animation is a numpy-like wrapper for animation data |
| |
| Animation data consists of several arrays consisting |
| of F frames and J joints. |
| |
| The animation is specified by |
| |
| rotations : (F, J) Quaternions | Joint Rotations |
| positions : (F, J, 3) ndarray | Joint Positions |
| |
| The base pose is specified by |
| |
| orients : (J) Quaternions | Joint Orientations |
| offsets : (J, 3) ndarray | Joint Offsets |
| |
| And the skeletal structure is specified by |
| |
| parents : (J) ndarray | Joint Parents |
| """ |
|
|
| def __init__(self, rotations, positions, orients, offsets, parents, names, frametime): |
|
|
| self.rotations = rotations |
| self.positions = positions |
| self.orients = orients |
| self.offsets = offsets |
| self.parents = parents |
| self.names = names |
| self.frametime = frametime |
|
|
| def __op__(self, op, other): |
| return Animation( |
| op(self.rotations, other.rotations), |
| op(self.positions, other.positions), |
| op(self.orients, other.orients), |
| op(self.offsets, other.offsets), |
| op(self.parents, other.parents)) |
|
|
| def __iop__(self, op, other): |
| self.rotations = op(self.roations, other.rotations) |
| self.positions = op(self.roations, other.positions) |
| self.orients = op(self.orients, other.orients) |
| self.offsets = op(self.offsets, other.offsets) |
| self.parents = op(self.parents, other.parents) |
| return self |
|
|
| def __sop__(self, op): |
| return Animation( |
| op(self.rotations), |
| op(self.positions), |
| op(self.orients), |
| op(self.offsets), |
| op(self.parents)) |
|
|
| def __add__(self, other): |
| return self.__op__(operator.add, other) |
|
|
| def __sub__(self, other): |
| return self.__op__(operator.sub, other) |
|
|
| def __mul__(self, other): |
| return self.__op__(operator.mul, other) |
|
|
| def __div__(self, other): |
| return self.__op__(operator.div, other) |
|
|
| def __abs__(self): |
| return self.__sop__(operator.abs) |
|
|
| def __neg__(self): |
| return self.__sop__(operator.neg) |
|
|
| def __iadd__(self, other): |
| return self.__iop__(operator.iadd, other) |
|
|
| def __isub__(self, other): |
| return self.__iop__(operator.isub, other) |
|
|
| def __imul__(self, other): |
| return self.__iop__(operator.imul, other) |
|
|
| def __idiv__(self, other): |
| return self.__iop__(operator.idiv, other) |
|
|
| def __len__(self): |
| return len(self.rotations) |
|
|
| def __getitem__(self, k): |
| if isinstance(k, tuple): |
| return Animation( |
| self.rotations[k], |
| self.positions[k], |
| self.orients[k[1:]], |
| self.offsets[k[1:]], |
| self.parents[k[1:]], |
| self.names[k[1:]], |
| self.frametime[k[1:]]) |
| else: |
| return Animation( |
| self.rotations[k], |
| self.positions[k], |
| self.orients, |
| self.offsets, |
| self.parents, |
| self.names, |
| self.frametime) |
|
|
| def __setitem__(self, k, v): |
| if isinstance(k, tuple): |
| self.rotations.__setitem__(k, v.rotations) |
| self.positions.__setitem__(k, v.positions) |
| self.orients.__setitem__(k[1:], v.orients) |
| self.offsets.__setitem__(k[1:], v.offsets) |
| self.parents.__setitem__(k[1:], v.parents) |
| else: |
| self.rotations.__setitem__(k, v.rotations) |
| self.positions.__setitem__(k, v.positions) |
| self.orients.__setitem__(k, v.orients) |
| self.offsets.__setitem__(k, v.offsets) |
| self.parents.__setitem__(k, v.parents) |
|
|
| @property |
| def shape(self): |
| return (self.rotations.shape[0], self.rotations.shape[1]) |
|
|
| def copy(self): |
| return Animation( |
| self.rotations.copy(), self.positions.copy(), |
| self.orients.copy(), self.offsets.copy(), |
| self.parents.copy(), self.names, |
| self.frametime) |
|
|
| def repeat(self, *args, **kw): |
| return Animation( |
| self.rotations.repeat(*args, **kw), |
| self.positions.repeat(*args, **kw), |
| self.orients, self.offsets, self.parents, self.frametime, self.names) |
|
|
| def ravel(self): |
| return np.hstack([ |
| self.rotations.log().ravel(), |
| self.positions.ravel(), |
| self.orients.log().ravel(), |
| self.offsets.ravel()]) |
|
|
| @classmethod |
| def unravel(cls, anim, shape, parents): |
| nf, nj = shape |
| rotations = anim[nf * nj * 0:nf * nj * 3] |
| positions = anim[nf * nj * 3:nf * nj * 6] |
| orients = anim[nf * nj * 6 + nj * 0:nf * nj * 6 + nj * 3] |
| offsets = anim[nf * nj * 6 + nj * 3:nf * nj * 6 + nj * 6] |
| return cls( |
| Quaternions.exp(rotations), positions, |
| Quaternions.exp(orients), offsets, |
| parents.copy()) |
|
|
|
|
| |
| def transforms_local(anim): |
| """ |
| Computes Animation Local Transforms |
| |
| As well as a number of other uses this can |
| be used to compute global joint transforms, |
| which in turn can be used to compete global |
| joint positions |
| |
| Parameters |
| ---------- |
| |
| anim : Animation |
| Input animation |
| |
| Returns |
| ------- |
| |
| transforms : (F, J, 4, 4) ndarray |
| |
| For each frame F, joint local |
| transforms for each joint J |
| """ |
|
|
| transforms = anim.rotations.transforms() |
| transforms = np.concatenate([transforms, np.zeros(transforms.shape[:2] + (3, 1))], axis=-1) |
| transforms = np.concatenate([transforms, np.zeros(transforms.shape[:2] + (1, 4))], axis=-2) |
| |
| transforms[:, :, 0:3, 3] = anim.positions |
| transforms[:, :, 3:4, 3] = 1.0 |
| return transforms |
|
|
|
|
| def transforms_multiply(t0s, t1s): |
| """ |
| Transforms Multiply |
| |
| Multiplies two arrays of animation transforms |
| |
| Parameters |
| ---------- |
| |
| t0s, t1s : (F, J, 4, 4) ndarray |
| Two arrays of transforms |
| for each frame F and each |
| joint J |
| |
| Returns |
| ------- |
| |
| transforms : (F, J, 4, 4) ndarray |
| Array of transforms for each |
| frame F and joint J multiplied |
| together |
| """ |
|
|
| return ut.matrix_multiply(t0s, t1s) |
|
|
|
|
| def transforms_inv(ts): |
| fts = ts.reshape(-1, 4, 4) |
| fts = np.array(list(map(lambda x: np.linalg.inv(x), fts))) |
| return fts.reshape(ts.shape) |
|
|
|
|
| def transforms_blank(anim): |
| """ |
| Blank Transforms |
| |
| Parameters |
| ---------- |
| |
| anim : Animation |
| Input animation |
| |
| Returns |
| ------- |
| |
| transforms : (F, J, 4, 4) ndarray |
| Array of identity transforms for |
| each frame F and joint J |
| """ |
|
|
| ts = np.zeros(anim.shape + (4, 4)) |
| ts[:, :, 0, 0] = 1.0; |
| ts[:, :, 1, 1] = 1.0; |
| ts[:, :, 2, 2] = 1.0; |
| ts[:, :, 3, 3] = 1.0; |
| return ts |
|
|
|
|
| |
| def transforms_global(anim): |
| """ |
| Global Animation Transforms |
| |
| This relies on joint ordering |
| being incremental. That means a joint |
| J1 must not be a ancestor of J0 if |
| J0 appears before J1 in the joint |
| ordering. |
| |
| Parameters |
| ---------- |
| |
| anim : Animation |
| Input animation |
| |
| Returns |
| ------ |
| |
| transforms : (F, J, 4, 4) ndarray |
| Array of global transforms for |
| each frame F and joint J |
| """ |
| locals = transforms_local(anim) |
| globals = transforms_blank(anim) |
|
|
| globals[:, 0] = locals[:, 0] |
|
|
| for i in range(1, anim.shape[1]): |
| globals[:, i] = transforms_multiply(globals[:, anim.parents[i]], locals[:, i]) |
|
|
| return globals |
|
|
|
|
| |
| def positions_global(anim): |
| """ |
| Global Joint Positions |
| |
| Given an animation compute the global joint |
| positions at at every frame |
| |
| Parameters |
| ---------- |
| |
| anim : Animation |
| Input animation |
| |
| Returns |
| ------- |
| |
| positions : (F, J, 3) ndarray |
| Positions for every frame F |
| and joint position J |
| """ |
|
|
| |
| positions = transforms_global(anim)[:, :, :, 3] |
| return positions[:, :, :3] / positions[:, :, 3, np.newaxis] |
|
|
|
|
| """ Rotations """ |
|
|
|
|
| def rotations_global(anim): |
| """ |
| Global Animation Rotations |
| |
| This relies on joint ordering |
| being incremental. That means a joint |
| J1 must not be a ancestor of J0 if |
| J0 appears before J1 in the joint |
| ordering. |
| |
| Parameters |
| ---------- |
| |
| anim : Animation |
| Input animation |
| |
| Returns |
| ------- |
| |
| points : (F, J) Quaternions |
| global rotations for every frame F |
| and joint J |
| """ |
|
|
| joints = np.arange(anim.shape[1]) |
| parents = np.arange(anim.shape[1]) |
| locals = anim.rotations |
| globals = Quaternions.id(anim.shape) |
|
|
| globals[:, 0] = locals[:, 0] |
|
|
| for i in range(1, anim.shape[1]): |
| globals[:, i] = globals[:, anim.parents[i]] * locals[:, i] |
|
|
| return globals |
|
|
|
|
| def rotations_parents_global(anim): |
| rotations = rotations_global(anim) |
| rotations = rotations[:, anim.parents] |
| rotations[:, 0] = Quaternions.id(len(anim)) |
| return rotations |
|
|
| """ Offsets & Orients """ |
|
|
|
|
| def orients_global(anim): |
| joints = np.arange(anim.shape[1]) |
| parents = np.arange(anim.shape[1]) |
| locals = anim.orients |
| globals = Quaternions.id(anim.shape[1]) |
|
|
| globals[:, 0] = locals[:, 0] |
|
|
| for i in range(1, anim.shape[1]): |
| globals[:, i] = globals[:, anim.parents[i]] * locals[:, i] |
|
|
| return globals |
|
|
|
|
| def offsets_transforms_local(anim): |
| transforms = anim.orients[np.newaxis].transforms() |
| transforms = np.concatenate([transforms, np.zeros(transforms.shape[:2] + (3, 1))], axis=-1) |
| transforms = np.concatenate([transforms, np.zeros(transforms.shape[:2] + (1, 4))], axis=-2) |
| transforms[:, :, 0:3, 3] = anim.offsets[np.newaxis] |
| transforms[:, :, 3:4, 3] = 1.0 |
| return transforms |
|
|
|
|
| def offsets_transforms_global(anim): |
| joints = np.arange(anim.shape[1]) |
| parents = np.arange(anim.shape[1]) |
| locals = offsets_transforms_local(anim) |
| globals = transforms_blank(anim) |
|
|
| globals[:, 0] = locals[:, 0] |
|
|
| for i in range(1, anim.shape[1]): |
| globals[:, i] = transforms_multiply(globals[:, anim.parents[i]], locals[:, i]) |
|
|
| return globals |
|
|
|
|
| def offsets_global(anim): |
| offsets = offsets_transforms_global(anim)[:, :, :, 3] |
| return offsets[0, :, :3] / offsets[0, :, 3, np.newaxis] |
|
|
|
|
| """ Lengths """ |
|
|
|
|
| def offset_lengths(anim): |
| return np.sum(anim.offsets[1:] ** 2.0, axis=1) ** 0.5 |
|
|
|
|
| def position_lengths(anim): |
| return np.sum(anim.positions[:, 1:] ** 2.0, axis=2) ** 0.5 |
|
|
|
|
| """ Skinning """ |
|
|
|
|
| def skin(anim, rest, weights, mesh, maxjoints=4): |
| full_transforms = transforms_multiply( |
| transforms_global(anim), |
| transforms_inv(transforms_global(rest[0:1]))) |
|
|
| weightids = np.argsort(-weights, axis=1)[:, :maxjoints] |
| weightvls = np.array(list(map(lambda w, i: w[i], weights, weightids))) |
| weightvls = weightvls / weightvls.sum(axis=1)[..., np.newaxis] |
|
|
| verts = np.hstack([mesh, np.ones((len(mesh), 1))]) |
| verts = verts[np.newaxis, :, np.newaxis, :, np.newaxis] |
| verts = transforms_multiply(full_transforms[:, weightids], verts) |
| verts = (verts[:, :, :, :3] / verts[:, :, :, 3:4])[:, :, :, :, 0] |
|
|
| return np.sum(weightvls[np.newaxis, :, :, np.newaxis] * verts, axis=2) |
