Public Member Functions
def	__init__
def	calculate_error
def	calculate_full_param_vec
def	calculate_jacobian
def	multisensor_pose_jacobian
def	single_sensor_params_jacobian
def	split_all
Private Attributes
	_expanded_params
	_free_list
	_j_count
	_multisensors
	_robot_params
	_use_cov

Detailed Description

Helpers for computing errors and jacobians

Definition at line 44 of file opt_runner.py.

Constructor & Destructor Documentation

def calibration_estimation.opt_runner.ErrorCalc.__init__	(	self,
		robot_params,
		free_dict,
		multisensors,
		use_cov
	)

Definition at line 48 of file opt_runner.py.

Member Function Documentation

def calibration_estimation.opt_runner.ErrorCalc.calculate_error	(	self,
		opt_all_vec
	)

Definition at line 66 of file opt_runner.py.

def calibration_estimation.opt_runner.ErrorCalc.calculate_full_param_vec	(	self,
		opt_param_vec
	)

Take the set of optimization params, and expand it into the bigger param vec

Definition at line 57 of file opt_runner.py.

def calibration_estimation.opt_runner.ErrorCalc.calculate_jacobian	(	self,
		opt_all_vec
	)

Full Jacobian:
  The resulting returned jacobian can be thought of as a set of several concatenated jacobians as follows:

[ J_multisensor_0 ]
    J = [ J_multisensor_1 ]
[        :        ]
[ J_multisensor_M ]

  where M is the number of multisensors, which is generally the number of calibration samples collected.

Multisensor Jacobian:
  The Jacobian for a given multisensor is created by concatenating jacobians for each sensor

            [ J_sensor_m_0 ]
  J_multisensor_m = [ J_sensor_m_1 ]
            [      :       ]
            [ J_sensor_m_S ]

  where S is the number of sensors in this multisensor.

Sensor Jacobian:
  A single sensor jacobian is created by concatenating jacobians for the system parameters and checkerboards

  J_sensor_m_s = [ J_params_m_s | J_m_s_pose0 | J_m_s_pose1 | --- | J_m_s_CB_poseC ]

  The number of rows in J_sensor_m_s is equal to the number of rows in this sensor's residual.
  J_params_m_s shows how modifying the free system parameters affects the residual.
  Each J_m_s_pose_c is 6 columns wide and shows how moving a certain target affects the residual. All
    of the J_m_s_pose blocks are zero, except J_sensor_pose_m, since target m is the only target that
    was viewed by the sensors in this multisensor.

Definition at line 95 of file opt_runner.py.

def calibration_estimation.opt_runner.ErrorCalc.multisensor_pose_jacobian	(	self,
		opt_param_vec,
		pose_param_vec,
		multisensor
	)

Generates the jacobian from a target pose to the multisensor's residual.

Input:
- opt_param_vec: Vector of the free system parameters (the parameters we're actuall optimizing)
- pose_param_vec: Vector of length 6 encoding the target's pose 0:3=translation 3:6=rotation_axis
- multisensor: The actual multisensor definition.
Output:
- J_scaled: An mx6 jacobian, where m is the length of multisensor's residual. There are 6 columns since the
    target's pose is encoded using 6 parameters.
    If covariance calculations are enabled, then the Jacobian is scaled by sqrt(Gamma), where Gamma
    is the information matrix for this measurement.

Definition at line 243 of file opt_runner.py.

def calibration_estimation.opt_runner.ErrorCalc.single_sensor_params_jacobian	(	self,
		opt_param_vec,
		target_pose_T,
		target_id,
		sensor
	)

Computes the jacobian from the free system parameters to a single sensor
Inputs:
- opt_param_vec: Vector of the free system parameters (the parameters we're actuall optimizing)
- target_pose_T: The pose of the target that this sensor is viewing
- target_id: String name of the target that this sensor is viewing. This is necessary to generate the
     set of feature points on the target
- sensor: The actual sensor definition
Output:
- J_scaled: An mxn jacobian, where m is the length of sensor's residual and n is the length of opt_param_vec.
    If covariance calculations are enabled, then the Jacobian is scaled by sqrt(Gamma), where Gamma
    is the information matrix for this measurement.

Definition at line 186 of file opt_runner.py.

def calibration_estimation.opt_runner.ErrorCalc.split_all	(	self,
		opt_all_vec
	)

Splits the input vector into two parts:
  1) opt_param_vec: The system parameters that we're optimizing,
  2) full_pose_arr: A Nx6 array where each row is a checkerboard pose

Definition at line 173 of file opt_runner.py.