Skip to content

rig_geometry

rig_geometry(P, lengths, s=0.1, return_selection_matrices=False)

Generates a pyramid-like geometry for each rig bone

Parameters:

Name Type Description Default
P (b, 3, 4) float numpy array

World transformation of each bone

 required
lengths (b, 1) float numpy array

Length of each bone

 required
s float

Scale of the pyramid

 0.1
return_selection_matrices bool

If True, returns selection matrices mapping bone to rig geometry (default False)

 False

Returns:

Name Type Description
rV (5b, 3) numpy float array

Vertices of rig geometry
rF (7b, 3) numpy float array

Faces of rig geometry.
SV (5b, b) scipy sparse matrix

Selection matrix mapping rig geometry to bones. Only returns if return_selection_matrices is True
SF (7b, b) scipy sparse matrix

Selection matrix mapping rig geometry to faces. Only returns if return_selection_matrices is True
Source code in src\fast_cody\rig_geometry.py 
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 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
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
def rig_geometry(P, lengths, s=0.1, return_selection_matrices=False):
    """
    Generates a pyramid-like geometry for each rig bone

    Parameters
    ----------
    P : (b, 3, 4) float numpy array
        World transformation of each bone
    lengths : (b, 1) float numpy array
        Length of each bone
    s : float, optional
        Scale of the pyramid
    return_selection_matrices : bool
        If True, returns selection matrices mapping bone to rig geometry (default False)

    Returns
    -------
    rV : (5b, 3) numpy float array
        Vertices of rig geometry
    rF : (7b, 3) numpy float array
        Faces of rig geometry.
    SV : (5b, b) scipy sparse matrix
        Selection matrix mapping rig geometry to bones. Only returns if return_selection_matrices is True
    SF : (7b, b) scipy sparse matrix
        Selection matrix mapping rig geometry to faces. Only returns if return_selection_matrices is True

    """
    if (P.ndim == 2):
        P = P[None, :,  :]
    #make standard tetrahedron with square base vertices, pointed upwards
    V = np.array(
        [[-0.5, 0, -0.5 ],
         [0.5,  0, -0.5  ],
         [0.5,  0, 0.5 ],
         [-0.5, 0, 0.5  ],
         [0,    1,   0  ]])



    F = np.array(
        [[0, 1, 2],
        [0, 2, 3],
        [0, 1,4],
        [1, 2, 4],
        [2, 3, 4],
        [3, 0, 4],
        [0, 3, 1]
         ]
    )


    #append ones to V to make homoegeneous

    V1 = np.hstack((V, np.ones((V.shape[0], 1))))

    k = P.shape[0]


    # empty list of face indices
    rF = np.empty((0, 3), dtype=int)
    # empty list of vertices
    rV = np.empty((0, 3), dtype=float)

    # initialize empty sparse matrices SV and SF
    SV = sp.coo_matrix((0, k))
    SF = sp.coo_matrix((0, k))

    for b in range(k):
        Tb = P[b, :, :]

        S = np.diag([s, lengths[b], s, 1])
        rVbs = (S@V1.T).T
        rVb = (Tb@rVbs.T).T

        # append face indices
        rF = np.vstack((rF, F + b*5))
        rV = np.vstack((rV, rVb))

        # selection matrix for vertices associated with each weights
        iV = np.arange(0, 5)
        jV = b*np.ones(5)
        vV = np.ones(5)
        SVb = sp.coo_matrix((vV, (iV, jV)), shape=(V.shape[0], k))

        iF = np.arange(0, 7)
        jF = b*np.ones(7)
        vF = np.ones(7)
        SFb = sp.coo_matrix((vF, (iF, jF)), shape=(F.shape[0], k))


        if return_selection_matrices:
            #concatenate SVb to global SV
            if b == 0:
                SV = SVb
                SF = SFb
            else:
                SV = sp.vstack((SV, SVb))
                SF = sp.vstack((SF, SFb))


    if return_selection_matrices:
        return rV, rF, SV, SF
    else:
        return rV, rF