xrt: Refactor t_camera_calibration to use a tagged union instead of a bare array

Co-authored-by: Jakob Bornecrantz <[e-mail]>

src/xrt/auxiliary/tracking/t_calibration.cpp

···
 	cv::Size image_size(cols, rows);
 	cv::Size new_image_size(cols, rows);
 
-	StereoCameraCalibrationWrapper wrapped = {5}; // We only use five distortion parameters.
+	StereoCameraCalibrationWrapper wrapped(c.use_fisheye ? T_DISTORTION_FISHEYE_KB4 : T_DISTORTION_OPENCV_RADTAN_5);
 	wrapped.view[0].image_size_pixels.w = image_size.width;
 	wrapped.view[0].image_size_pixels.h = image_size.height;
 	wrapped.view[1].image_size_pixels = wrapped.view[0].image_size_pixels;
-
-	wrapped.view[0].use_fisheye = c.use_fisheye;
-	wrapped.view[1].use_fisheye = c.use_fisheye;
 
 
 	float rp_error = 0.0f;
···
 		flags |= cv::fisheye::CALIB_RECOMPUTE_EXTRINSIC;
 
 		// fisheye version
-		rp_error = cv::fisheye::stereoCalibrate(c.state.board_models_f64,               // objectPoints
-		                                        c.state.view[0].measured_f64,           // inagePoints1
-		                                        c.state.view[1].measured_f64,           // imagePoints2
-		                                        wrapped.view[0].intrinsics_mat,         // cameraMatrix1
-		                                        wrapped.view[0].distortion_fisheye_mat, // distCoeffs1
-		                                        wrapped.view[1].intrinsics_mat,         // cameraMatrix2
-		                                        wrapped.view[1].distortion_fisheye_mat, // distCoeffs2
-		                                        image_size,                             // imageSize
-		                                        wrapped.camera_rotation_mat,            // R
-		                                        wrapped.camera_translation_mat,         // T
+		rp_error = cv::fisheye::stereoCalibrate(c.state.board_models_f64,       // objectPoints
+		                                        c.state.view[0].measured_f64,   // inagePoints1
+		                                        c.state.view[1].measured_f64,   // imagePoints2
+		                                        wrapped.view[0].intrinsics_mat, // cameraMatrix1
+		                                        wrapped.view[0].distortion_mat, // distCoeffs1
+		                                        wrapped.view[1].intrinsics_mat, // cameraMatrix2
+		                                        wrapped.view[1].distortion_mat, // distCoeffs2
+		                                        image_size,                     // imageSize
+		                                        wrapped.camera_rotation_mat,    // R
+		                                        wrapped.camera_translation_mat, // T
 		                                        flags);
 	} else {
 		// non-fisheye version
···
 	}
 	to_stdout("disparity_to_depth", maps.disparity_to_depth_mat);
 	std::cout << "#####\n";
-	if (c.use_fisheye) {
-		to_stdout("view[0].distortion_fisheye", wrapped.view[0].distortion_fisheye_mat);
-	} else {
-		to_stdout("view[0].distortion", wrapped.view[0].distortion_mat);
-	}
+	to_stdout("view[0].distortion", wrapped.view[0].distortion_mat);
 	to_stdout("view[0].intrinsics", wrapped.view[0].intrinsics_mat);
 	to_stdout("view[0].projection", maps.view[0].projection_mat);
 	to_stdout("view[0].rotation", maps.view[0].rotation_mat);
 	std::cout << "#####\n";
-	if (c.use_fisheye) {
-		to_stdout("view[1].distortion_fisheye", wrapped.view[1].distortion_fisheye_mat);
-	} else {
-		to_stdout("view[1].distortion", wrapped.view[1].distortion_mat);
-	}
+	to_stdout("view[1].distortion", wrapped.view[1].distortion_mat);
 	to_stdout("view[1].intrinsics", wrapped.view[1].intrinsics_mat);
 	to_stdout("view[1].projection", maps.view[1].projection_mat);
 	to_stdout("view[1].rotation", maps.view[1].rotation_mat);
···
 	cv::Mat intrinsics_mat = {};
 	cv::Mat new_intrinsics_mat = {};
 	cv::Mat distortion_mat = {};
-	cv::Mat distortion_fisheye_mat = {};
 
 	if (c.dump_measurements) {
 		U_LOG_RAW("...measured = (ArrayOfMeasurements){");
···
 		                                  view.measured_f64,        // imagePoints
 		                                  image_size,               // image_size
 		                                  intrinsics_mat,           // K (cameraMatrix 3x3)
-		                                  distortion_fisheye_mat,   // D (distCoeffs 4x1)
+		                                  distortion_mat,           // D (distCoeffs 4x1)
 		                                  cv::noArray(),            // rvecs
 		                                  cv::noArray(),            // tvecs
 		                                  flags,                    // flags
···
 
 		double balance = 0.1f;
 
-		cv::fisheye::estimateNewCameraMatrixForUndistortRectify(intrinsics_mat,         // K
-		                                                        distortion_fisheye_mat, // D
-		                                                        image_size,             // image_size
-		                                                        cv::Matx33d::eye(),     // R
-		                                                        new_intrinsics_mat,     // P
-		                                                        balance);               // balance
+		cv::fisheye::estimateNewCameraMatrixForUndistortRectify(intrinsics_mat,     // K
+		                                                        distortion_mat,     // D
+		                                                        image_size,         // image_size
+		                                                        cv::Matx33d::eye(), // R
+		                                                        new_intrinsics_mat, // P
+		                                                        balance);           // balance
 
 		// Probably a busted work-around for busted function.
 		new_intrinsics_mat.at<double>(0, 2) = (cols - 1) / 2.0;
···
 	std::cout << "rp_error: " << rp_error << "\n";
 	std::cout << "intrinsics_mat:\n" << intrinsics_mat << "\n";
 	std::cout << "new_intrinsics_mat:\n" << new_intrinsics_mat << "\n";
-	if (c.use_fisheye) {
-		std::cout << "distortion_fisheye_mat:\n" << distortion_fisheye_mat << "\n";
-	} else {
 		std::cout << "distortion_mat:\n" << distortion_mat << "\n";
-	}
 	// clang-format on
 
 	if (c.use_fisheye) {
-		cv::fisheye::initUndistortRectifyMap(intrinsics_mat,         // K
-		                                     distortion_fisheye_mat, // D
-		                                     cv::Matx33d::eye(),     // R
-		                                     new_intrinsics_mat,     // P
-		                                     image_size,             // size
-		                                     CV_32FC1,               // m1type
-		                                     view.map1,              // map1
-		                                     view.map2);             // map2
+		cv::fisheye::initUndistortRectifyMap(intrinsics_mat,     // K
+		                                     distortion_mat,     // D
+		                                     cv::Matx33d::eye(), // R
+		                                     new_intrinsics_mat, // P
+		                                     image_size,         // size
+		                                     CV_32FC1,           // m1type
+		                                     view.map1,          // map1
+		                                     view.map2);         // map2
 
 		// Set the maps as valid.
 		view.maps_valid = true;

src/xrt/auxiliary/tracking/t_calibration_opencv.hpp

···
 
 namespace xrt::auxiliary::tracking {
 
+static inline size_t
+t_num_opencv_params_from_distortion_model(const enum t_camera_distortion_model model)
+{
+	switch (model) {
+	case T_DISTORTION_WMR:
+		// OpenCV doesn't know what to do with codx, cody or rpmax. We reinterpret it as
+		// T_DISTORTION_OPENCV_RADTAN_8.
+		return t_num_params_from_distortion_model(T_DISTORTION_OPENCV_RADTAN_8);
+		break;
+	default: return t_num_params_from_distortion_model(model);
+	}
+}
 /*!
  * @brief Essential calibration data wrapped for C++.
  *
···
 	const cv::Size image_size_pixels_cv;
 	cv::Mat_<double> intrinsics_mat;
 	cv::Mat_<double> distortion_mat;
-	cv::Mat_<double> distortion_fisheye_mat;
-	bool &use_fisheye;
+	enum t_camera_distortion_model &distortion_model;
 
 	CameraCalibrationWrapper(t_camera_calibration &calib)
-	    : base(calib), image_size_pixels(calib.image_size_pixels),
-	      image_size_pixels_cv(calib.image_size_pixels.w, calib.image_size_pixels.h),
-	      intrinsics_mat(3, 3, &calib.intrinsics[0][0]),
-	      distortion_mat(base.distortion_num, 1, &calib.distortion[0]),
-	      distortion_fisheye_mat(4, 1, &calib.distortion_fisheye[0]), use_fisheye(calib.use_fisheye)
+	    : base(calib),                                                                //
+	      image_size_pixels(calib.image_size_pixels),                                 //
+	      image_size_pixels_cv(calib.image_size_pixels.w, calib.image_size_pixels.h), //
+	      intrinsics_mat(3, 3, &calib.intrinsics[0][0]),                              //
+	      distortion_mat(t_num_opencv_params_from_distortion_model(base.distortion_model),
+	                     1,
+	                     &calib.distortion_parameters_as_array[0]), //
+	      distortion_model(calib.distortion_model)
 	{
+		if (base.distortion_model == T_DISTORTION_WMR) {
+			U_LOG_W("Reinterpreting T_DISTORTION_WMR model as T_DISTORTION_OPENCV_RADTAN_8!");
+		}
 		assert(isDataStorageValid());
 	}
 
···
 	{
 		return intrinsics_mat.size() == cv::Size(3, 3) &&
 		       (double *)intrinsics_mat.data == &(base.intrinsics[0][0]) &&
-
-		       distortion_mat.size() == cv::Size(1, base.distortion_num) &&
-		       (double *)distortion_mat.data == &(base.distortion[0]) &&
-
-		       distortion_fisheye_mat.size() == cv::Size(1, 4) &&
-		       (double *)distortion_fisheye_mat.data == &(base.distortion_fisheye[0]);
+		       (base.distortion_model != T_DISTORTION_FISHEYE_KB4 || distortion_mat.size() == cv::Size(1, 4)) &&
+		       distortion_mat.size() ==
+		           cv::Size(1, t_num_opencv_params_from_distortion_model(base.distortion_model)) &&
+		       (double *)distortion_mat.data == &(base.distortion_parameters_as_array[0]);
 	}
 };
 
···
 
 
 	static t_stereo_camera_calibration *
-	allocData(uint32_t distortion_num)
+	allocData(enum t_camera_distortion_model distortion_model)
 	{
 		t_stereo_camera_calibration *data_ptr = NULL;
-		t_stereo_camera_calibration_alloc(&data_ptr, distortion_num);
+		t_stereo_camera_calibration_alloc(&data_ptr, distortion_model);
 		return data_ptr;
 	}
 
···
 		assert(isDataStorageValid());
 	}
 
-	StereoCameraCalibrationWrapper(uint32_t distortion_num)
-	    : StereoCameraCalibrationWrapper(allocData(distortion_num))
+	StereoCameraCalibrationWrapper(enum t_camera_distortion_model distortion_model)
+	    : StereoCameraCalibrationWrapper(allocData(distortion_model))
 	{
 
 		// The function allocData returns with a ref count of one,

src/xrt/auxiliary/tracking/t_data_utils.c

···
 {
 	char buf[1024];
 	ssize_t curr = 0;
-
-	U_LOG_RAW("use_fisheye = %s", view->use_fisheye ? "true" : "false");
+	U_LOG_RAW("distortion_model = %s", t_stringify_camera_distortion_model(view->distortion_model));
 
-	if (view->use_fisheye) {
-		P("distortion_fisheye = [");
-		for (uint32_t col = 0; col < 4; col++) {
-			P("%f", view->distortion_fisheye[col]);
-			if (col < 3) {
-				P(", ");
-			}
+	P("distortion = [");
+	size_t num = t_num_params_from_distortion_model(view->distortion_model);
+	for (uint32_t col = 0; col < num; col++) {
+		P("%f", view->distortion_parameters_as_array[col]);
+		if (col < num - 1) {
+			P(", ");
 		}
-		P("]");
-	} else {
-		P("distortion = [");
-		for (uint32_t col = 0; col < view->distortion_num; col++) {
-			P("%f", view->distortion[col]);
-			if (col < view->distortion_num - 1) {
-				P(", ");
-			}
-		}
-		P("]");
 	}
+	P("]");
+
 	U_LOG_RAW("%s", buf);
 }
 
···
  */
 
 void
-t_stereo_camera_calibration_alloc(struct t_stereo_camera_calibration **out_c, uint32_t distortion_num)
+t_stereo_camera_calibration_alloc(struct t_stereo_camera_calibration **out_c,
+                                  const enum t_camera_distortion_model distortion_model)
 {
-	// Four parameters for kannala-brandt, 5, 8, 12, or 14 for the normal OpenCV pinhole distortion model
-	assert(distortion_num == 4 || distortion_num == 5 || distortion_num == 8 || distortion_num == 12 ||
-	       distortion_num == 14);
-
 	struct t_stereo_camera_calibration *c = U_TYPED_CALLOC(struct t_stereo_camera_calibration);
-	c->view[0].distortion_num = distortion_num;
-	c->view[1].distortion_num = distortion_num;
+	c->view[0].distortion_model = distortion_model;
+	c->view[1].distortion_model = distortion_model;
 	t_stereo_camera_calibration_reference(out_c, c);
 }
 

src/xrt/auxiliary/tracking/t_file.cpp

···
 		return false;                                                                                          \
 	}
 
+#define COPY(TO, FROM)                                                                                                 \
+	do {                                                                                                           \
+		CALIB_ASSERT(FROM.size() == TO.size(), "Sizes doesn't match for " #FROM);                              \
+		FROM.copyTo(TO);                                                                                       \
+	} while (false)
+
+
 /*
  *
  * Pre-declar functions.
···
 	//              calibration for does not match what was saved
 	cv::Size image_size(calib.image_size_pixels.w, calib.image_size_pixels.h);
 
-	if (calib.use_fisheye) {
-		cv::fisheye::initUndistortRectifyMap(wrap.intrinsics_mat,         // cameraMatrix
-		                                     wrap.distortion_fisheye_mat, // distCoeffs
-		                                     rectify_transform_optional,  // R
-		                                     new_camera_matrix_optional,  // newCameraMatrix
-		                                     image_size,                  // size
-		                                     CV_32FC1,                    // m1type
-		                                     ret.remap_x,                 // map1
-		                                     ret.remap_y);                // map2
-	} else {
+	switch (calib.distortion_model) {
+	case (T_DISTORTION_FISHEYE_KB4):
+		cv::fisheye::initUndistortRectifyMap(wrap.intrinsics_mat,        // cameraMatrix
+		                                     wrap.distortion_mat,        // distCoeffs
+		                                     rectify_transform_optional, // R
+		                                     new_camera_matrix_optional, // newCameraMatrix
+		                                     image_size,                 // size
+		                                     CV_32FC1,                   // m1type
+		                                     ret.remap_x,                // map1
+		                                     ret.remap_y);               // map2
+		break;
+	case T_DISTORTION_OPENCV_RADTAN_5:
 		cv::initUndistortRectifyMap(wrap.intrinsics_mat,        // cameraMatrix
 		                            wrap.distortion_mat,        // distCoeffs
 		                            rectify_transform_optional, // R
···
 		                            CV_32FC1,                   // m1type
 		                            ret.remap_x,                // map1
 		                            ret.remap_y);               // map2
+		break;
+	default: assert(false);
 	}
 
 	return ret;
···
 	CALIB_ASSERT_(data->view[0].image_size_pixels.w == data->view[1].image_size_pixels.w);
 	CALIB_ASSERT_(data->view[0].image_size_pixels.h == data->view[1].image_size_pixels.h);
 
-	CALIB_ASSERT_(data->view[0].use_fisheye == data->view[1].use_fisheye);
+	CALIB_ASSERT_(data->view[0].distortion_model == data->view[1].distortion_model);
 
 	cv::Size image_size(data->view[0].image_size_pixels.w, data->view[0].image_size_pixels.h);
 	StereoCameraCalibrationWrapper wrapped(data);
···
 	 *
 	 * Here cv::noArray() means zero distortion.
 	 */
-	if (data->view[0].use_fisheye) {
+	switch (data->view[0].distortion_model) {
+	case T_DISTORTION_FISHEYE_KB4: {
 #if 0
 		//! @todo for some reason this looks weird?
 		// Alpha of 1.0 kinda works, not really.
···
 
 		cv::fisheye::stereoRectify(
 		    wrapped.view[0].intrinsics_mat,         // K1
-		    wrapped.view[0].distortion_fisheye_mat, // D1
+		    wrapped.view[0].distortion_mat,         // D1
 		    wrapped.view[1].intrinsics_mat,         // K2
-		    wrapped.view[1].distortion_fisheye_mat, // D2
+		    wrapped.view[1].distortion_mat,         // D2
 		    image_size,                             // imageSize
 		    wrapped.camera_rotation_mat,            // R
 		    wrapped.camera_translation_mat,         // tvec
···
 		                  NULL,                           // validPixROI1
 		                  NULL);                          // validPixROI2
 #endif
-	} else {
+	} break;
+	case T_DISTORTION_OPENCV_RADTAN_5: {
 		// Have the same principal point on both.
 		int flags = cv::CALIB_ZERO_DISPARITY;
 		// Get all of the pixels from the camera.
···
 		                  cv::Size(),                     // newImageSize
 		                  NULL,                           // validPixROI1
 		                  NULL);                          // validPixROI2
+	} break;
+	default: assert(false);
 	}
 
 	view[0].rectify = calibration_get_undistort_map(data->view[0], view[0].rotation_mat, view[0].projection_mat);
···
 extern "C" bool
 t_stereo_camera_calibration_load_v1(FILE *calib_file, struct t_stereo_camera_calibration **out_data)
 {
-
-	t_stereo_camera_calibration *data_ptr = NULL;
-	t_stereo_camera_calibration_alloc(&data_ptr, 5); // Hardcoded to 5 distortion parameters.
-	StereoCameraCalibrationWrapper wrapped(data_ptr);
-
 	// Scratch-space temporary matrix
 	cv::Mat scratch;
 
+	// Temp load matricies
+	cv::Mat_<double> l_intrinsics(3, 3);
+	cv::Mat_<double> r_intrinsics(3, 3);
+	cv::Mat_<double> l_distortion(5, 1);
+	cv::Mat_<double> r_distortion(5, 1);
+	cv::Mat_<double> l_distortion_fisheye(4, 1);
+	cv::Mat_<double> r_distortion_fisheye(4, 1);
+	cv::Mat_<double> translation(3, 1);
+	cv::Mat_<double> rotation(3, 3);
+	cv::Mat_<double> essential(3, 3);
+	cv::Mat_<double> fundamental(3, 3);
+	cv::Mat_<float> mat_use_fisheye(1, 1, {0.0f}); // Ensure is initialised.
+	cv::Mat_<float> mat_image_size(1, 2);
+	cv::Mat_<float> mat_new_image_size(1, 2);
+
 	// Read our calibration from this file
-	// clang-format off
-	cv::Mat_<float> mat_image_size(2, 1);
-	bool result = read_cv_mat(calib_file, &wrapped.view[0].intrinsics_mat, "l_intrinsics"); // 3 x 3
-	result = result && read_cv_mat(calib_file, &wrapped.view[1].intrinsics_mat, "r_intrinsics"); // 3 x 3
-	result = result && read_cv_mat(calib_file, &wrapped.view[0].distortion_mat, "l_distortion"); // 5 x 1
-	result = result && read_cv_mat(calib_file, &wrapped.view[1].distortion_mat, "r_distortion"); // 5 x 1
-	result = result && read_cv_mat(calib_file, &wrapped.view[0].distortion_fisheye_mat, "l_distortion_fisheye"); // 4 x 1
-	result = result && read_cv_mat(calib_file, &wrapped.view[1].distortion_fisheye_mat, "r_distortion_fisheye"); // 4 x 1
-	result = result && read_cv_mat(calib_file, &scratch, "l_rotation"); // 3 x 3
-	result = result && read_cv_mat(calib_file, &scratch, "r_rotation"); // 3 x 3
-	result = result && read_cv_mat(calib_file, &scratch, "l_translation"); // empty
-	result = result && read_cv_mat(calib_file, &scratch, "r_translation"); // empty
-	result = result && read_cv_mat(calib_file, &scratch, "l_projection"); // 3 x 4
-	result = result && read_cv_mat(calib_file, &scratch, "r_projection"); // 3 x 4
-	result = result && read_cv_mat(calib_file, &scratch, "disparity_to_depth");  // 4 x 4
+	bool result = read_cv_mat(calib_file, &l_intrinsics, "l_intrinsics");                      // 3 x 3
+	result = result && read_cv_mat(calib_file, &r_intrinsics, "r_intrinsics");                 // 3 x 3
+	result = result && read_cv_mat(calib_file, &l_distortion, "l_distortion");                 // 5 x 1
+	result = result && read_cv_mat(calib_file, &r_distortion, "r_distortion");                 // 5 x 1
+	result = result && read_cv_mat(calib_file, &l_distortion_fisheye, "l_distortion_fisheye"); // 4 x 1
+	result = result && read_cv_mat(calib_file, &r_distortion_fisheye, "r_distortion_fisheye"); // 4 x 1
+	result = result && read_cv_mat(calib_file, &scratch, "l_rotation");                        // 3 x 3
+	result = result && read_cv_mat(calib_file, &scratch, "r_rotation");                        // 3 x 3
+	result = result && read_cv_mat(calib_file, &scratch, "l_translation");                     // empty
+	result = result && read_cv_mat(calib_file, &scratch, "r_translation");                     // empty
+	result = result && read_cv_mat(calib_file, &scratch, "l_projection");                      // 3 x 4
+	result = result && read_cv_mat(calib_file, &scratch, "r_projection");                      // 3 x 4
+	result = result && read_cv_mat(calib_file, &scratch, "disparity_to_depth");                // 4 x 4
 	result = result && read_cv_mat(calib_file, &mat_image_size, "mat_image_size");
 
 	if (!result) {
 		CALIB_WARN("Re-run calibration!");
 		return false;
 	}
-	wrapped.view[0].image_size_pixels.w = uint32_t(mat_image_size(0, 0));
-	wrapped.view[0].image_size_pixels.h = uint32_t(mat_image_size(0, 1));
-	wrapped.view[1].image_size_pixels = wrapped.view[0].image_size_pixels;
 
-	cv::Mat mat_new_image_size = mat_image_size.clone();
 	if (read_cv_mat(calib_file, &mat_new_image_size, "mat_new_image_size")) {
 		// do nothing particular here.
 	}
-
-	if (!read_cv_mat(calib_file, &wrapped.camera_translation_mat, "translation")) {
+	if (!read_cv_mat(calib_file, &translation, "translation")) { // 3 x 1
 		CALIB_WARN("Re-run calibration!");
 	}
-	if (!read_cv_mat(calib_file, &wrapped.camera_rotation_mat, "rotation")) {
+	if (!read_cv_mat(calib_file, &rotation, "rotation")) { // 3 x 3
 		CALIB_WARN("Re-run calibration!");
 	}
-	if (!read_cv_mat(calib_file, &wrapped.camera_essential_mat, "essential")) {
+	if (!read_cv_mat(calib_file, &essential, "essential")) { // 3 x 3
 		CALIB_WARN("Re-run calibration!");
 	}
-	if (!read_cv_mat(calib_file, &wrapped.camera_fundamental_mat, "fundamental")) {
+	if (!read_cv_mat(calib_file, &fundamental, "fundamental")) { // 3 x 3
 		CALIB_WARN("Re-run calibration!");
 	}
-
-	cv::Mat_<float> mat_use_fisheye(1, 1);
 	if (!read_cv_mat(calib_file, &mat_use_fisheye, "use_fisheye")) {
-		wrapped.view[0].use_fisheye = false;
 		CALIB_WARN("Re-run calibration! (Assuming not fisheye)");
+	}
+
+
+	/*
+	 * Extract some data.
+	 */
+
+	bool is_fisheye = mat_use_fisheye(0, 0) != 0.0f;
+	uint32_t size_w = uint32_t(mat_image_size(0, 0));
+	uint32_t size_h = uint32_t(mat_image_size(0, 1));
+	t_camera_distortion_model model = is_fisheye ? T_DISTORTION_FISHEYE_KB4 : T_DISTORTION_OPENCV_RADTAN_5;
+
+
+	/*
+	 * Copy to calibration struct.
+	 */
+
+	t_stereo_camera_calibration *data_ptr = NULL;
+	t_stereo_camera_calibration_alloc(&data_ptr, model);
+	StereoCameraCalibrationWrapper wrapped(data_ptr);
+
+	COPY(wrapped.view[0].intrinsics_mat, l_intrinsics);
+	COPY(wrapped.view[1].intrinsics_mat, r_intrinsics);
+	if (is_fisheye) {
+		COPY(wrapped.view[0].distortion_mat, l_distortion_fisheye);
+		COPY(wrapped.view[1].distortion_mat, r_distortion_fisheye);
 	} else {
-		wrapped.view[0].use_fisheye = mat_use_fisheye(0, 0) != 0.0f;
+		COPY(wrapped.view[0].distortion_mat, l_distortion);
+		COPY(wrapped.view[1].distortion_mat, r_distortion);
 	}
-	wrapped.view[1].use_fisheye = wrapped.view[0].use_fisheye;
-	// clang-format on
+	COPY(wrapped.camera_translation_mat, translation);
+	COPY(wrapped.camera_rotation_mat, rotation);
+	COPY(wrapped.camera_essential_mat, essential);
+	COPY(wrapped.camera_fundamental_mat, fundamental);
+	wrapped.view[0].image_size_pixels.w = wrapped.view[1].image_size_pixels.w = size_w;
+	wrapped.view[0].image_size_pixels.h = wrapped.view[1].image_size_pixels.h = size_h;
 
 	CALIB_ASSERT_(wrapped.isDataStorageValid());
 
···
 	return success;
 }
 
+//!@todo merge these with t_tracking.h
 #define PINHOLE_RADTAN5 "pinhole_radtan5"
 #define FISHEYE_EQUIDISTANT4 "fisheye_equidistant4"
 
···
 
 	size_t n = jc["distortion"].asObject().size();
 	if (model == PINHOLE_RADTAN5) {
-		cc->use_fisheye = false;
+		cc->distortion_model = T_DISTORTION_OPENCV_RADTAN_5;
 		CALIB_ASSERTR(n == 5, "%zu != 5 distortion params", n);
 
-		constexpr array names{"k1", "k2", "p1", "p2", "k3"};
-		for (size_t i = 0; i < n; i++) {
-			cc->distortion[i] = jc["distortion"][names[i]].asDouble();
-		}
+		cc->rt5.k1 = jc["distortion"]["k1"].asDouble();
+		cc->rt5.k2 = jc["distortion"]["k2"].asDouble();
+		cc->rt5.p1 = jc["distortion"]["p1"].asDouble();
+		cc->rt5.p2 = jc["distortion"]["p2"].asDouble();
+		cc->rt5.k3 = jc["distortion"]["k3"].asDouble();
 	} else if (model == FISHEYE_EQUIDISTANT4) {
-		cc->use_fisheye = true;
+		cc->distortion_model = T_DISTORTION_FISHEYE_KB4;
 		CALIB_ASSERTR(n == 4, "%zu != 4 distortion params", n);
 
-		constexpr array names{"k1", "k2", "k3", "k4"};
-		for (size_t i = 0; i < n; i++) {
-			cc->distortion_fisheye[i] = jc["distortion"][names[i]].asDouble();
-		}
+		cc->kb4.k1 = jc["distortion"]["k1"].asDouble();
+		cc->kb4.k2 = jc["distortion"]["k2"].asDouble();
+		cc->kb4.k3 = jc["distortion"]["k3"].asDouble();
+		cc->kb4.k4 = jc["distortion"]["k4"].asDouble();
 	} else {
 		CALIB_ASSERTR(false, "Invalid camera model: '%s'", model.c_str());
 		return false;
···
 t_stereo_camera_calibration_from_json_v2(cJSON *cjson, struct t_stereo_camera_calibration **out_stereo)
 {
 	JSONNode json{cjson};
-	StereoCameraCalibrationWrapper stereo{5}; // Hardcoded to 5 distortion parameters.
 
 	// Load file metadata
 	const int supported_version = 2;
···
 	}
 	CALIB_ASSERTR(version == supported_version, "Calibration json version (%d) != %d", version, supported_version);
 
+	// Temporary camera calibration structs so we can infer the distortion model easily
+	t_camera_calibration tmp_calibs[2];
+
 	// Load cameras
 	vector<JSONNode> cameras = json["cameras"].asArray();
 	bool okmats = true;
 	CALIB_ASSERTR(cameras.size() == 2, "Two cameras must be specified, %zu given", cameras.size());
 	for (size_t i = 0; i < cameras.size(); i++) {
 		JSONNode jc = cameras[i];
-		CameraCalibrationWrapper &cc = stereo.view[i];
-		bool loaded = t_camera_calibration_load_v2(jc.getCJSON(), &cc.base);
+		bool loaded = t_camera_calibration_load_v2(jc.getCJSON(), &tmp_calibs[i]);
 		CALIB_ASSERTR(loaded, "Unable to load camera calibration: %s", jc.toString(false).c_str());
 	}
 
+	t_camera_distortion_model model = tmp_calibs[0].distortion_model;
+
+	//!@todo  At some point it'll make sense to support different distortion models per-camera, but right now we
+	//! don't have any cameras like that and the way t_stereo_camera_calib_alloc and
+	//!(Stereo)CameraCalibrationWrapper work makes it pretty annoying.
+
+	CALIB_ASSERT_(tmp_calibs[0].distortion_model == tmp_calibs[1].distortion_model);
+
+	StereoCameraCalibrationWrapper stereo{model};
+
+	stereo.view[0].base = tmp_calibs[0];
+	stereo.view[1].base = tmp_calibs[1];
+
+
 	JSONNode rel = json["opencv_stereo_calibrate"];
 	okmats &= load_mat_field(rel["rotation"], 3, 3, stereo.camera_rotation_mat);
 	okmats &= load_mat_field(rel["translation"], 3, 1, stereo.camera_translation_mat);
···
 	CALIB_WARN("Deprecated function: %s", __func__);
 
 	StereoCameraCalibrationWrapper wrapped(data);
+
+	bool is_fisheye = false;
+
+	switch (data->view[0].distortion_model) {
+	case T_DISTORTION_OPENCV_RADTAN_5: is_fisheye = false; break;
+	case T_DISTORTION_FISHEYE_KB4: is_fisheye = true; break;
+	default:
+		CALIB_ERROR("Can't save distortion model %s in a v1 calib file!",
+		            t_stringify_camera_distortion_model(data->view[0].distortion_model));
+		return false;
+	}
+
+	if (data->view[0].distortion_model != data->view[1].distortion_model) {
+		CALIB_ERROR("v1 calibrations can't deal with differing distortion models!");
+		return false;
+	}
+
 	// Scratch-space temporary matrix
 	cv::Mat scratch;
 
 	write_cv_mat(calib_file, &wrapped.view[0].intrinsics_mat);
 	write_cv_mat(calib_file, &wrapped.view[1].intrinsics_mat);
-	write_cv_mat(calib_file, &wrapped.view[0].distortion_mat);
-	write_cv_mat(calib_file, &wrapped.view[1].distortion_mat);
-	write_cv_mat(calib_file, &wrapped.view[0].distortion_fisheye_mat);
-	write_cv_mat(calib_file, &wrapped.view[1].distortion_fisheye_mat);
+	if (is_fisheye) {
+		cv::Mat_<double> distortion(5, 1, {0.0});
+		write_cv_mat(calib_file, &distortion); // l_distortion
+		write_cv_mat(calib_file, &distortion); // r_distortion
+		write_cv_mat(calib_file, &wrapped.view[0].distortion_mat);
+		write_cv_mat(calib_file, &wrapped.view[1].distortion_mat);
+	} else {
+		cv::Mat_<double> distortion_fisheye(4, 1, {0.0});
+		write_cv_mat(calib_file, &wrapped.view[0].distortion_mat);
+		write_cv_mat(calib_file, &wrapped.view[1].distortion_mat);
+		write_cv_mat(calib_file, &distortion_fisheye); // l_distortion_fisheye
+		write_cv_mat(calib_file, &distortion_fisheye); // r_distortion_fisheye
+	}
+
 	write_cv_mat(calib_file, &scratch); // view[0].rotation_mat
 	write_cv_mat(calib_file, &scratch); // view[1].rotation_mat
 	write_cv_mat(calib_file, &scratch); // l_translation
···
 
 	cv::Mat mat_use_fisheye;
 	mat_use_fisheye.create(1, 1, CV_32F);
-	mat_use_fisheye.at<float>(0, 0) = wrapped.view[0].use_fisheye;
+	mat_use_fisheye.at<float>(0, 0) = is_fisheye;
 	write_cv_mat(calib_file, &mat_use_fisheye);
 
 	return true;
···
 extern "C" bool
 t_stereo_camera_calibration_to_json_v2(cJSON **out_cjson, struct t_stereo_camera_calibration *data)
 {
+	if (data->view[0].distortion_model != data->view[1].distortion_model) {
+		CALIB_ASSERTR(false,
+		              "Can't deal with a stereo camera calibration with different distortion models per-view!");
+	}
+
+	if (data->view[0].distortion_model != T_DISTORTION_FISHEYE_KB4 &&
+	    data->view[0].distortion_model != T_DISTORTION_OPENCV_RADTAN_5) {
+		CALIB_ASSERTR(false, "Can only deal with fisheye or radtan5 distortion models!");
+	}
+
 	StereoCameraCalibrationWrapper wrapped(data);
 	JSONBuilder jb{};
 
···
 	// Cameras
 	for (size_t i = 0; i < 2; i++) {
 		const auto &view = wrapped.view[i];
+		bool fisheye = view.distortion_model == T_DISTORTION_FISHEYE_KB4;
 		jb << "{";
-		jb << "model" << (view.use_fisheye ? FISHEYE_EQUIDISTANT4 : PINHOLE_RADTAN5);
+		jb << "model" << (fisheye ? FISHEYE_EQUIDISTANT4 : PINHOLE_RADTAN5);
 
 		jb << "intrinsics";
 		jb << "{";
···
 
 		jb << "distortion";
 		jb << "{";
-		if (view.use_fisheye) {
-			int n = view.distortion_fisheye_mat.size().area(); // Number of distortion parameters
+		if (fisheye) {
+			int n = view.distortion_mat.size().area(); // Number of distortion parameters
 			CALIB_ASSERT_(n == 4);
 
 			constexpr array names{"k1", "k2", "k3", "k4"};
 			for (int i = 0; i < n; i++) {
-				jb << names[i] << view.distortion_fisheye_mat(i);
+				jb << names[i] << view.distortion_mat(i);
 			}
 		} else {
 			int n = view.distortion_mat.size().area(); // Number of distortion parameters

src/xrt/auxiliary/tracking/t_tracker_psmv.cpp

···
 
 	cv::Matx33d intrinsics;
 	cv::Mat distortion; // size may vary
-	cv::Vec4d distortion_fisheye;
-	bool use_fisheye;
+	enum t_camera_distortion_model distortion_model;
 
 	std::vector<cv::KeyPoint> keypoints;
 
···
 		CameraCalibrationWrapper wrap(calib);
 		intrinsics = wrap.intrinsics_mat;
 		distortion = wrap.distortion_mat.clone();
-		distortion_fisheye = wrap.distortion_fisheye_mat;
-		use_fisheye = wrap.use_fisheye;
+		distortion_model = wrap.distortion_model;
 
 		undistort_rectify_map_x = rectification.remap_x;
 		undistort_rectify_map_y = rectification.remap_y;

src/xrt/auxiliary/tracking/t_tracker_psvr.cpp

···
 
 	cv::Matx33d intrinsics;
 	cv::Mat distortion; // size may vary
-	cv::Vec4d distortion_fisheye;
-	bool use_fisheye;
+	enum t_camera_distortion_model distortion_model;
 
 	std::vector<cv::KeyPoint> keypoints;
 
···
 		CameraCalibrationWrapper wrap(calib);
 		intrinsics = wrap.intrinsics_mat;
 		distortion = wrap.distortion_mat.clone();
-		distortion_fisheye = wrap.distortion_fisheye_mat;
-		use_fisheye = wrap.use_fisheye;
+		distortion_model = wrap.distortion_model;
 
 		undistort_rectify_map_x = rectification.remap_x;
 		undistort_rectify_map_y = rectification.remap_y;

src/xrt/auxiliary/tracking/t_tracker_slam.cpp

···
 		params->cx = view.intrinsics[0][2];
 		params->cy = view.intrinsics[1][2];
 
-		params->distortion_model = view.use_fisheye ? "kb4" : string{"rt"} + to_string(view.distortion_num);
-		if (view.use_fisheye) { // Kannala-brandt pinhole (OpenCV's "fisheye")
-			params->distortion.assign(view.distortion_fisheye, std::end(view.distortion_fisheye));
+		switch (view.distortion_model) {
+		case T_DISTORTION_OPENCV_RADTAN_8:
+			params->distortion_model = "rt8";
+			params->distortion.push_back(view.rt8.k1);
+			params->distortion.push_back(view.rt8.k2);
+			params->distortion.push_back(view.rt8.p1);
+			params->distortion.push_back(view.rt8.p2);
+			params->distortion.push_back(view.rt8.k3);
+			params->distortion.push_back(view.rt8.k4);
+			params->distortion.push_back(view.rt8.k5);
+			params->distortion.push_back(view.rt8.k6);
+			// -1 metric radius tells Basalt to calculate the metric radius on its own.
+			params->distortion.push_back(-1.0);
+			SLAM_ASSERT_(params->distortion.size() == 9);
+			break;
+		case T_DISTORTION_WMR:
+			params->distortion_model = "rt8";
+			params->distortion.push_back(view.wmr.k1);
+			params->distortion.push_back(view.wmr.k2);
+			params->distortion.push_back(view.wmr.p1);
+			params->distortion.push_back(view.wmr.p2);
+			params->distortion.push_back(view.wmr.k3);
+			params->distortion.push_back(view.wmr.k4);
+			params->distortion.push_back(view.wmr.k5);
+			params->distortion.push_back(view.wmr.k6);
+			params->distortion.push_back(view.wmr.rpmax);
+			SLAM_ASSERT_(params->distortion.size() == 9);
+			break;
+		case T_DISTORTION_FISHEYE_KB4:
+			params->distortion_model = "kb4";
+			params->distortion.push_back(view.kb4.k1);
+			params->distortion.push_back(view.kb4.k2);
+			params->distortion.push_back(view.kb4.k3);
+			params->distortion.push_back(view.kb4.k4);
 			SLAM_ASSERT_(params->distortion.size() == 4);
-		} else { // Radial-tangential pinhole
-			params->distortion.assign(view.distortion, view.distortion + view.distortion_num);
-
-			if (params->distortion_model == "rt8") { // rt8 has a ninth parameter rpmax ("metric_radius")
-				params->distortion.push_back(extra.rpmax);
-			}
+			break;
+		default:
+			SLAM_ASSERT(false, "SLAM doesn't support distortion type %s",
+			            t_stringify_camera_distortion_model(view.distortion_model));
 		}
 
 		xrt_matrix_4x4 T; // Row major T_imu_cam

src/xrt/auxiliary/tracking/t_tracking.h

···
-// Copyright 2019-2021, Collabora, Ltd.
+// Copyright 2019-2023, Collabora, Ltd.
 // SPDX-License-Identifier: BSL-1.0
 /*!
  * @file
···
  * @author Pete Black <[e-mail]>
  * @author Jakob Bornecrantz <[e-mail]>
  * @author Ryan Pavlik <[e-mail]>
+ * @author Moses Turner <[e-mail]>
  * @ingroup aux_tracking
  */
 
···
 #define XRT_DISTORTION_MAX_DIM (14)
 
 /*!
+ * @brief The distortion model this camera calibration falls under.
+ * @todo Add RiftS's Fisheye62 to this enumerator once we have native support for it in our hand tracking and SLAM.
+ * @todo Feel free to add support for T_DISTORTION_OPENCV_RADTAN_4 or T_DISTORTION_OPENCV_RADTAN_12 whenever you have a
+ * camera that uses those.
+ */
+enum t_camera_distortion_model
+{
+	/*!
+	 * OpenCV's radial-tangential distortion model. Exactly equivalent to the distortion model from OpenCV's calib3d
+	 * module with just the first five parameters. This may be reinterpreted as RT8 with the last three parameters
+	 * zeroed out, which is 100% valid and results in exactly equivalent (un)projections.
+	 *
+	 * Parameters:
+	 *
+	 * \f[(k_1, k_2, p_1, p_2, k_3)\f]
+	 */
+	T_DISTORTION_OPENCV_RADTAN_5,
+
+	/*!
+	 * OpenCV's radial-tangential distortion model. Exactly equivalent to the distortion model from OpenCV's calib3d
+	 * module, with just the first 8 parameters.
+	 * Parameters:
+	 *
+	 * \f[(k_1, k_2, p_1, p_2, k_3, k_4, k_5, k_6)\f]
+	 */
+	T_DISTORTION_OPENCV_RADTAN_8,
+
+	/*!
+	 * OpenCV's radial-tangential distortion model. Exactly equivalent to the distortion model from OpenCV's calib3d
+	 * module, with all 14 parameters.
+	 *
+	 * In practice this is reinterpreted as RT8 because the last 6 parameters are almost always approximately 0.
+	 *
+	 * @todo Feel free to implement RT14 (un)projection functions if you have a camera that actually has a tilted
+	 * sensor.
+	 *
+	 * Parameters:
+	 *
+	 * \f[(k_1, k_2, p_1, p_2, k_3, k_4, k_5, k_6, s_1, s_2, s_3, s_4, \tau_x, \tau_y)\f]
+	 *
+	 * All known factory-calibrated Luxonis cameras use this distortion model, and in all known cases their last 6
+	 * parameters are approximately 0.
+	 *
+	 */
+	T_DISTORTION_OPENCV_RADTAN_14,
+
+	/*!
+	 * Juho Kannalla and Sami Sebastian Brandt's fisheye distortion model. Exactly equivalent to the distortion
+	 * model from OpenCV's calib3d/fisheye module.
+	 *
+	 * Parameters:
+	 *
+	 * \f[(k_1, k_2, k_3, k_4)\f]
+	 *
+	 * Many cameras use this model. Here's a non-exhaustive list of cameras Monado knows about that fall under this
+	 * model:
+	 * * Intel T265
+	 * * Valve Index
+	 */
+	T_DISTORTION_FISHEYE_KB4,
+
+	/*!
+	 * Windows Mixed Reality headsets' camera model.
+	 *
+	 * The model is listed as CALIBRATION_LensDistortionModelRational6KT in the WMR json files, which seems to be
+	 * equivalent to Azure-Kinect-Sensor-SDK's K4A_CALIBRATION_LENS_DISTORTION_MODEL_RATIONAL_6KT.
+	 *
+	 * The only difference between this model and RT8 are codx, cody, and the way p1 and p2 are interpreted. In
+	 * practice we reinterpret this as RT8 because those values are almost always approximately 0 for WMR headsets.
+	 *
+	 * Parameters:
+	 *
+	 * \f[(k_1, k_2, p_1, p_2, k_3, k_4, k_5, k_6, cod_x, cod_y, rpmax)\f]
+	 */
+	T_DISTORTION_WMR,
+};
+
+
+/*!
+ * Stringifies a @ref enum t_camera_distortion_model
+ * @param model The distortion model to be stringified
+ * @return The distortion model as a string
+ */
+static inline const char *
+t_stringify_camera_distortion_model(const enum t_camera_distortion_model model)
+{
+	switch (model) {
+	case T_DISTORTION_OPENCV_RADTAN_5: return "T_DISTORTION_OPENCV_RADTAN_5"; break;
+	case T_DISTORTION_OPENCV_RADTAN_8: return "T_DISTORTION_OPENCV_RADTAN_8"; break;
+	case T_DISTORTION_OPENCV_RADTAN_14: return "T_DISTORTION_OPENCV_RADTAN_14"; break;
+	case T_DISTORTION_WMR: return "T_DISTORTION_WMR"; break;
+	case T_DISTORTION_FISHEYE_KB4: return "T_DISTORTION_FISHEYE_KB4"; break;
+	default: U_LOG_E("Invalid distortion_model! %d", model); return "INVALID";
+	}
+}
+
+/*!
+ * Returns the number of parameters needed for this @ref enum t_camera_distortion_model to be held by an OpenCV Mat and
+ * correctly interpreted by OpenCV's (un)projection functions.
+ *
+ * @param model The distortion model in question
+ * @return The number of distortion coefficients, or 0 if this model cannot be represented inside OpenCV.
+ */
+static inline size_t
+t_num_params_from_distortion_model(const enum t_camera_distortion_model model)
+{
+	switch (model) {
+	case T_DISTORTION_OPENCV_RADTAN_5: return 5; break;
+	case T_DISTORTION_OPENCV_RADTAN_8: return 8; break;
+	case T_DISTORTION_OPENCV_RADTAN_14: return 14; break;
+	case T_DISTORTION_WMR: return 11; break;
+	case T_DISTORTION_FISHEYE_KB4: return 4; break;
+	default: U_LOG_E("Invalid distortion_model! %d", model); return 0;
+	}
+}
+
+/*!
+ * Parameters for @ref T_DISTORTION_OPENCV_RADTAN_5
+ * @ingroup aux_tracking
+ */
+struct t_camera_calibration_rt5_params
+{
+	double k1, k2, p1, p2, k3;
+};
+
+/*!
+ * Parameters for @ref T_DISTORTION_OPENCV_RADTAN_8
+ * @ingroup aux_tracking
+ */
+struct t_camera_calibration_rt8_params
+{
+	double k1, k2, p1, p2, k3, k4, k5, k6;
+};
+
+/*!
+ * Parameters for @ref T_DISTORTION_OPENCV_RADTAN_14
+ * @ingroup aux_tracking
+ */
+struct t_camera_calibration_rt14_params
+{
+	double k1, k2, p1, p2, k3, k4, k5, k6, s1, s2, s3, s4, tx, ty;
+};
+
+/*!
+ * Parameters for @ref T_DISTORTION_FISHEYE_KB4
+ * @ingroup aux_tracking
+ */
+struct t_camera_calibration_kb4_params
+{
+	double k1, k2, k3, k4;
+};
+
+/*!
+ * Parameters for @ref T_DISTORTION_WMR
+ * @ingroup aux_tracking
+ */
+struct t_camera_calibration_wmr_params
+{
+	double k1, k2, p1, p2, k3, k4, k5, k6, codx, cody, rpmax;
+};
+
+/*!
  * @brief Essential calibration data for a single camera, or single lens/sensor
  * of a stereo camera.
  */
···
 	//! Camera intrinsics matrix
 	double intrinsics[3][3];
 
-	//! Number of distortion parameters (non-fisheye).
-	size_t distortion_num;
+	union {
+		struct t_camera_calibration_rt5_params rt5;
+		struct t_camera_calibration_rt8_params rt8;
+		struct t_camera_calibration_rt14_params rt14;
+		struct t_camera_calibration_kb4_params kb4;
+		struct t_camera_calibration_wmr_params wmr;
+		double distortion_parameters_as_array[XRT_DISTORTION_MAX_DIM];
+	};
 
-	//! Rectilinear distortion coefficients: k1, k2, p1, p2[, k3[, k4, k5, k6[, s1, s2, s3, s4[, Tx, Ty]]]]
-	double distortion[XRT_DISTORTION_MAX_DIM];
-
-	//! Fisheye camera distortion coefficients
-	double distortion_fisheye[4];
 
-	//! Is the camera fisheye?
-	bool use_fisheye;
+	//! Distortion model that this camera uses.
+	enum t_camera_distortion_model distortion_model;
 };
 
 /*!
···
 /*!
  * Allocates a new stereo calibration data, unreferences the old data pointed to by @p out_c.
  *
- * Also initializes t_camera_calibration::distortion_num in t_stereo_camera_calibration::view, only 5 and 14 is
- * accepted.
- *
  * @public @memberof t_stereo_camera_calibration
  */
 void
-t_stereo_camera_calibration_alloc(struct t_stereo_camera_calibration **out_c, uint32_t distortion_num);
+t_stereo_camera_calibration_alloc(struct t_stereo_camera_calibration **out_c,
+                                  const enum t_camera_distortion_model distortion_model);
 
 /*!
  * Only to be called by @p t_stereo_camera_calibration_reference.
···
 	{
 		double frequency;                //!< Camera FPS
 		struct xrt_matrix_4x4 T_imu_cam; //!< Transform IMU to camera. Column major.
-		float rpmax;                     //!< Used for rt8 calibrations. Rpmax or "metric_radius" property.
 	} cams[2];
 };
 

src/xrt/auxiliary/vive/vive_config.c

···
 	struct index_camera *cameras = d->cameras.view;
 	struct t_stereo_camera_calibration *calib = NULL;
 
-	t_stereo_camera_calibration_alloc(&calib, 5);
+	t_stereo_camera_calibration_alloc(&calib, T_DISTORTION_FISHEYE_KB4);
 
 	for (int i = 0; i < 2; i++) {
 		calib->view[i].image_size_pixels.w = cameras[i].intrinsics.image_size_pixels.w;
···
 		calib->view[i].intrinsics[2][1] = 0.0f;
 		calib->view[i].intrinsics[2][2] = 1.0f;
 
-		calib->view[i].use_fisheye = true;
-		calib->view[i].distortion_fisheye[0] = cameras[i].intrinsics.distortion[0];
-		calib->view[i].distortion_fisheye[1] = cameras[i].intrinsics.distortion[1];
-		calib->view[i].distortion_fisheye[2] = cameras[i].intrinsics.distortion[2];
-		calib->view[i].distortion_fisheye[3] = cameras[i].intrinsics.distortion[3];
+		calib->view[i].kb4.k1 = cameras[i].intrinsics.distortion[0];
+		calib->view[i].kb4.k2 = cameras[i].intrinsics.distortion[1];
+		calib->view[i].kb4.k3 = cameras[i].intrinsics.distortion[2];
+		calib->view[i].kb4.k4 = cameras[i].intrinsics.distortion[3];
 	}
 
 	struct xrt_vec3 pos = d->cameras.opencv.position;

src/xrt/drivers/depthai/depthai_driver.cpp

···
 	 * Copy to the Monado calibration struct.
 	 */
 
-	uint32_t num_dist = 14;
 
 	// Good enough assumption that they're using the same distortion model
-	bool use_fisheye = calibData.getDistortionModel(dai::CameraBoardSocket::LEFT) == dai::CameraModel::Fisheye;
-	if (use_fisheye) {
-		num_dist = 4;
+	enum t_camera_distortion_model type = T_DISTORTION_OPENCV_RADTAN_14;
+	if (calibData.getDistortionModel(dai::CameraBoardSocket::LEFT) == dai::CameraModel::Fisheye) {
+		type = T_DISTORTION_FISHEYE_KB4;
 	}
+
+	uint32_t num_dist = t_num_params_from_distortion_model(type);
 
 	struct t_stereo_camera_calibration *c = NULL;
-	t_stereo_camera_calibration_alloc(&c, num_dist);
+	t_stereo_camera_calibration_alloc(&c, type);
 
 	// Copy intrinsics
 	c->view[0].image_size_pixels.w = left.width;
···
 		}
 	}
 
-	// Copy distortion
-	c->view[0].use_fisheye = use_fisheye;
-	c->view[1].use_fisheye = use_fisheye;
+	c->view[0].distortion_model = type;
+	c->view[1].distortion_model = type;
 	for (uint32_t i = 0; i < num_dist; i++) {
-		if (use_fisheye) {
-			c->view[0].distortion_fisheye[i] = left.distortion[i];
-			c->view[1].distortion_fisheye[i] = right.distortion[i];
-		} else {
-			c->view[0].distortion[i] = left.distortion[i];
-			c->view[1].distortion[i] = right.distortion[i];
-		}
+		c->view[0].distortion_parameters_as_array[i] = left.distortion[i];
+		c->view[1].distortion_parameters_as_array[i] = right.distortion[i];
 	}
 
 	// Copy translation

src/xrt/drivers/rift_s/rift_s_tracker.c

···
 	            {
 	                .frequency = CAMERA_FREQUENCY,
 	                .T_imu_cam = T_imu_left_cam,
-	                .rpmax = 0.0,
 	            },
 	            {
 	                .frequency = CAMERA_FREQUENCY,
 	                .T_imu_cam = T_imu_right_cam,
-	                .rpmax = 0.0,
 	            },
 	        },
 	};

src/xrt/drivers/rift_s/rift_s_util.cpp

···
 	tcc->intrinsics[0][2] = rift_s_cam->projection.cx;
 	tcc->intrinsics[1][2] = rift_s_cam->projection.cy;
 	tcc->intrinsics[2][2] = 1.0;
-	tcc->use_fisheye = true;
+	tcc->distortion_model = T_DISTORTION_FISHEYE_KB4;
 
 	TargetPoint xy[STEPS * STEPS];
 
···
 		TinySolver<AutoDiffDistortParamKB4Function> solver;
 		solver.Solve(f, &kb4_distort_params);
 
-		for (int i = 0; i < 4; i++)
-			tcc->distortion_fisheye[i] = kb4_distort_params[i];
+		tcc->kb4.k1 = kb4_distort_params[0];
+		tcc->kb4.k2 = kb4_distort_params[1];
+		tcc->kb4.k3 = kb4_distort_params[2];
+		tcc->kb4.k4 = kb4_distort_params[3];
 	}
 
 	return true;
···
 rift_s_create_stereo_camera_calib_rotated(struct rift_s_camera_calibration_block *camera_calibration)
 {
 	struct t_stereo_camera_calibration *calib = NULL;
-	t_stereo_camera_calibration_alloc(&calib, 8);
+	t_stereo_camera_calibration_alloc(&calib, T_DISTORTION_FISHEYE_KB4);
 
 	struct rift_s_camera_calibration *left = &camera_calibration->cameras[RIFT_S_CAMERA_FRONT_LEFT];
 	struct rift_s_camera_calibration *right = &camera_calibration->cameras[RIFT_S_CAMERA_FRONT_RIGHT];

src/xrt/drivers/wmr/wmr_hmd.c

···
  * 2. The terms that use the tangential parameters, p1 and p2, aren't multiplied by 2
  * 3. There is a "metric radius" that delimits a valid area of distortion/undistortion
  *
- * Thankfully, parameters of points 1 and 2 tend to be almost zero in practice and we
- * only do unprojections (for hand tracking) in very safe camera regions so 3
- * doesn't bother us that much either.
+ * Thankfully, parameters of points 1 and 2 tend to be almost zero in practice. For 3, we place metric_radius into
+ * the calibration struct so that downstream tracking algorithms can use it as needed.
  */
 XRT_MAYBE_UNUSED static struct t_stereo_camera_calibration *
 wmr_hmd_create_stereo_camera_calib(struct wmr_hmd *wh)
 {
 	struct t_stereo_camera_calibration *calib = NULL;
-	t_stereo_camera_calibration_alloc(&calib, 8);
+	t_stereo_camera_calibration_alloc(&calib, T_DISTORTION_WMR);
+
 
 	// Intrinsics
 	for (int view = 0; view < 2; view++) { // Assuming that cameras[0-1] are HT0 and HT1
···
 		tcc->intrinsics[1][2] = intr->params.cy * (double)cam->roi.extent.h;
 		tcc->intrinsics[2][2] = 1.0;
 
-		tcc->distortion[0] = intr->params.k[0];
-		tcc->distortion[1] = intr->params.k[1];
-		tcc->distortion[2] = intr->params.p1;
-		tcc->distortion[3] = intr->params.p2;
-		tcc->distortion[4] = intr->params.k[2];
-		tcc->distortion[5] = intr->params.k[3];
-		tcc->distortion[6] = intr->params.k[4];
-		tcc->distortion[7] = intr->params.k[5];
-		tcc->use_fisheye = false;
+		tcc->wmr.k1 = intr->params.k[0];
+		tcc->wmr.k2 = intr->params.k[1];
+		tcc->wmr.p1 = intr->params.p1;
+		tcc->wmr.p2 = intr->params.p2;
+		tcc->wmr.k3 = intr->params.k[2];
+		tcc->wmr.k4 = intr->params.k[3];
+		tcc->wmr.k5 = intr->params.k[4];
+		tcc->wmr.k6 = intr->params.k[5];
+
+		tcc->wmr.codx = intr->params.dist_x;
+		tcc->wmr.cody = intr->params.dist_y;
+
+		tcc->wmr.rpmax = intr->params.metric_radius;
+
+		tcc->distortion_model = T_DISTORTION_WMR;
 	}
 
 	// Extrinsics
···
 XRT_MAYBE_UNUSED static struct t_slam_calib_extras
 wmr_hmd_create_extra_calib(struct wmr_hmd *wh)
 {
-	struct wmr_camera_config *ht0 = &wh->config.cameras[0];
-	struct wmr_camera_config *ht1 = &wh->config.cameras[1];
-
 	struct xrt_pose P_imu_ht0 = wh->config.sensors.accel.pose;
-	struct xrt_pose P_ht1_ht0 = ht1->pose;
+	struct xrt_pose P_ht1_ht0 = wh->config.cameras[1].pose;
 	struct xrt_pose P_ht0_ht1;
 	math_pose_invert(&P_ht1_ht0, &P_ht0_ht1);
 	struct xrt_pose P_imu_ht1;
···
 	            {
 	                .frequency = CAMERA_FREQUENCY,
 	                .T_imu_cam = T_imu_ht0,
-	                .rpmax = ht0->distortion6KT.params.metric_radius,
 	            },
 	            {
 	                .frequency = CAMERA_FREQUENCY,
 	                .T_imu_cam = T_imu_ht1,
-	                .rpmax = ht1->distortion6KT.params.metric_radius,
 	            },
 	        },
 	};

src/xrt/tracking/hand/mercury/hg_sync.cpp

···
  */
 
 static bool
-getCalibration(struct HandTracking *hgt, t_stereo_camera_calibration *calibration)
+getCalibration(struct HandTracking *hgt, t_stereo_camera_calibration &calibration)
 {
-	xrt::auxiliary::tracking::StereoCameraCalibrationWrapper wrap(calibration);
-	xrt_vec3 trans = {(float)wrap.camera_translation_mat(0, 0), (float)wrap.camera_translation_mat(1, 0),
-	                  (float)wrap.camera_translation_mat(2, 0)};
+	xrt::auxiliary::tracking::StereoCameraCalibrationWrapper wrap(&calibration);
+	xrt_vec3 trans = {
+	    (float)calibration.camera_translation[0],
+	    (float)calibration.camera_translation[1],
+	    (float)calibration.camera_translation[2],
+	};
 	hgt->baseline = m_vec3_len(trans);
 	HG_DEBUG(hgt, "I think the baseline is %f meters!", hgt->baseline);
 	// Note, this assumes camera 0 is the left camera and camera 1 is the right camera.
 	// If you find one with the opposite arrangement, you'll need to invert hgt->baseline, and look at
 	// hgJointDisparityMath
 
-	hgt->use_fisheye = wrap.view[0].use_fisheye;
+	hgt->use_fisheye = wrap.view[0].distortion_model == T_DISTORTION_FISHEYE_KB4;
 
 	if (hgt->use_fisheye) {
 		HG_DEBUG(hgt, "I think the cameras are fisheye!");
···
 		s.v[1] = wrap.camera_rotation_mat(1, 0);
 		s.v[2] = wrap.camera_rotation_mat(2, 0);
 
-		s.v[3] = wrap.camera_rotation_mat(0, 1);
-		s.v[4] = wrap.camera_rotation_mat(1, 1);
-		s.v[5] = wrap.camera_rotation_mat(2, 1);
+		s.v[0] = (float)calibration.camera_rotation[0][0];
+		s.v[1] = (float)calibration.camera_rotation[1][0];
+		s.v[2] = (float)calibration.camera_rotation[2][0];
 
-		s.v[6] = wrap.camera_rotation_mat(0, 2);
-		s.v[7] = wrap.camera_rotation_mat(1, 2);
-		s.v[8] = wrap.camera_rotation_mat(2, 2);
+		s.v[3] = (float)calibration.camera_rotation[0][1];
+		s.v[4] = (float)calibration.camera_rotation[1][1];
+		s.v[5] = (float)calibration.camera_rotation[2][1];
+
+		s.v[6] = (float)calibration.camera_rotation[0][2];
+		s.v[7] = (float)calibration.camera_rotation[1][2];
+		s.v[8] = (float)calibration.camera_rotation[2][2];
 
 		xrt_pose left_in_right;
-		left_in_right.position.x = wrap.camera_translation_mat(0);
+		left_in_right.position = trans;
 		left_in_right.position.y = wrap.camera_translation_mat(1);
 		left_in_right.position.z = wrap.camera_translation_mat(2);
 
 		math_quat_from_matrix_3x3(&s, &left_in_right.orientation);
+
+		//! @todo what are these magic values?
+		//! they're probably turning the OpenCV formalism into OpenXR, but especially what gives with negating
+		//! orientation.x?
 		left_in_right.orientation.x = -left_in_right.orientation.x;
 		left_in_right.position.y = -left_in_right.position.y;
 		left_in_right.position.z = -left_in_right.position.z;
···
 	//* Good enough guess that view 0 and view 1 are the same size.
 	for (int i = 0; i < 2; i++) {
 		hgt->views[i].cameraMatrix = wrap.view[i].intrinsics_mat;
-
-		if (hgt->use_fisheye) {
-			hgt->views[i].distortion = wrap.view[i].distortion_fisheye_mat;
-		} else {
-			hgt->views[i].distortion = wrap.view[i].distortion_mat;
-		}
+		hgt->views[i].distortion = wrap.view[i].distortion_mat;
 
 		if (hgt->log_level <= U_LOGGING_DEBUG) {
 			HG_DEBUG(hgt, "K%d ->", i);
···
 	hgt->calib = NULL;
 	// We have to reference it, getCalibration points at it.
 	t_stereo_camera_calibration_reference(&hgt->calib, calib);
-	getCalibration(hgt, calib);
+	getCalibration(hgt, *calib);
 	getModelsFolder(hgt);