On this page |

This CHOP performs channel interpolation using an example-based method. Each example is taken from the pair of samples provided from the source and target channels. The data from the first input is then interpolated so that the target values will be obtained if the input values match the source values.

The first input specifies the channels used for the interpolation.

The second input specifies the source channels. This must contain the same number of channels as the first input.

The third input specifies the target channels. Each sample here is paired with the corresponding sample in the source channel. Thus, the length in samples of this input must matched with the second input. However, a different number of channels from the second input is allowed.

## Parameters

## Fit

Interpolant

Interpolation method.

Radial Basis Functions

This class of interpolants provide smooth results that will likely match the example data.

Hyperplane

This interpolant will create a plane of best fit. The results will likely not match the example data.

Clamp Input

If enabled, this will clamp the input data to the corresponding value range of the source input before interpolating.

Extrapolate Beyond Examples

If enabled, a best fit method will be used for the extrapolation of data outside of the source inputs.

Best Possible Extrapolation

This option is only used when **Extrapolate Beyond Examples** is enabled. Turning this on will first maximize the interpolation using the plane of best fit, and then interpolate the remaining differences using the radial basis functions. This gives closer fits to the
hyperplane method especially for kernel functions that specify a falloff. For those kernel functions, turning this option will also result in faster cooking. This option can give better results when there is high spatial correlation in the examples.

Kernel

This specifies the kernel function used for the Radial Basis Functions interpolant. Different kernel functions will result in varying fits.

Exponent

Specifies the exponent used for the Thin Plate kernel function. Larger values will give smoother results.

Fall Off

Specifies the fall off factor for the Gaussian, Multiquadric, Inverse Multiquadric, and Exponential Bump kernel functions. Larger values will give smoother results.

Solver

Specifies the solver method used for the interpolation.

Fast

The Cholesky solver is faster but not as stable.

Robust

The SVD solver is slower but will produce the higher quality interpolations.

Damping

Specifies the damping used for the Cholesky solver. This is normally not needed unless the solver is failing. In that case, start with a very small damping value like 0.00001 for example. Then use successively larger values like 0.0001, 0.001, 0.01, etc. until the solver succeeds.

Maximum Iterations

Specifies the maximum number of iterations that the SVD solver performs. If the SVD solver fails, then increase this value until the solver succeeds.

### Common

Some of these parameters may not be available on all CHOP nodes.

Scope

To determine which channels get affected, some CHOPs have a scope string. Patterns can be used in the scope, for example `*`

(match all), and `?`

(match single character).

The following are examples of possible channel name matching options:

`chan2`

Matches a single channel name.

`chan3 tx ty tz`

Matches four channel names, separated by spaces.

`chan*`

Matches each channel that starts with `chan`

.

`*foot*`

Matches each channel that has `foot`

in it.

`t?`

The `?`

matches a single character. `t?`

matches two-character channels starting with t.

`r[xyz]`

Matches channels `rx`

, `ry`

and `rz`

.

`blend[3-7:2]`

Matches number ranges giving `blend3`

, `blend5`

, and `blend7`

.

`blend[2-3,5,13]`

Matches channels `blend2`

, `blend3`

, `blend5`

, `blend13`

.

`t[xyz]`

`[xyz]`

matches three characters, giving channels `tx`

, `ty`

and `tz`

.

Sample Rate Match

The Sample Rate Match Options handle cases where multiple input CHOPs’ sample rates are different.

Resample At First Input’s Rate

Use rate of first input to resample others.

Resample At Maximum Rate

Resample to highest sample rate.

Resample At Minimum Rate

Resample to the lowest sample rate.

Error if Rates Differ

Does not accept conflicting sample rates.

Units

The units for which time parameters are specified.

For example, you can specify the amount of time a lag should last for in seconds (default), frames (at the Houdini FPS), or samples (in the CHOP’s sample rate).

Note

When you change the Units parameter, it does not convert the existing parameters to the new units.

Time Slice

Time Slicing is a feature which boosts cooking performance and reduces memory usage. Traditionally, CHOPs calculate the channel over its entire frame range. If the channel does need to be evaluated every frame, then cooking the entire range of the channel is unnecessary. It is more efficient to calculate only the fraction of the channel that is needed. This fraction is known as a Time Slice.

Unload

Causes the memory consumed by a CHOP to be released after it is cooked and the data passed to the next CHOP.

Export Prefix

The Export prefix is prepended to CHOP channel names to determine where to export to.

For example, if the CHOP channel was named `geo1:tx`

, and the prefix was `/obj`

, the channel would be exported to `/obj/geo1/tx`

.

Note

You can leave the **Export Prefix** blank, but then your CHOP track names need to be absolute paths, such as `obj:geo1:tx`

.

Graph Color

Every CHOP has this option. Each CHOP gets a default color assigned for display in the Graph port, but you can override the color in the Common page under Graph Color. There are 36 RGB color combinations in the Palette.

Graph Color Step

When the graph displays the animation curves and a CHOP has two or more channels, this defines the difference in color from one channel to the next, giving a rainbow spectrum of colors.

## Examples

BlendPoseBasic Example for BlendPose channel node

This is a simple example of using the BlendPose CHOP to deform some geometry using random tracker point positions.

See also |