LinearOrthoMDTransform

class menpofit.transform.LinearOrthoMDTransform(model, sparse_instance)

Bases: OrthoPDM, Transform

A transform that couples an alignment transform to a statistical model together with a global similarity transform, such that the weights of the transform are fully specified by both the weights of statistical model and the weights of the similarity transform. The model is assumed to generate an instance which is then transformed by the similarity transform; the result defines the target landmarks of the transform. If no source is provided, the mean of the model is defined as the source landmarks of the transform.

This transform (in contrast to the GlobalMDTransform) additionally orthonormalises both the global and the model basis against each other, ensuring that orthogonality and normalization is enforced across the unified bases.

This transform (in contrast to the OrthoMDTransform) should be used with linear statistical models of dense shapes.

Parameters

• model (menpo.model.LinearModel) – A linear statistical shape model.

• sparse_instance (menpo.shape.PointCloud) – The source landmarks of the transform.

apply(x, batch_size=None, **kwargs)

Applies this transform to x.

If x is Transformable, x will be handed this transform object to transform itself non-destructively (a transformed copy of the object will be returned).

If not, x is assumed to be an ndarray. The transformation will be non-destructive, returning the transformed version.

Any kwargs will be passed to the specific transform _apply() method.

Parameters

• x (Transformable or (n_points, n_dims) ndarray) – The array or object to be transformed.

• batch_size (int, optional) – If not None, this determines how many items from the numpy array will be passed through the transform at a time. This is useful for operations that require large intermediate matrices to be computed.

• kwargs (dict) – Passed through to _apply().

Returns

transformed (type(x)) – The transformed object or array

apply_inplace(*args, **kwargs)

Deprecated as public supported API, use the non-mutating apply() instead.

For internal performance-specific uses, see _apply_inplace().

as_vector(**kwargs)

Returns a flattened representation of the object as a single vector.

Returns

vector ((N,) ndarray) – The core representation of the object, flattened into a single vector. Note that this is always a view back on to the original object, but is not writable.

compose_after(transform)

Returns a TransformChain that represents this transform composed after the given transform:

c = a.compose_after(b)
c.apply(p) == a.apply(b.apply(p))

a and b are left unchanged.

This corresponds to the usual mathematical formalism for the compose operator, o.

Parameters

transform (Transform) – Transform to be applied before self

Returns

transform (TransformChain) – The resulting transform chain.

compose_before(transform)

Returns a TransformChain that represents this transform composed before the given transform:

c = a.compose_before(b)
c.apply(p) == b.apply(a.apply(p))

a and b are left unchanged.

Parameters

transform (Transform) – Transform to be applied after self

Returns

transform (TransformChain) – The resulting transform chain.

copy()

Generate an efficient copy of this object.

Note that Numpy arrays and other Copyable objects on self will be deeply copied. Dictionaries and sets will be shallow copied, and everything else will be assigned (no copy will be made).

Classes that store state other than numpy arrays and immutable types should overwrite this method to ensure all state is copied.

Returns

type(self) – A copy of this object

d_dp(_)

The derivative with respect to the parametrisation changes evaluated at points.

Parameters

points ((n_points, n_dims) ndarray) – The spatial points at which the derivative should be evaluated.

Returns

d_dp ((n_points, n_parameters, n_dims) ndarray) – The Jacobian with respect to the parametrisation.

from_vector(vector)

Build a new instance of the object from it’s vectorized state.

self is used to fill out the missing state required to rebuild a full object from it’s standardized flattened state. This is the default implementation, which is which is a deepcopy of the object followed by a call to from_vector_inplace(). This method can be overridden for a performance benefit if desired.

Parameters

vector ((n_parameters,) ndarray) – Flattened representation of the object.

Returns

object (type(self)) – An new instance of this class.

from_vector_inplace(vector)

Deprecated. Use the non-mutating API, from_vector.

For internal usage in performance-sensitive spots, see _from_vector_inplace()

Parameters

vector ((n_parameters,) ndarray) – Flattened representation of this object

has_nan_values()

Tests if the vectorized form of the object contains nan values or not. This is particularly useful for objects with unknown values that have been mapped to nan values.

Returns

has_nan_values (bool) – If the vectorized object contains nan values.

increment(shapes, n_shapes=None, forgetting_factor=1.0, max_n_components=None, verbose=False)

Update the eigenvectors, eigenvalues and mean vector of this model by performing incremental PCA on the given samples.

Parameters

• shapes (list of menpo.shape.PointCloud) – List of new shapes to update the model from.

• n_shapes (int or None, optional) – If int, then shapes must be an iterator that yields n_shapes. If None, then shapes has to be a list (so we know how large the data matrix needs to be).

• forgetting_factor ([0.0, 1.0] float, optional) – Forgetting factor that weights the relative contribution of new samples vs old samples. If 1.0, all samples are weighted equally and, hence, the results is the exact same as performing batch PCA on the concatenated list of old and new simples. If <1.0, more emphasis is put on the new samples. See [1] for details.

• max_n_components (int or None, optional) – The maximum number of components that the model will keep. If None, then all the components will be kept.

• verbose (bool, optional) – If True, then information about the progress will be printed.

References

1

D. Ross, J. Lim, R.S. Lin, M.H. Yang. “Incremental Learning for Robust Visual Tracking”. International Journal on Computer Vision, 2007.

set_target(target)

Update this object so that it attempts to recreate the new_target.

Parameters

new_target (menpo.shape.PointCloud) – The new target that this object should try and regenerate.

property dense_target

The current dense menpo.shape.PointCloud that this object produces.

Type

menpo.shape.PointCloud

property global_parameters

The parameters for the global transform.

Type

(n_global_parameters,) ndarray

property n_active_components

The number of components currently in use on this model.

Type

int

property n_dims

The number of dimensions of the spatial instance of the model

Type

int

property n_dims_output

The output of the data from the transform.

None if the output of the transform is not dimension specific.

Type

int or None

property n_global_parameters

The number of parameters in the global_transform

Type

int

property n_landmarks

The number of sparse landmarks.

Type

int

property n_parameters

The length of the vector that this object produces.

Type

int

property n_points

The number of points on the target.

Type

int

property n_weights

The number of parameters in the linear model.

Type

int

property sparse_target

The current sparse menpo.shape.PointCloud that this object produces.

Type

menpo.shape.PointCloud

property target

The current menpo.shape.PointCloud that this object produces.

Type

menpo.shape.PointCloud

property weights

The weights of the model.

Type

(n_weights,) ndarray