Alignment Parameters

parameters

Parameter

Parameter(
    value: float,
    variance: float = 0.0,
    default: float = 0.0,
    enabled: bool = True,
    name: str = "",
    unit: Unit = NONE,
)

Class representing a stochastic parameter with variance.

A parameter holds a stochastic value with some variance and can be enabled or disabled. When disabled, the parameter's value equals its default value. The default value should be chosen so the parameter has no effect on computations (e.g., scale=1, rotation/translation=0).

Parameter disabling is used to exclude parameters from least-squares estimation during trajectory alignment.

Attributes:

• default –

  Default value used when parameter is disabled

• enabled –

  Whether the parameter is active

• name –

  Parameter name for identification

• unit –

  Unit of measurement for the parameter

Initializes a Parameter instance.

Parameters:

• value (float) –

  Initial parameter value

• variance (float, default: 0.0 ) –

  Initial parameter variance. Defaults to 0.0.

• default (float, default: 0.0 ) –

  Default value when disabled. Defaults to 0.0.

• enabled (bool, default: True ) –

  Whether parameter is enabled. Defaults to True.

• name (str, default: '' ) –

  Parameter name. Auto-generated if empty. Defaults to "".

• unit (Unit, default: NONE ) –

  Unit of measurement. Defaults to Unit.NONE.

Source code in trajectopy\processing\lib\alignment\parameters.py

def __init__(
    self,
    value: float,
    variance: float = 0.0,
    default: float = 0.0,
    enabled: bool = True,
    name: str = "",
    unit: Unit = Unit.NONE,
) -> None:
    """Initializes a Parameter instance.

    Args:
        value: Initial parameter value
        variance: Initial parameter variance. Defaults to 0.0.
        default: Default value when disabled. Defaults to 0.0.
        enabled: Whether parameter is enabled. Defaults to True.
        name: Parameter name. Auto-generated if empty. Defaults to "".
        unit: Unit of measurement. Defaults to Unit.NONE.
    """
    self._value = value
    self._variance = variance
    self.default = default
    self.enabled = enabled
    self.name = name or f"Parameter {Parameter._cnt}"
    self.unit = unit

    Parameter._cnt += 1

value property writable

value: float

Gets the parameter value.

Returns:

• float ( float ) –

  Actual value if enabled, default value otherwise

variance property writable

variance: float

Gets the parameter variance.

Returns:

• float ( float ) –

  Actual variance if enabled, 0.0 otherwise

__str__

__str__() -> str

Returns formatted string representation of the parameter.

Returns:

• str ( str ) –

  Formatted string with parameter name, value, unit, and standard deviation

Source code in trajectopy\processing\lib\alignment\parameters.py

def __str__(self) -> str:
    """Returns formatted string representation of the parameter.

    Returns:
        str: Formatted string with parameter name, value, unit, and standard deviation
    """
    formatter_value = UNIT_FORMAT_RULES.get(self.unit, {"normal": (1, "-", 4)})["normal"]
    formatter_variance = UNIT_FORMAT_RULES.get(self.unit, {"precise": (1, "-", 2)}).get("precise", formatter_value)
    return f"{self.name:<16} = {self.value*formatter_value[0]:<8.{formatter_value[2]}f}{formatter_value[1]:<4}  s-dev.: {np.sqrt(self.variance)*formatter_variance[0]:<8.{formatter_variance[2]}f}{formatter_variance[1]:<4}"

__sub__

__sub__(other: Parameter) -> Parameter

Subtracts another parameter from this one.

Parameters:

• other (Parameter) –

  Parameter to subtract

Returns:

• Parameter ( Parameter ) –

  New parameter with subtracted value and combined variance

Source code in trajectopy\processing\lib\alignment\parameters.py

def __sub__(self, other: "Parameter") -> "Parameter":
    """Subtracts another parameter from this one.

    Args:
        other: Parameter to subtract

    Returns:
        Parameter: New parameter with subtracted value and combined variance
    """
    return Parameter(
        value=self.value - other.value,
        variance=np.sqrt(self.variance**2 + other.variance**2),
    )

__add__

__add__(other: Parameter) -> Parameter

Adds another parameter to this one.

Parameters:

• other (Parameter) –

  Parameter to add

Returns:

• Parameter ( Parameter ) –

  New parameter with added value and combined variance

Source code in trajectopy\processing\lib\alignment\parameters.py

def __add__(self, other: "Parameter") -> "Parameter":
    """Adds another parameter to this one.

    Args:
        other: Parameter to add

    Returns:
        Parameter: New parameter with added value and combined variance
    """
    return Parameter(
        value=self.value + other.value,
        variance=np.sqrt(self.variance**2 + other.variance**2),
    )

__neg__

__neg__() -> Parameter

Negates the parameter.

Returns:

• Parameter ( Parameter ) –

  New parameter with negated value and default

Source code in trajectopy\processing\lib\alignment\parameters.py

def __neg__(self) -> "Parameter":
    """Negates the parameter.

    Returns:
        Parameter: New parameter with negated value and default
    """
    return Parameter(
        value=-self.value,
        variance=self.variance,
        default=-self.default,
        enabled=self.enabled,
        name=self.name,
        unit=self.unit,
    )

enable

enable() -> None

Enables the parameter for estimation.

Source code in trajectopy\processing\lib\alignment\parameters.py

def enable(self) -> None:
    """Enables the parameter for estimation."""
    self.enabled = True

disable

disable() -> None

Disables the parameter from estimation.

Source code in trajectopy\processing\lib\alignment\parameters.py

def disable(self) -> None:
    """Disables the parameter from estimation."""
    self.enabled = False

ParameterSet dataclass

ParameterSet(
    enabled: bool = True,
    covariance_matrix: ndarray = (
        lambda: zeros((0, 0), dtype=float)
    )(),
)

Bases: ABC

Abstract base class for grouping related parameters.

Groups related parameters (e.g., 3 parameters for 3D translation) and provides common functionality for managing parameter values, variances, and covariances.

Attributes:

• enabled (bool) –

  Whether the entire parameter set is enabled

• covariance_matrix (ndarray) –

  Covariance matrix for the parameter set

any_enabled property

any_enabled: bool

Checks if any parameter in the set is enabled.

Returns:

• bool ( bool ) –

  True if at least one parameter is enabled

num_enabled property

num_enabled: int

Gets the number of enabled parameters in the set.

Returns:

• int ( int ) –

  Count of enabled parameters

enabled_bool_list property writable

enabled_bool_list: List[bool]

Gets the enabled state of all parameters as a boolean list.

Returns:

• List[bool] –

  List[bool]: List of booleans indicating which parameters are enabled

enabled_indices property

enabled_indices: List[int]

Gets indices of enabled parameters.

Useful for extracting values or variances of only enabled parameters from the full parameter arrays.

Returns:

• List[int] –

  List[int]: List of indices where parameters are enabled

__parameter_fields property

__parameter_fields: List[Parameter]

Gets all Parameter instances from dataclass fields.

Returns:

• List[Parameter] –

  List[Parameter]: List of all Parameter objects in the set

values property writable

values: ndarray

Gets all parameter values as a numpy array.

Returns:

• ndarray –

  np.ndarray: Array of all parameter values

values_enabled property writable

values_enabled: ndarray

Gets enabled parameter values as a numpy array.

Returns:

• ndarray –

  np.ndarray: Array of enabled parameter values

variances property writable

variances: ndarray

Gets all parameter variances as a numpy array.

Returns:

• ndarray –

  np.ndarray: Array of all parameter variances

variances_enabled property writable

variances_enabled: ndarray

Gets enabled parameter variances as a numpy array.

Returns:

• ndarray –

  np.ndarray: Array of enabled parameter variances

__post_init__

__post_init__() -> None

Initializes covariance matrix after dataclass creation.

Source code in trajectopy\processing\lib\alignment\parameters.py

def __post_init__(self) -> None:
    """Initializes covariance matrix after dataclass creation."""
    if len(self.covariance_matrix) == len(self):
        self.validate_covariance()
        return

    self.covariance_matrix = np.zeros((len(self), len(self)), dtype=float)

__len__

__len__() -> int

Returns the number of parameters in the set.

Returns:

• int ( int ) –

  Number of parameters

Source code in trajectopy\processing\lib\alignment\parameters.py

def __len__(self) -> int:
    """Returns the number of parameters in the set.

    Returns:
        int: Number of parameters
    """
    return len(self.values)

__str__

__str__() -> str

Returns formatted string representation of the parameter set.

Returns:

• str ( str ) –

  Boxed string with all parameter information

Source code in trajectopy\processing\lib\alignment\parameters.py

def __str__(self) -> str:
    """Returns formatted string representation of the parameter set.

    Returns:
        str: Boxed string with all parameter information
    """
    return list2box(
        input_list=self.to_string_list(),
        title=self.__class__.__name__,
        upper_boundary=True,
        lower_boundary=True,
    )

__iter__

__iter__() -> iter

Returns iterator over parameter fields.

Returns:

• Iterator ( iter ) –

  Iterator over Parameter instances

Source code in trajectopy\processing\lib\alignment\parameters.py

def __iter__(self) -> iter:
    """Returns iterator over parameter fields.

    Returns:
        Iterator: Iterator over Parameter instances
    """
    return iter(self.__parameter_fields)

get_covariance_matrix

get_covariance_matrix(enabled_only: bool = True) -> ndarray

Returns the covariance matrix of the parameter set

Parameters:

• enabled_only (bool, default: True ) –

  If True, only the covariance matrix of the enabled parameters is returned. Defaults to True.

Returns:

• ndarray –

  np.ndarray: Covariance matrix

Source code in trajectopy\processing\lib\alignment\parameters.py

def get_covariance_matrix(self, enabled_only: bool = True) -> np.ndarray:
    """Returns the covariance matrix of the parameter set

    Args:
        enabled_only (bool, optional): If True, only the covariance matrix of the enabled parameters is returned. Defaults to True.

    Returns:
        np.ndarray: Covariance matrix
    """
    if enabled_only:
        return self.covariance_matrix[np.ix_(self.enabled_indices, self.enabled_indices)]

    return self.covariance_matrix

set_covariance_matrix

set_covariance_matrix(cov_matrix: ndarray) -> None

Sets the covariance matrix of the parameter set

Parameters:

• cov_matrix (ndarray) –

  Covariance matrix

Source code in trajectopy\processing\lib\alignment\parameters.py

def set_covariance_matrix(self, cov_matrix: np.ndarray) -> None:
    """Sets the covariance matrix of the parameter set

    Args:
        cov_matrix (np.ndarray): Covariance matrix
    """
    self.covariance_matrix = cov_matrix
    self.validate_covariance()

validate_covariance

validate_covariance() -> None

Validates and normalizes the covariance matrix dimensions.

Checks that the covariance matrix is square and matches either all parameters or only enabled parameters. Updates parameter variances from diagonal elements.

Raises:

• AlignmentParametersError –

  If covariance matrix dimensions are invalid

Source code in trajectopy\processing\lib\alignment\parameters.py

def validate_covariance(self) -> None:
    """Validates and normalizes the covariance matrix dimensions.

    Checks that the covariance matrix is square and matches either all parameters
    or only enabled parameters. Updates parameter variances from diagonal elements.

    Raises:
        AlignmentParametersError: If covariance matrix dimensions are invalid
    """
    if self.covariance_matrix.shape[0] != self.covariance_matrix.shape[1]:
        raise AlignmentParametersError("Covariance matrix must be square.")

    if self.covariance_matrix.shape[0] == len(self):
        self.variances = np.diag(self.covariance_matrix)
        return

    if self.covariance_matrix.shape[0] != self.num_enabled:
        raise AlignmentParametersError(
            "Covariance matrix must either be valid for all parameters or for all enabled parameters!"
        )

    covariance_matrix = np.zeros((len(self), len(self)), dtype=float)
    # for sub_row_indiex, full_row_index in enumerate(self.enabled_indices):
    #     for sub_col_index, full_col_index in enumerate(self.enabled_indices):
    #         covariance_matrix[full_row_index, full_col_index] = self.covariance_matrix[
    #             sub_row_indiex, sub_col_index
    #         ]
    covariance_matrix[np.ix_(self.enabled_indices, self.enabled_indices)] = self.covariance_matrix
    self.covariance_matrix = covariance_matrix
    self.variances_enabled = np.diag(self.get_covariance_matrix(enabled_only=True))

enable

enable() -> None

Enables all parameters in the set.

Source code in trajectopy\processing\lib\alignment\parameters.py

def enable(self) -> None:
    """Enables all parameters in the set."""
    for param in self.__parameter_fields:
        param.enable()
    self.enabled = True

disable

disable() -> None

Disables all parameters in the set.

Source code in trajectopy\processing\lib\alignment\parameters.py

def disable(self) -> None:
    """Disables all parameters in the set."""
    for param in self.__parameter_fields:
        param.disable()
    self.enabled = False

to_string_list

to_string_list(enabled_only: bool = True) -> List[str]

Returns a list of all parameter strings of the class

Parameters:

• enabled_only (bool, default: True ) –

  If True, only enabled parameters are included. Defaults to True.

Returns:

• List[str] –

  List[str]: List of parameter strings

Source code in trajectopy\processing\lib\alignment\parameters.py

def to_string_list(self, enabled_only: bool = True) -> List[str]:
    """Returns a list of all parameter strings of the class

    Args:
        enabled_only (bool, optional): If True, only enabled parameters are included. Defaults to True.

    Returns:
        List[str]: List of parameter strings
    """
    return [str(param) for param in self.__parameter_fields if param.enabled or not enabled_only]

to_name_list

to_name_list(
    enabled_only: bool = True, lower_case: bool = True
) -> List[str]

Returns a list of all parameter names of the class

Parameters:

• enabled_only (bool, default: True ) –

  If True, only enabled parameters are included. Defaults to True.

• lower_case (bool, default: True ) –

  If True, parameter names are returned in lower case. Defaults to True.

Returns:

• List[str] –

  List[str]: List of parameter names

Source code in trajectopy\processing\lib\alignment\parameters.py

def to_name_list(self, enabled_only: bool = True, lower_case: bool = True) -> List[str]:
    """Returns a list of all parameter names of the class

    Args:
        enabled_only (bool, optional): If True, only enabled parameters are included. Defaults to True.
        lower_case (bool, optional): If True, parameter names are returned in lower case. Defaults to True.

    Returns:
        List[str]: List of parameter names
    """
    return [
        param.name.lower() if lower_case else param.name
        for param in self.__parameter_fields
        if param.enabled or not enabled_only
    ]

to_dict

to_dict(
    enabled_only: bool = True,
) -> Dict[str, List[float]]

Returns a dictionary of all parameters of the class

Parameters:

• enabled_only (bool, default: True ) –

  If True, only enabled parameters are included. Defaults to True.

Returns:

• Dict[str, List[float]] –

  Dict[str, List[float]]: Dictionary with parameter names as keys and [value, variance] as values

Source code in trajectopy\processing\lib\alignment\parameters.py

def to_dict(self, enabled_only: bool = True) -> Dict[str, List[float]]:
    """Returns a dictionary of all parameters of the class

    Args:
        enabled_only (bool, optional): If True, only enabled parameters are included. Defaults to True.

    Returns:
        Dict[str, List[float]]: Dictionary with parameter names as keys and [value, variance] as values
    """
    return {
        param.name: [param.value, param.variance]
        for param in self.__parameter_fields
        if param.enabled or not enabled_only
    }

HelmertTransformation dataclass

HelmertTransformation(
    enabled: bool = True,
    covariance_matrix: ndarray = (
        lambda: zeros((0, 0), dtype=float)
    )(),
    trans_x: Parameter = (
        lambda: Parameter(value=0.0, default=0.0)
    )(),
    trans_y: Parameter = (
        lambda: Parameter(value=0.0, default=0.0)
    )(),
    trans_z: Parameter = (
        lambda: Parameter(value=0.0, default=0.0)
    )(),
    rot_x: Parameter = (
        lambda: Parameter(value=0.0, default=0.0)
    )(),
    rot_y: Parameter = (
        lambda: Parameter(value=0.0, default=0.0)
    )(),
    rot_z: Parameter = (
        lambda: Parameter(value=0.0, default=0.0)
    )(),
    scale: Parameter = (
        lambda: Parameter(value=1.0, default=1.0)
    )(),
)

Bases: ParameterSet

Parameter set for a 7-parameter Helmert similarity transformation.

Represents a 3D similarity transformation with translation, rotation, and scale.

Attributes:

• trans_x (Parameter) –

  Translation parameter in x-direction

• trans_y (Parameter) –

  Translation parameter in y-direction

• trans_z (Parameter) –

  Translation parameter in z-direction

• rot_x (Parameter) –

  Rotation parameter around x-axis

• rot_y (Parameter) –

  Rotation parameter around y-axis

• rot_z (Parameter) –

  Rotation parameter around z-axis

• scale (Parameter) –

  Scale parameter

translation property writable

translation: ndarray

Gets the 3D translation vector.

Returns:

• ndarray –

  np.ndarray: Translation vector [x, y, z]

rotation property writable

rotation: ndarray

Gets the Euler rotation angles.

Returns:

• ndarray –

  np.ndarray: Rotation angles [rx, ry, rz] in radians (XYZ order)

rotation_set property

rotation_set: Rotations

Gets the rotation as a Rotations object.

Returns:

• Rotations ( Rotations ) –

  Rotation object from Euler angles

rotation_matrix property

rotation_matrix: ndarray

Gets the 3x3 rotation matrix.

Returns:

• ndarray –

  np.ndarray: Rotation matrix (3x3)

apply_to

apply_to(xyz: ndarray) -> ndarray

Applies the Helmert transformation to 3D points.

Parameters:

• xyz (ndarray) –

  Input points (Nx3 array)

Returns:

• ndarray –

  np.ndarray: Transformed points (Nx3 array)

Source code in trajectopy\processing\lib\alignment\parameters.py

def apply_to(self, xyz: np.ndarray) -> np.ndarray:
    """Applies the Helmert transformation to 3D points.

    Args:
        xyz: Input points (Nx3 array)

    Returns:
        np.ndarray: Transformed points (Nx3 array)
    """
    return self.translation + self.scale.value * (self.rotation_matrix @ xyz.T).T

Leverarm dataclass

Leverarm(
    enabled: bool = True,
    covariance_matrix: ndarray = (
        lambda: zeros((0, 0), dtype=float)
    )(),
    x: Parameter = (
        lambda: Parameter(
            value=0.0,
            default=0.0,
            name="Leverarm x",
            enabled=False,
            unit=METER,
        )
    )(),
    y: Parameter = (
        lambda: Parameter(
            value=0.0,
            default=0.0,
            name="Leverarm y",
            enabled=False,
            unit=METER,
        )
    )(),
    z: Parameter = (
        lambda: Parameter(
            value=0.0,
            default=0.0,
            name="Leverarm z",
            enabled=False,
            unit=METER,
        )
    )(),
)

Bases: ParameterSet

Parameter set for a leverarm offset between sensor and body frame.

Represents the 3D offset between a sensor frame and the vehicle body frame.

Attributes:

• x (Parameter) –

  Leverarm parameter in x-direction

• y (Parameter) –

  Leverarm parameter in y-direction

• z (Parameter) –

  Leverarm parameter in z-direction

apply_to

apply_to(xyz: ndarray, quat_body: ndarray) -> ndarray

Applies the leverarm to a set of positions using orientations

Parameters:

• xyz (ndarray) –

  Positions

• quat_body (ndarray) –

  Orientations

Returns:

• ndarray –

  np.ndarray: Leverarm applied positions

Source code in trajectopy\processing\lib\alignment\parameters.py

def apply_to(self, xyz: np.ndarray, quat_body: np.ndarray) -> np.ndarray:
    """Applies the leverarm to a set of positions using orientations

    Args:
        xyz (np.ndarray): Positions
        quat_body (np.ndarray): Orientations

    Returns:
        np.ndarray: Leverarm applied positions
    """
    if len(xyz) != len(quat_body):
        raise ValueError("Dimension mismatch between positions and orientations.")

    xyz_red = np.zeros((xyz.shape))
    rot_matrices = Rotations.from_quat(quat_body).as_matrix()

    for i in range(len(xyz_red)):
        d_rot = rot_matrices[i] @ self.values
        xyz_red[i, :] = xyz[i, :] + d_rot

    return xyz_red

AlignmentParameters dataclass

AlignmentParameters(
    enabled: bool = True,
    covariance_matrix: ndarray = (
        lambda: zeros((0, 0), dtype=float)
    )(),
    sim_trans_x: Parameter = (
        lambda: Parameter(
            value=0.0,
            default=0.0,
            name="Translation x",
            enabled=False,
            unit=METER,
        )
    )(),
    sim_trans_y: Parameter = (
        lambda: Parameter(
            value=0.0,
            default=0.0,
            name="Translation y",
            enabled=False,
            unit=METER,
        )
    )(),
    sim_trans_z: Parameter = (
        lambda: Parameter(
            value=0.0,
            default=0.0,
            name="Translation z",
            enabled=False,
            unit=METER,
        )
    )(),
    sim_rot_x: Parameter = (
        lambda: Parameter(
            value=0.0,
            default=0.0,
            name="Rotation x",
            enabled=False,
            unit=RADIAN,
        )
    )(),
    sim_rot_y: Parameter = (
        lambda: Parameter(
            value=0.0,
            default=0.0,
            name="Rotation y",
            enabled=False,
            unit=RADIAN,
        )
    )(),
    sim_rot_z: Parameter = (
        lambda: Parameter(
            value=0.0,
            default=0.0,
            name="Rotation z",
            enabled=False,
            unit=RADIAN,
        )
    )(),
    sim_scale: Parameter = (
        lambda: Parameter(
            value=1.0,
            default=1.0,
            name="Scale",
            enabled=False,
            unit=SCALE,
        )
    )(),
    time_shift: Parameter = (
        lambda: Parameter(
            value=0.0,
            default=0.0,
            name="Time Shift",
            enabled=False,
            unit=SECOND,
        )
    )(),
    lever_x: Parameter = (
        lambda: Parameter(
            value=0.0,
            default=0.0,
            name="Leverarm x",
            enabled=False,
            unit=METER,
        )
    )(),
    lever_y: Parameter = (
        lambda: Parameter(
            value=0.0,
            default=0.0,
            name="Leverarm y",
            enabled=False,
            unit=METER,
        )
    )(),
    lever_z: Parameter = (
        lambda: Parameter(
            value=0.0,
            default=0.0,
            name="Leverarm z",
            enabled=False,
            unit=METER,
        )
    )(),
)

Bases: ParameterSet

Parameter set for spatio-temporal trajectory alignment.

Contains all parameters for aligning two trajectories including similarity transformation (translation, rotation, scale), time shift, and leverarm.

Attributes:

• sim_trans_x (Parameter) –

  Similarity transformation translation in x

• sim_trans_y (Parameter) –

  Similarity transformation translation in y

• sim_trans_z (Parameter) –

  Similarity transformation translation in z

• sim_rot_x (Parameter) –

  Similarity transformation rotation around x

• sim_rot_y (Parameter) –

  Similarity transformation rotation around y

• sim_rot_z (Parameter) –

  Similarity transformation rotation around z

• sim_scale (Parameter) –

  Similarity transformation scale factor

• time_shift (Parameter) –

  Temporal offset between trajectories

• lever_x (Parameter) –

  Leverarm offset in x

• lever_y (Parameter) –

  Leverarm offset in y

• lever_z (Parameter) –

  Leverarm offset in z

sim3_matrix property

sim3_matrix: ndarray

Gets the 4x4 similarity transformation matrix (Sim(3)).

Returns:

• ndarray –

  np.ndarray: 4x4 homogeneous transformation matrix

helmert property

helmert: HelmertTransformation

Gets the Helmert similarity transformation parameters.

Returns:

• HelmertTransformation ( HelmertTransformation ) –

  Transformation parameters (translation, rotation, scale)

leverarm property

leverarm: Leverarm

Gets the leverarm offset parameters.

Returns:

• Leverarm ( Leverarm ) –

  Leverarm offset parameters (x, y, z)

__add__

__add__(other: AlignmentParameters) -> AlignmentParameters

Adds parameter values from another alignment parameter set.

Parameters:

• other (AlignmentParameters) –

  AlignmentParameters to add

Returns:

• AlignmentParameters ( AlignmentParameters ) –

  Sum of parameter values

Source code in trajectopy\processing\lib\alignment\parameters.py

def __add__(self, other: "AlignmentParameters") -> "AlignmentParameters":
    """Adds parameter values from another alignment parameter set.

    Args:
        other: AlignmentParameters to add

    Returns:
        AlignmentParameters: Sum of parameter values
    """
    return self.values + other.values

__sub__

__sub__(other: AlignmentParameters) -> AlignmentParameters

Subtracts parameter values from another alignment parameter set.

Parameters:

• other (AlignmentParameters) –

  AlignmentParameters to subtract

Returns:

• AlignmentParameters ( AlignmentParameters ) –

  Difference of parameter values

Source code in trajectopy\processing\lib\alignment\parameters.py

def __sub__(self, other: "AlignmentParameters") -> "AlignmentParameters":
    """Subtracts parameter values from another alignment parameter set.

    Args:
        other: AlignmentParameters to subtract

    Returns:
        AlignmentParameters: Difference of parameter values
    """
    return self.values - other.values

params_labels

params_labels(
    enabled_only: bool = True, lower_case: bool = True
) -> List[str]

Gets parameter labels/names.

Parameters:

• enabled_only (bool, default: True ) –

  If True, only include enabled parameters. Defaults to True.

• lower_case (bool, default: True ) –

  If True, return lowercase labels. Defaults to True.

Returns:

• List[str] –

  List[str]: List of parameter labels

Source code in trajectopy\processing\lib\alignment\parameters.py

def params_labels(self, enabled_only: bool = True, lower_case: bool = True) -> List[str]:
    """Gets parameter labels/names.

    Args:
        enabled_only: If True, only include enabled parameters. Defaults to True.
        lower_case: If True, return lowercase labels. Defaults to True.

    Returns:
        List[str]: List of parameter labels
    """
    return self.to_name_list(enabled_only=enabled_only, lower_case=lower_case)

from_settings classmethod

from_settings(
    settings: AlignmentEstimationSettings,
) -> AlignmentParameters

Creates AlignmentParameters from estimation settings.

Parameters:

• settings (AlignmentEstimationSettings) –

  Settings specifying which parameters to enable

Returns:

• AlignmentParameters ( AlignmentParameters ) –

  New instance with parameters enabled per settings

Source code in trajectopy\processing\lib\alignment\parameters.py

@classmethod
def from_settings(cls, settings: AlignmentEstimationSettings) -> "AlignmentParameters":
    """Creates AlignmentParameters from estimation settings.

    Args:
        settings: Settings specifying which parameters to enable

    Returns:
        AlignmentParameters: New instance with parameters enabled per settings
    """
    return cls(
        sim_trans_x=Parameter(enabled=settings.translation_x, value=0.0, default=0.0),
        sim_trans_y=Parameter(enabled=settings.translation_x, value=0.0, default=0.0),
        sim_trans_z=Parameter(enabled=settings.translation_x, value=0.0, default=0.0),
        sim_rot_x=Parameter(enabled=settings.rotation_x, value=0.0, default=0.0),
        sim_rot_y=Parameter(enabled=settings.rotation_y, value=0.0, default=0.0),
        sim_rot_z=Parameter(enabled=settings.rotation_z, value=0.0, default=0.0),
        sim_scale=Parameter(enabled=settings.scale, value=1.0, default=1.0),
        time_shift=Parameter(enabled=settings.time_shift, value=0.0, default=0.0),
        lever_x=Parameter(enabled=settings.leverarm_x, value=0.0, default=0.0),
        lever_y=Parameter(enabled=settings.leverarm_y, value=0.0, default=0.0),
        lever_z=Parameter(enabled=settings.leverarm_z, value=0.0, default=0.0),
    )

apply_settings

apply_settings(
    settings: AlignmentEstimationSettings,
) -> None

Applies estimation settings by enabling or disabling parameters.

Parameters:

• settings (AlignmentEstimationSettings) –

  Settings specifying which parameters to enable

Source code in trajectopy\processing\lib\alignment\parameters.py

def apply_settings(self, settings: AlignmentEstimationSettings) -> None:
    """Applies estimation settings by enabling or disabling parameters.

    Args:
        settings: Settings specifying which parameters to enable
    """
    self.sim_trans_x.enabled = settings.translation_x and settings.helmert_enabled
    self.sim_trans_y.enabled = settings.translation_y and settings.helmert_enabled
    self.sim_trans_z.enabled = settings.translation_z and settings.helmert_enabled
    self.sim_rot_x.enabled = settings.rotation_x and settings.helmert_enabled
    self.sim_rot_y.enabled = settings.rotation_y and settings.helmert_enabled
    self.sim_rot_z.enabled = settings.rotation_z and settings.helmert_enabled
    self.sim_scale.enabled = settings.scale and settings.helmert_enabled

    self.time_shift.enabled = settings.time_shift_enabled

    self.lever_x.enabled = settings.leverarm_x and settings.leverarm_enabled
    self.lever_y.enabled = settings.leverarm_y and settings.leverarm_enabled
    self.lever_z.enabled = settings.leverarm_z and settings.leverarm_enabled

to_file

to_file(filename: str) -> None

Writes the alignment parameters to a file

All parameters are written to the file no matter if they are enabled or not. If they are not enabled, the default value is written. Enabled parameters are marked with a 1, disabled with a 0. The order of the parameters is:

• Translation x
• Translation y
• Translation z
• Rotation x
• Rotation y
• Rotation z
• Scale
• Time Shift
• Leverarm x
• Leverarm y
• Leverarm z

Besides the parameters, the covariance matrix is written to the file. The covariance matrix is written row by row next to the parameters.

Parameters:

• filename (str) –

  Path to the file

Source code in trajectopy\processing\lib\alignment\parameters.py

def to_file(self, filename: str) -> None:
    """Writes the alignment parameters to a file

    All parameters are written to the file no matter if they are enabled or not.
    If they are not enabled, the default value is written. Enabled parameters are
    marked with a 1, disabled with a 0. The order of the parameters is:

    - Translation x
    - Translation y
    - Translation z
    - Rotation x
    - Rotation y
    - Rotation z
    - Scale
    - Time Shift
    - Leverarm x
    - Leverarm y
    - Leverarm z

    Besides the parameters, the covariance matrix is written to the file. The covariance
    matrix is written row by row next to the parameters.

    Args:
        filename (str): Path to the file
    """
    dataframe = pd.DataFrame(np.c_[self.values, self.covariance_matrix])
    dataframe.to_csv(filename, index=False, header=False)

to_dataframe

to_dataframe() -> DataFrame

Converts alignment parameters to a pandas DataFrame.

Returns:

• DataFrame –

  pd.DataFrame: DataFrame with parameter values, enabled flags, and covariance matrix

Source code in trajectopy\processing\lib\alignment\parameters.py

def to_dataframe(self) -> pd.DataFrame:
    """Converts alignment parameters to a pandas DataFrame.

    Returns:
        pd.DataFrame: DataFrame with parameter values, enabled flags, and covariance matrix
    """
    variances = pd.DataFrame(self.covariance_matrix)
    parameters = pd.DataFrame({0: self.values, 1: self.enabled_bool_list})
    return pd.concat([parameters, variances], axis=1)

from_file classmethod

from_file(filename: str) -> AlignmentParameters

Reads the alignment parameters from a file

Parameters:

• filename (str) –

  Path to the file

Returns:

• AlignmentParameters ( AlignmentParameters ) –

  AlignmentParameters instance

Source code in trajectopy\processing\lib\alignment\parameters.py

@classmethod
def from_file(cls, filename: str) -> "AlignmentParameters":
    """Reads the alignment parameters from a file

    Args:
        filename (str): Path to the file

    Returns:
        AlignmentParameters: AlignmentParameters instance
    """
    alignment_data = pd.read_csv(filename, comment="#", header=None)
    params: AlignmentParameters = cls()
    params.values = alignment_data.iloc[:11, 0].to_numpy()
    params.enabled_bool_list = [str(item).lower() != "false" for item in alignment_data.iloc[:11, 1].to_list()]

    if alignment_data.shape[1] > 2:
        params.set_covariance_matrix(alignment_data.iloc[:11, 2:].to_numpy())

    return params

to_estimation_settings

to_estimation_settings() -> AlignmentEstimationSettings

Converts alignment parameters to estimation settings.

Returns:

• AlignmentEstimationSettings ( AlignmentEstimationSettings ) –

  Settings object with enabled flags from parameters

Source code in trajectopy\processing\lib\alignment\parameters.py

def to_estimation_settings(self) -> AlignmentEstimationSettings:
    """Converts alignment parameters to estimation settings.

    Returns:
        AlignmentEstimationSettings: Settings object with enabled flags from parameters
    """
    return AlignmentEstimationSettings(
        translation_x=self.sim_trans_x.enabled,
        translation_y=self.sim_trans_y.enabled,
        translation_z=self.sim_trans_z.enabled,
        rotation_x=self.sim_rot_x.enabled,
        rotation_y=self.sim_rot_y.enabled,
        rotation_z=self.sim_rot_z.enabled,
        scale=self.sim_scale.enabled,
        time_shift=self.time_shift.enabled,
        leverarm_x=self.lever_x.enabled,
        leverarm_y=self.lever_y.enabled,
        leverarm_z=self.lever_z.enabled,
    )

SensorRotationParameters dataclass

SensorRotationParameters(
    enabled: bool = True,
    covariance_matrix: ndarray = (
        lambda: zeros((0, 0), dtype=float)
    )(),
    sensor_rot_x: Parameter = (
        lambda: Parameter(
            value=0.0,
            default=0.0,
            name="Sensor Rotation x",
            enabled=False,
            unit=RADIAN,
        )
    )(),
    sensor_rot_y: Parameter = (
        lambda: Parameter(
            value=0.0,
            default=0.0,
            name="Sensor Rotation y",
            enabled=False,
            unit=RADIAN,
        )
    )(),
    sensor_rot_z: Parameter = (
        lambda: Parameter(
            value=0.0,
            default=0.0,
            name="Sensor Rotation z",
            enabled=False,
            unit=RADIAN,
        )
    )(),
)

Bases: ParameterSet

Parameter set for sensor body-frame rotation.

Represents the rotational offset between the sensor frame and body frame.

Attributes:

• sensor_rot_x (Parameter) –

  Sensor rotation around x-axis

• sensor_rot_y (Parameter) –

  Sensor rotation around y-axis

• sensor_rot_z (Parameter) –

  Sensor rotation around z-axis

rotation property

rotation: ndarray

Gets the sensor rotation Euler angles.

Returns:

• ndarray –

  np.ndarray: Rotation angles [rx, ry, rz] in radians (XYZ order)

rotation_set property

rotation_set: Rotations

Gets the sensor rotation as a Rotations object.

Returns:

• Rotations ( Rotations ) –

  Rotation object from Euler angles

rotation_matrix property

rotation_matrix: ndarray

Gets the 3x3 sensor rotation matrix.

Returns:

• ndarray –

  np.ndarray: Rotation matrix (3x3)

from_file classmethod

from_file(filename: str) -> SensorRotationParameters

Reads sensor rotation parameters from a file.

Parameters:

• filename (str) –

  Path to the alignment file (must contain 14 lines)

Returns:

• SensorRotationParameters ( SensorRotationParameters ) –

  Loaded sensor rotation parameters

Raises:

• ValueError –

  If file doesn't contain exactly 14 lines

Source code in trajectopy\processing\lib\alignment\parameters.py

@classmethod
def from_file(cls, filename: str) -> "SensorRotationParameters":
    """Reads sensor rotation parameters from a file.

    Args:
        filename: Path to the alignment file (must contain 14 lines)

    Returns:
        SensorRotationParameters: Loaded sensor rotation parameters

    Raises:
        ValueError: If file doesn't contain exactly 14 lines
    """
    alignment_data = pd.read_csv(filename, comment="#", header=None)

    if len(alignment_data) != 14:
        raise ValueError("Alignment file with sensor rotation information must contain 14 lines!")
    enabled_bool_list = [str(item).lower() != "false" for item in alignment_data.iloc[11:, 1].to_list()]
    params: SensorRotationParameters = cls()
    params.values = alignment_data.iloc[11:, 0].to_numpy()
    params.enabled_bool_list = enabled_bool_list
    return params

to_file

to_file(filename: str) -> None

Appends sensor rotation parameters to a file.

Parameters:

• filename (str) –

  Path to the file to append to

Source code in trajectopy\processing\lib\alignment\parameters.py

def to_file(self, filename: str) -> None:
    """Appends sensor rotation parameters to a file.

    Args:
        filename: Path to the file to append to
    """
    with open(filename, mode="a", encoding="utf-8") as file:
        file.write(f"{self.sensor_rot_x.value},{self.sensor_rot_x.enabled}\n")
        file.write(f"{self.sensor_rot_y.value},{self.sensor_rot_y.enabled}\n")
        file.write(f"{self.sensor_rot_z.value},{self.sensor_rot_z.enabled}\n")