| | import numpy as np |
| | |
| | import visualization.Animation as Animation |
| |
|
| |
|
| | """ Family Functions """ |
| |
|
| |
|
| | def joints(parents): |
| | """ |
| | Parameters |
| | ---------- |
| | |
| | parents : (J) ndarray |
| | parents array |
| | |
| | Returns |
| | ------- |
| | |
| | joints : (J) ndarray |
| | Array of joint indices |
| | """ |
| | return np.arange(len(parents), dtype=int) |
| |
|
| |
|
| | def joints_list(parents): |
| | """ |
| | Parameters |
| | ---------- |
| | |
| | parents : (J) ndarray |
| | parents array |
| | |
| | Returns |
| | ------- |
| | |
| | joints : [ndarray] |
| | List of arrays of joint idices for |
| | each joint |
| | """ |
| | return list(joints(parents)[:, np.newaxis]) |
| |
|
| |
|
| | def parents_list(parents): |
| | """ |
| | Parameters |
| | ---------- |
| | |
| | parents : (J) ndarray |
| | parents array |
| | |
| | Returns |
| | ------- |
| | |
| | parents : [ndarray] |
| | List of arrays of joint idices for |
| | the parents of each joint |
| | """ |
| | return list(parents[:, np.newaxis]) |
| |
|
| |
|
| | def children_list(parents): |
| | """ |
| | Parameters |
| | ---------- |
| | |
| | parents : (J) ndarray |
| | parents array |
| | |
| | Returns |
| | ------- |
| | |
| | children : [ndarray] |
| | List of arrays of joint indices for |
| | the children of each joint |
| | """ |
| |
|
| | def joint_children(i): |
| | return [j for j, p in enumerate(parents) if p == i] |
| |
|
| | return list(map(lambda j: np.array(joint_children(j)), joints(parents))) |
| |
|
| |
|
| | def descendants_list(parents): |
| | """ |
| | Parameters |
| | ---------- |
| | |
| | parents : (J) ndarray |
| | parents array |
| | |
| | Returns |
| | ------- |
| | |
| | descendants : [ndarray] |
| | List of arrays of joint idices for |
| | the descendants of each joint |
| | """ |
| |
|
| | children = children_list(parents) |
| |
|
| | def joint_descendants(i): |
| | return sum([joint_descendants(j) for j in children[i]], list(children[i])) |
| |
|
| | return list(map(lambda j: np.array(joint_descendants(j)), joints(parents))) |
| |
|
| |
|
| | def ancestors_list(parents): |
| | """ |
| | Parameters |
| | ---------- |
| | |
| | parents : (J) ndarray |
| | parents array |
| | |
| | Returns |
| | ------- |
| | |
| | ancestors : [ndarray] |
| | List of arrays of joint idices for |
| | the ancestors of each joint |
| | """ |
| |
|
| | decendants = descendants_list(parents) |
| |
|
| | def joint_ancestors(i): |
| | return [j for j in joints(parents) if i in decendants[j]] |
| |
|
| | return list(map(lambda j: np.array(joint_ancestors(j)), joints(parents))) |
| |
|
| |
|
| | """ Mask Functions """ |
| |
|
| |
|
| | def mask(parents, filter): |
| | """ |
| | Constructs a Mask for a give filter |
| | |
| | A mask is a (J, J) ndarray truth table for a given |
| | condition over J joints. For example there |
| | may be a mask specifying if a joint N is a |
| | child of another joint M. |
| | |
| | This could be constructed into a mask using |
| | `m = mask(parents, children_list)` and the condition |
| | of childhood tested using `m[N, M]`. |
| | |
| | Parameters |
| | ---------- |
| | |
| | parents : (J) ndarray |
| | parents array |
| | |
| | filter : (J) ndarray -> [ndarray] |
| | function that outputs a list of arrays |
| | of joint indices for some condition |
| | |
| | Returns |
| | ------- |
| | |
| | mask : (N, N) ndarray |
| | boolean truth table of given condition |
| | """ |
| | m = np.zeros((len(parents), len(parents))).astype(bool) |
| | jnts = joints(parents) |
| | fltr = filter(parents) |
| | for i, f in enumerate(fltr): m[i, :] = np.any(jnts[:, np.newaxis] == f[np.newaxis, :], axis=1) |
| | return m |
| |
|
| |
|
| | def joints_mask(parents): return np.eye(len(parents)).astype(bool) |
| |
|
| |
|
| | def children_mask(parents): return mask(parents, children_list) |
| |
|
| |
|
| | def parents_mask(parents): return mask(parents, parents_list) |
| |
|
| |
|
| | def descendants_mask(parents): return mask(parents, descendants_list) |
| |
|
| |
|
| | def ancestors_mask(parents): return mask(parents, ancestors_list) |
| |
|
| |
|
| | """ Search Functions """ |
| |
|
| |
|
| | def joint_chain_ascend(parents, start, end): |
| | chain = [] |
| | while start != end: |
| | chain.append(start) |
| | start = parents[start] |
| | chain.append(end) |
| | return np.array(chain, dtype=int) |
| |
|
| |
|
| | """ Constraints """ |
| |
|
| |
|
| | def constraints(anim, **kwargs): |
| | """ |
| | Constraint list for Animation |
| | |
| | This constraint list can be used in the |
| | VerletParticle solver to constrain |
| | a animation global joint positions. |
| | |
| | Parameters |
| | ---------- |
| | |
| | anim : Animation |
| | Input animation |
| | |
| | masses : (F, J) ndarray |
| | Optional list of masses |
| | for joints J across frames F |
| | defaults to weighting by |
| | vertical height |
| | |
| | Returns |
| | ------- |
| | |
| | constraints : [(int, int, (F, J) ndarray, (F, J) ndarray, (F, J) ndarray)] |
| | A list of constraints in the format: |
| | (Joint1, Joint2, Masses1, Masses2, Lengths) |
| | |
| | """ |
| |
|
| | masses = kwargs.pop('masses', None) |
| |
|
| | children = children_list(anim.parents) |
| | constraints = [] |
| |
|
| | points_offsets = Animation.offsets_global(anim) |
| | points = Animation.positions_global(anim) |
| |
|
| | if masses is None: |
| | masses = 1.0 / (0.1 + np.absolute(points_offsets[:, 1])) |
| | masses = masses[np.newaxis].repeat(len(anim), axis=0) |
| |
|
| | for j in range(anim.shape[1]): |
| |
|
| | """ Add constraints between all joints and their children """ |
| | for c0 in children[j]: |
| |
|
| | dists = np.sum((points[:, c0] - points[:, j]) ** 2.0, axis=1) ** 0.5 |
| | constraints.append((c0, j, masses[:, c0], masses[:, j], dists)) |
| |
|
| | """ Add constraints between all children of joint """ |
| | for c1 in children[j]: |
| | if c0 == c1: continue |
| |
|
| | dists = np.sum((points[:, c0] - points[:, c1]) ** 2.0, axis=1) ** 0.5 |
| | constraints.append((c0, c1, masses[:, c0], masses[:, c1], dists)) |
| |
|
| | return constraints |
| |
|
| |
|
| | """ Graph Functions """ |
| |
|
| |
|
| | def graph(anim): |
| | """ |
| | Generates a weighted adjacency matrix |
| | using local joint distances along |
| | the skeletal structure. |
| | |
| | Joints which are not connected |
| | are assigned the weight `0`. |
| | |
| | Joints which actually have zero distance |
| | between them, but are still connected, are |
| | perturbed by some minimal amount. |
| | |
| | The output of this routine can be used |
| | with the `scipy.sparse.csgraph` |
| | routines for graph analysis. |
| | |
| | Parameters |
| | ---------- |
| | |
| | anim : Animation |
| | input animation |
| | |
| | Returns |
| | ------- |
| | |
| | graph : (N, N) ndarray |
| | weight adjacency matrix using |
| | local distances along the |
| | skeletal structure from joint |
| | N to joint M. If joints are not |
| | directly connected are assigned |
| | the weight `0`. |
| | """ |
| |
|
| | graph = np.zeros(anim.shape[1], anim.shape[1]) |
| | lengths = np.sum(anim.offsets ** 2.0, axis=1) ** 0.5 + 0.001 |
| |
|
| | for i, p in enumerate(anim.parents): |
| | if p == -1: continue |
| | graph[i, p] = lengths[p] |
| | graph[p, i] = lengths[p] |
| |
|
| | return graph |
| |
|
| |
|
| | def distances(anim): |
| | """ |
| | Generates a distance matrix for |
| | pairwise joint distances along |
| | the skeletal structure |
| | |
| | Parameters |
| | ---------- |
| | |
| | anim : Animation |
| | input animation |
| | |
| | Returns |
| | ------- |
| | |
| | distances : (N, N) ndarray |
| | array of pairwise distances |
| | along skeletal structure |
| | from some joint N to some |
| | joint M |
| | """ |
| |
|
| | distances = np.zeros((anim.shape[1], anim.shape[1])) |
| | generated = distances.copy().astype(bool) |
| |
|
| | joint_lengths = np.sum(anim.offsets ** 2.0, axis=1) ** 0.5 |
| | joint_children = children_list(anim) |
| | joint_parents = parents_list(anim) |
| |
|
| | def find_distance(distances, generated, prev, i, j): |
| |
|
| | """ If root, identity, or already generated, return """ |
| | if j == -1: return (0.0, True) |
| | if j == i: return (0.0, True) |
| | if generated[i, j]: return (distances[i, j], True) |
| |
|
| | """ Find best distances along parents and children """ |
| | par_dists = [(joint_lengths[j], find_distance(distances, generated, j, i, p)) for p in joint_parents[j] if |
| | p != prev] |
| | out_dists = [(joint_lengths[c], find_distance(distances, generated, j, i, c)) for c in joint_children[j] if |
| | c != prev] |
| |
|
| | """ Check valid distance and not dead end """ |
| | par_dists = [a + d for (a, (d, f)) in par_dists if f] |
| | out_dists = [a + d for (a, (d, f)) in out_dists if f] |
| |
|
| | """ All dead ends """ |
| | if (out_dists + par_dists) == []: return (0.0, False) |
| |
|
| | """ Get minimum path """ |
| | dist = min(out_dists + par_dists) |
| | distances[i, j] = dist; |
| | distances[j, i] = dist |
| | generated[i, j] = True; |
| | generated[j, i] = True |
| |
|
| | for i in range(anim.shape[1]): |
| | for j in range(anim.shape[1]): |
| | find_distance(distances, generated, -1, i, j) |
| |
|
| | return distances |
| |
|
| |
|
| | def edges(parents): |
| | """ |
| | Animation structure edges |
| | |
| | Parameters |
| | ---------- |
| | |
| | parents : (J) ndarray |
| | parents array |
| | |
| | Returns |
| | ------- |
| | |
| | edges : (M, 2) ndarray |
| | array of pairs where each |
| | pair contains two indices of a joints |
| | which corrisponds to an edge in the |
| | joint structure going from parent to child. |
| | """ |
| |
|
| | return np.array(list(zip(parents, joints(parents)))[1:]) |
| |
|
| |
|
| | def incidence(parents): |
| | """ |
| | Incidence Matrix |
| | |
| | Parameters |
| | ---------- |
| | |
| | parents : (J) ndarray |
| | parents array |
| | |
| | Returns |
| | ------- |
| | |
| | incidence : (N, M) ndarray |
| | |
| | Matrix of N joint positions by |
| | M edges which each entry is either |
| | 1 or -1 and multiplication by the |
| | joint positions returns the an |
| | array of vectors along each edge |
| | of the structure |
| | """ |
| |
|
| | es = edges(parents) |
| |
|
| | inc = np.zeros((len(parents) - 1, len(parents))).astype(np.int) |
| | for i, e in enumerate(es): |
| | inc[i, e[0]] = 1 |
| | inc[i, e[1]] = -1 |
| |
|
| | return inc.T |
| |
|
