Skip to content

# Posts tagged ‘weight space’

From my earlier posts if we break the idea of a pose being directly attached to weight 1:1,  we can place it anywhere in a n-dimensional space made up of multiple weights. E.g.

```pose A = weight A @ 1.0 pose B = weight B @ 1.0 pose C = weight A @ 1.0 * weight B @ 1.0```

The @ denotes the position along the weight governing its interpolation e.g. if the position was at 0.5 the interpolation would go from 0.0 – 1.0 (0.5) – 0.0. Likewise if the position was at 0.0 the interpolation would go from 1.0 – 0.0 and vice verse if it was at 1.0.

Zero value positions

If we include  dimensions with zero values we can have absolute interpolation. We can show this with a 2d space:

```Pose A = weight A @ 1.0 * weight B @ 0.0 Pose B = weight A @ 0.0 * weight B @ 1.0```

If weight A is at 1.0 and weight B at 0.0 the pose A will be at 1.0, once we start to introduce weight B,  pose A gets reduced until 0.0 when weight B is at 1.0.

Mixing additive and absolute poses

This can be done simply by deciding on the dimensionality of the poses. If we have three weights: A, B and C we could have poses for weights A and B additive and absolute for C:

```Pose A = weight A @ 1.0 * weight C @ 0.0 Pose B = weight B @ 1.0 * weight C @ 0.0 Pose C  = weight C @ 1.0```

Plus a corrective could still be applied:

`Pose D = weight A @ 1.0 * weight B @ 1.0`

As an entry in the weight space is essentially added on top, local weight manipulation is key.

An entry is now classified as an interpolated product of interpolated values between 0 and 1, multiplied by a local weight. The local weight is important , as once an entry has been added it becomes impossible to see the mix of weights/entries that went into it.

Interpolation of an entry can take many forms, remember though that its product can still be non-linear.

Entries placed inside the weight space, are based on the products of multiple weights in a value interpolated sense between [0:1].

I.e An entry placed at 0.5 using weight A * weight B should not be the product of weight A and B to produce 0.5. As inconsistencies can arise for example:

A = 1.0, B = 0.5
A = 0.5, B = 1.0

Resulting in unbalanced in between combinations – Rather an entry sits at the product of a value interpolate by each weight:

Weight A @ 0.0 – Value = 0.0
Weight A @ 0.5 – Value = 1.0
Weight A @ 1.0 – Value = 0.0

The entry therefore sits at (weight A @ 0.5 = Value 1.0) * (weight B @ 0.5 = value 1.0)

This allows for true interpolations, special thanks go to Daniel Pook Kolb – finally starting to understand this.

Thanks goes to Daniel Pook Kolb.

Given a weight space of real numbers where each weight is a dimension, we can embed any data in this space be it an input or a pure value itself. By breaking the connection of weight to data (shape) we can essentially have multiple weights drive a single input.

For example if we have a dimension of two weights: W1 and W2 when W1 is at 1.0 we can drive a face pose/blendshape – lets call this shape S1. Likewise when W2 is at 1.0 we can drive another shape S2.

Treating this as a two dimensional space, we can place entries anywhere inside it. For example combining W1 and W2 (W1 * W2) we can place an entry (shape) at this point in the space.

Manipulating the weights drive this entry in a non-linear way. For example when W1 is at 1.0 and W2 is at 1.0, W1*W2 results in this entry being at 1.0. Likewise when W1 is at 1.0 but W2 is at 0.0, (W1 * W2) the entry is at 0.0.

Greater values of the input weights causes greater influence of the entry at there combination. This influence happens in a non-linear way.

W1 0.00 W2 0.00 = Entry 0.0
W1 0.25 W2 0.25 = Entry 0.06
W1 0.50 W2 0.50 = Entry 0.25
W1 0.75 W2 0.75 = Entry 0.56
W1 1.00 W2 1.00 = Entry 1.00

If we treat this as corrective system, the entry at the combination is additive to the other entrys at W1 and W2. This entry however can be an absolute if its regarded as a value that the W1 and W2 entries take negatively, whilst driving a new entry positively.

The weight space can in theory have as many dimensions as possible, with as many entries into its space (given that they exist inside a range of 0:1).