Support multiple distortion models, including a new division model

This commit makes it so CameraIntrinsics is no longer hardcoded
to use the traditional polynomial radial distortion model. Currently
the distortion code has generic logic which is shared between
different distortion models, but had no other models until now.

This moves everything specific to the polynomial radial distortion
to a subclass PolynomialDistortionCameraIntrinsics(), and adds a
new division distortion model suitable for cameras such as the
GoPro which have much stronger distortion due to their fisheye lens.

This also cleans up the internal API of CameraIntrinsics to make
it easier to understand and reduces old C-style code.

New distortion model is available in the Lens panel of MCE.

- Polynomial is the old well-known model
- Division is the new one which s intended to deal better with huge
  distortion.

Coefficients of this model works independent from each other
and for division model one probably want to have positive values
to have a barrel distortion.

9 files changed, 193 insertions, 91 deletions

diff --git a/source/blender/blenkernel/BKE_tracking.h b/source/blender/blenkernel/BKE_tracking.h
index ecf6b789227..6d155ba37de 100644
--- a/source/blender/blenkernel/BKE_tracking.h
+++ b/source/blender/blenkernel/BKE_tracking.h
@@ -175,7 +175,8 @@ void BKE_tracking_camera_get_reconstructed_interpolate(struct MovieTracking *tra
                                                        int framenr, float mat[4][4]);
 
 /* **** Distortion/Undistortion **** */
-struct MovieDistortion *BKE_tracking_distortion_new(void);
+struct MovieDistortion *BKE_tracking_distortion_new(struct MovieTracking *tracking,
+                                                    int calibration_width, int calibration_height);
 void BKE_tracking_distortion_update(struct MovieDistortion *distortion, struct MovieTracking *tracking,
                                     int calibration_width, int calibration_height);
 void BKE_tracking_distortion_set_threads(struct MovieDistortion *distortion, int threads);
diff --git a/source/blender/blenkernel/intern/movieclip.c b/source/blender/blenkernel/intern/movieclip.c
index de4846e1772..5012c08d95d 100644
--- a/source/blender/blenkernel/intern/movieclip.c
+++ b/source/blender/blenkernel/intern/movieclip.c
@@ -335,7 +335,9 @@ typedef struct MovieClipCache {
 
 		/* cache for undistorted shot */
 		float principal[2];
-		float k1, k2, k3;
+		float polynomial_k1, polynomial_k2, polynomial_k3;
+		float division_k1, division_k2;
+		short distortion_model;
 		bool undistortion_used;
 
 		int proxy;
@@ -732,11 +734,21 @@ static bool check_undistortion_cache_flags(MovieClip *clip)
 	MovieTrackingCamera *camera = &clip->tracking.camera;
 
 	/* check for distortion model changes */
-	if (!equals_v2v2(camera->principal, cache->postprocessed.principal))
+	if (!equals_v2v2(camera->principal, cache->postprocessed.principal)) {
 		return false;
+	}
+
+	if (camera->distortion_model != cache->postprocessed.distortion_model) {
+		return false;
+	}
 
-	if (!equals_v3v3(&camera->k1, &cache->postprocessed.k1))
+	if (!equals_v3v3(&camera->k1, &cache->postprocessed.polynomial_k1)) {
 		return false;
+	}
+
+	if (!equals_v2v2(&camera->division_k1, &cache->postprocessed.division_k1)) {
+		return false;
+	}
 
 	return true;
 }
@@ -823,8 +835,10 @@ static void put_postprocessed_frame_to_cache(MovieClip *clip, MovieClipUser *use
 	}
 
 	if (need_undistortion_postprocess(user)) {
+		cache->postprocessed.distortion_model = camera->distortion_model;
 		copy_v2_v2(cache->postprocessed.principal, camera->principal);
-		copy_v3_v3(&cache->postprocessed.k1, &camera->k1);
+		copy_v3_v3(&cache->postprocessed.polynomial_k1, &camera->k1);
+		copy_v2_v2(&cache->postprocessed.division_k1, &camera->division_k1);
 		cache->postprocessed.undistortion_used = true;
 	}
 	else {
diff --git a/source/blender/blenkernel/intern/tracking.c b/source/blender/blenkernel/intern/tracking.c
index 8434fde3005..ca0b52bd7c2 100644
--- a/source/blender/blenkernel/intern/tracking.c
+++ b/source/blender/blenkernel/intern/tracking.c
@@ -1733,32 +1733,19 @@ void BKE_tracking_camera_get_reconstructed_interpolate(MovieTracking *tracking,
 
 /*********************** Distortion/Undistortion *************************/
 
-static void cameraIntrinscisOptionsFromTracking(libmv_CameraIntrinsicsOptions *camera_intrinsics_options,
-                                                MovieTracking *tracking, int calibration_width, int calibration_height)
-{
-	MovieTrackingCamera *camera = &tracking->camera;
-	float aspy = 1.0f / tracking->camera.pixel_aspect;
-
-	camera_intrinsics_options->focal_length = camera->focal;
-
-	camera_intrinsics_options->principal_point_x = camera->principal[0];
-	camera_intrinsics_options->principal_point_y = camera->principal[1] * aspy;
-
-	camera_intrinsics_options->k1 = camera->k1;
-	camera_intrinsics_options->k2 = camera->k2;
-	camera_intrinsics_options->k3 = camera->k3;
-
-	camera_intrinsics_options->image_width = calibration_width;
-	camera_intrinsics_options->image_height = (int) (calibration_height * aspy);
-}
-
-MovieDistortion *BKE_tracking_distortion_new(void)
+MovieDistortion *BKE_tracking_distortion_new(MovieTracking *tracking,
+                                             int calibration_width, int calibration_height)
 {
 	MovieDistortion *distortion;
+	libmv_CameraIntrinsicsOptions camera_intrinsics_options;
 
-	distortion = MEM_callocN(sizeof(MovieDistortion), "BKE_tracking_distortion_create");
+	tracking_cameraIntrinscisOptionsFromTracking(tracking,
+	                                             calibration_width,
+	                                             calibration_height,
+	                                             &camera_intrinsics_options);
 
-	distortion->intrinsics = libmv_cameraIntrinsicsNewEmpty();
+	distortion = MEM_callocN(sizeof(MovieDistortion), "BKE_tracking_distortion_create");
+	distortion->intrinsics = libmv_cameraIntrinsicsNew(&camera_intrinsics_options);
 
 	return distortion;
 }
@@ -1768,8 +1755,10 @@ void BKE_tracking_distortion_update(MovieDistortion *distortion, MovieTracking *
 {
 	libmv_CameraIntrinsicsOptions camera_intrinsics_options;
 
-	cameraIntrinscisOptionsFromTracking(&camera_intrinsics_options, tracking,
-	                                    calibration_width, calibration_height);
+	tracking_cameraIntrinscisOptionsFromTracking(tracking,
+	                                             calibration_width,
+	                                             calibration_height,
+	                                             &camera_intrinsics_options);
 
 	libmv_cameraIntrinsicsUpdate(&camera_intrinsics_options, distortion->intrinsics);
 }
@@ -1845,7 +1834,9 @@ void BKE_tracking_distort_v2(MovieTracking *tracking, const float co[2], float r
 	double x, y;
 	float aspy = 1.0f / tracking->camera.pixel_aspect;
 
-	cameraIntrinscisOptionsFromTracking(&camera_intrinsics_options, tracking, 0, 0);
+	tracking_cameraIntrinscisOptionsFromTracking(tracking,
+	                                             0, 0,
+	                                             &camera_intrinsics_options);
 
 	/* normalize coords */
 	x = (co[0] - camera->principal[0]) / camera->focal;
@@ -1866,7 +1857,9 @@ void BKE_tracking_undistort_v2(MovieTracking *tracking, const float co[2], float
 	double x = co[0], y = co[1];
 	float aspy = 1.0f / tracking->camera.pixel_aspect;
 
-	cameraIntrinscisOptionsFromTracking(&camera_intrinsics_options, tracking, 0, 0);
+	tracking_cameraIntrinscisOptionsFromTracking(tracking,
+	                                             0, 0,
+	                                             &camera_intrinsics_options);
 
 	libmv_cameraIntrinsicsInvert(&camera_intrinsics_options, x, y, &x, &y);
 
@@ -1879,8 +1872,9 @@ ImBuf *BKE_tracking_undistort_frame(MovieTracking *tracking, ImBuf *ibuf, int ca
 {
 	MovieTrackingCamera *camera = &tracking->camera;
 
-	if (camera->intrinsics == NULL)
-		camera->intrinsics = BKE_tracking_distortion_new();
+	if (camera->intrinsics == NULL) {
+		camera->intrinsics = BKE_tracking_distortion_new(tracking, calibration_width, calibration_height);
+	}
 
 	return BKE_tracking_distortion_exec(camera->intrinsics, tracking, ibuf, calibration_width,
 	                                    calibration_height, overscan, true);
@@ -1891,8 +1885,9 @@ ImBuf *BKE_tracking_distort_frame(MovieTracking *tracking, ImBuf *ibuf, int cali
 {
 	MovieTrackingCamera *camera = &tracking->camera;
 
-	if (camera->intrinsics == NULL)
-		camera->intrinsics = BKE_tracking_distortion_new();
+	if (camera->intrinsics == NULL) {
+		camera->intrinsics = BKE_tracking_distortion_new(tracking, calibration_width, calibration_height);
+	}
 
 	return BKE_tracking_distortion_exec(camera->intrinsics, tracking, ibuf, calibration_width,
 	                                    calibration_height, overscan, false);
diff --git a/source/blender/blenkernel/intern/tracking_solver.c b/source/blender/blenkernel/intern/tracking_solver.c
index 44a4c11ec92..9ab1643aab1 100644
--- a/source/blender/blenkernel/intern/tracking_solver.c
+++ b/source/blender/blenkernel/intern/tracking_solver.c
@@ -66,11 +66,7 @@ typedef struct MovieReconstructContext {
 	bool is_camera;
 	short motion_flag;
 
-	float focal_length;
-	float principal_point[2];
-	float k1, k2, k3;
-
-	int width, height;
+	libmv_CameraIntrinsicsOptions camera_intrinsics_options;
 
 	float reprojection_error;
 
@@ -134,22 +130,11 @@ static void reconstruct_retrieve_libmv_intrinsics(MovieReconstructContext *conte
 	struct libmv_Reconstruction *libmv_reconstruction = context->reconstruction;
 	struct libmv_CameraIntrinsics *libmv_intrinsics = libmv_reconstructionExtractIntrinsics(libmv_reconstruction);
 
-	float aspy = 1.0f / tracking->camera.pixel_aspect;
-
-	double focal_length, principal_x, principal_y, k1, k2, k3;
-	int width, height;
-
-	libmv_cameraIntrinsicsExtract(libmv_intrinsics, &focal_length, &principal_x, &principal_y,
-	                              &k1, &k2, &k3, &width, &height);
-
-	tracking->camera.focal = focal_length;
-
-	tracking->camera.principal[0] = principal_x;
-	tracking->camera.principal[1] = principal_y / (double)aspy;
+	libmv_CameraIntrinsicsOptions camera_intrinsics_options;
+	libmv_cameraIntrinsicsExtractOptions(libmv_intrinsics, &camera_intrinsics_options);
 
-	tracking->camera.k1 = k1;
-	tracking->camera.k2 = k2;
-	tracking->camera.k3 = k3;
+	tracking_trackingCameraFromIntrinscisOptions(tracking,
+	                                             &camera_intrinsics_options);
 }
 
 /* Retrieve reconstructed tracks from libmv to blender.
@@ -369,7 +354,6 @@ MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieClip *clip
 {
 	MovieTracking *tracking = &clip->tracking;
 	MovieReconstructContext *context = MEM_callocN(sizeof(MovieReconstructContext), "MovieReconstructContext data");
-	MovieTrackingCamera *camera = &tracking->camera;
 	ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
 	float aspy = 1.0f / tracking->camera.pixel_aspect;
 	int num_tracks = BLI_countlist(tracksbase);
@@ -383,16 +367,9 @@ MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieClip *clip
 	context->select_keyframes =
 		(tracking->settings.reconstruction_flag & TRACKING_USE_KEYFRAME_SELECTION) != 0;
 
-	context->focal_length = camera->focal;
-	context->principal_point[0] = camera->principal[0];
-	context->principal_point[1] = camera->principal[1] * aspy;
-
-	context->width = width;
-	context->height = height;
-
-	context->k1 = camera->k1;
-	context->k2 = camera->k2;
-	context->k3 = camera->k3;
+	tracking_cameraIntrinscisOptionsFromTracking(tracking,
+                                                 width, height,
+                                                 &context->camera_intrinsics_options);
 
 	context->tracks_map = tracks_map_new(context->object_name, context->is_camera, num_tracks, 0);
 
@@ -461,22 +438,6 @@ static void reconstruct_update_solve_cb(void *customdata, double progress, const
 
 	BLI_snprintf(progressdata->stats_message, progressdata->message_size, "Solving camera | %s", message);
 }
-/* FIll in camera intrinsics structure from reconstruction context. */
-static void camraIntrincicsOptionsFromContext(libmv_CameraIntrinsicsOptions *camera_intrinsics_options,
-                                              MovieReconstructContext *context)
-{
-	camera_intrinsics_options->focal_length = context->focal_length;
-
-	camera_intrinsics_options->principal_point_x = context->principal_point[0];
-	camera_intrinsics_options->principal_point_y = context->principal_point[1];
-
-	camera_intrinsics_options->k1 = context->k1;
-	camera_intrinsics_options->k2 = context->k2;
-	camera_intrinsics_options->k3 = context->k3;
-
-	camera_intrinsics_options->image_width = context->width;
-	camera_intrinsics_options->image_height = context->height;
-}
 
 /* Fill in reconstruction options structure from reconstruction context. */
 static void reconstructionOptionsFromContext(libmv_ReconstructionOptions *reconstruction_options,
@@ -506,7 +467,6 @@ void BKE_tracking_reconstruction_solve(MovieReconstructContext *context, short *
 
 	ReconstructProgressData progressdata;
 
-	libmv_CameraIntrinsicsOptions camera_intrinsics_options;
 	libmv_ReconstructionOptions reconstruction_options;
 
 	progressdata.stop = stop;
@@ -515,18 +475,17 @@ void BKE_tracking_reconstruction_solve(MovieReconstructContext *context, short *
 	progressdata.stats_message = stats_message;
 	progressdata.message_size = message_size;
 
-	camraIntrincicsOptionsFromContext(&camera_intrinsics_options, context);
 	reconstructionOptionsFromContext(&reconstruction_options, context);
 
 	if (context->motion_flag & TRACKING_MOTION_MODAL) {
 		context->reconstruction = libmv_solveModal(context->tracks,
-		                                           &camera_intrinsics_options,
+		                                           &context->camera_intrinsics_options,
 		                                           &reconstruction_options,
 		                                           reconstruct_update_solve_cb, &progressdata);
 	}
 	else {
 		context->reconstruction = libmv_solveReconstruction(context->tracks,
-		                                                    &camera_intrinsics_options,
+		                                                    &context->camera_intrinsics_options,
 		                                                    &reconstruction_options,
 		                                                    reconstruct_update_solve_cb, &progressdata);
 
diff --git a/source/blender/blenkernel/intern/tracking_util.c b/source/blender/blenkernel/intern/tracking_util.c
index 4b3c354dd12..4ebe8494101 100644
--- a/source/blender/blenkernel/intern/tracking_util.c
+++ b/source/blender/blenkernel/intern/tracking_util.c
@@ -51,6 +51,8 @@
 
 #include "tracking_private.h"
 
+#include "libmv-capi.h"
+
 /*********************** Tracks map *************************/
 
 TracksMap *tracks_map_new(const char *object_name, bool is_camera, int num_tracks, int customdata_size)
@@ -386,3 +388,68 @@ void tracking_marker_insert_disabled(MovieTrackingTrack *track, const MovieTrack
 	if (overwrite || !BKE_tracking_track_has_marker_at_frame(track, marker_new.framenr))
 		BKE_tracking_marker_insert(track, &marker_new);
 }
+
+
+/* Fill in Libmv C-API camera intrinsics options from tracking structure.
+ */
+void tracking_cameraIntrinscisOptionsFromTracking(MovieTracking *tracking,
+                                                  int calibration_width, int calibration_height,
+                                                  libmv_CameraIntrinsicsOptions *camera_intrinsics_options)
+{
+	MovieTrackingCamera *camera = &tracking->camera;
+	float aspy = 1.0f / tracking->camera.pixel_aspect;
+
+	camera_intrinsics_options->focal_length = camera->focal;
+
+	camera_intrinsics_options->principal_point_x = camera->principal[0];
+	camera_intrinsics_options->principal_point_y = camera->principal[1] * aspy;
+
+	switch (camera->distortion_model) {
+		case TRACKING_DISTORTION_MODEL_POLYNOMIAL:
+			camera_intrinsics_options->distortion_model = LIBMV_DISTORTION_MODEL_POLYNOMIAL;
+			camera_intrinsics_options->polynomial_k1 = camera->k1;
+			camera_intrinsics_options->polynomial_k2 = camera->k2;
+			camera_intrinsics_options->polynomial_k3 = camera->k3;
+			camera_intrinsics_options->polynomial_p1 = 0.0;
+			camera_intrinsics_options->polynomial_p2 = 0.0;
+			break;
+		case TRACKING_DISTORTION_MODEL_DIVISION:
+			camera_intrinsics_options->distortion_model = LIBMV_DISTORTION_MODEL_DIVISION;
+			camera_intrinsics_options->division_k1 = camera->division_k1;
+			camera_intrinsics_options->division_k2 = camera->division_k2;
+			break;
+		default:
+			BLI_assert(!"Unknown distortion model");
+	}
+
+	camera_intrinsics_options->image_width = calibration_width;
+	camera_intrinsics_options->image_height = (int) (calibration_height * aspy);
+}
+
+void tracking_trackingCameraFromIntrinscisOptions(MovieTracking *tracking,
+                                                  const libmv_CameraIntrinsicsOptions *camera_intrinsics_options)
+{
+	float aspy = 1.0f / tracking->camera.pixel_aspect;
+	MovieTrackingCamera *camera = &tracking->camera;
+
+	camera->focal = camera_intrinsics_options->focal_length;
+
+	camera->principal[0] = camera_intrinsics_options->principal_point_x;
+	camera->principal[1] = camera_intrinsics_options->principal_point_y / (double) aspy;
+
+	switch (camera_intrinsics_options->distortion_model) {
+		case LIBMV_DISTORTION_MODEL_POLYNOMIAL:
+			camera->distortion_model = TRACKING_DISTORTION_MODEL_POLYNOMIAL;
+			camera->k1 = camera_intrinsics_options->polynomial_k1;
+			camera->k2 = camera_intrinsics_options->polynomial_k2;
+			camera->k3 = camera_intrinsics_options->polynomial_k3;
+			break;
+		case LIBMV_DISTORTION_MODEL_DIVISION:
+			camera->distortion_model = TRACKING_DISTORTION_MODEL_DIVISION;
+			camera->division_k1 = camera_intrinsics_options->division_k1;
+			camera->division_k2 = camera_intrinsics_options->division_k2;
+			break;
+		default:
+			BLI_assert(!"Unknown distortion model");
+	}
+}
diff --git a/source/blender/blenkernel/tracking_private.h b/source/blender/blenkernel/tracking_private.h
index 981b7951097..6efa1533e3e 100644
--- a/source/blender/blenkernel/tracking_private.h
+++ b/source/blender/blenkernel/tracking_private.h
@@ -41,6 +41,8 @@ struct GHash;
 struct MovieTracking;
 struct MovieTrackingMarker;
 
+struct libmv_CameraIntrinsicsOptions;
+
 /*********************** Tracks map *************************/
 
 typedef struct TracksMap {
@@ -86,4 +88,11 @@ void tracking_set_marker_coords_from_tracking(int frame_width, int frame_height,
 void tracking_marker_insert_disabled(struct MovieTrackingTrack *track, const struct MovieTrackingMarker *ref_marker,
                                      bool before, bool overwrite);
 
+void tracking_cameraIntrinscisOptionsFromTracking(struct MovieTracking *tracking,
+                                                  int calibration_width, int calibration_height,
+                                                  struct libmv_CameraIntrinsicsOptions *camera_intrinsics_options);
+
+void tracking_trackingCameraFromIntrinscisOptions(struct MovieTracking *tracking,
+                                                  const struct libmv_CameraIntrinsicsOptions *camera_intrinsics_options);
+
 #endif  /* __TRACKING_PRIVATE_H__ */
diff --git a/source/blender/editors/space_clip/clip_ops.c b/source/blender/editors/space_clip/clip_ops.c
index 3f0a376d791..b8fe9fe4a17 100644
--- a/source/blender/editors/space_clip/clip_ops.c
+++ b/source/blender/editors/space_clip/clip_ops.c
@@ -1018,8 +1018,11 @@ static void do_movie_proxy(void *pjv, int *UNUSED(build_sizes), int UNUSED(build
 
 	if (build_undistort_count) {
 		int threads = BLI_system_thread_count();
+		int width, height;
 
-		distortion = BKE_tracking_distortion_new();
+		BKE_movieclip_get_size(clip, NULL, &width, &height);
+
+		distortion = BKE_tracking_distortion_new(&clip->tracking, width, height);
 		BKE_tracking_distortion_set_threads(distortion, threads);
 	}
 
@@ -1185,8 +1188,11 @@ static void do_sequence_proxy(void *pjv, int *build_sizes, int build_count,
 		handle->build_undistort_count = build_undistort_count;
 		handle->build_undistort_sizes = build_undistort_sizes;
 
-		if (build_undistort_count)
-			handle->distortion = BKE_tracking_distortion_new();
+		if (build_undistort_count) {
+			int width, height;
+			BKE_movieclip_get_size(clip, NULL, &width, &height);
+			handle->distortion = BKE_tracking_distortion_new(&clip->tracking, width, height);
+		}
 
 		if (tot_thread > 1)
 			BLI_insert_thread(&threads, handle);
diff --git a/source/blender/makesdna/DNA_tracking_types.h b/source/blender/makesdna/DNA_tracking_types.h
index a5079cb6c6f..c471cb26892 100644
--- a/source/blender/makesdna/DNA_tracking_types.h
+++ b/source/blender/makesdna/DNA_tracking_types.h
@@ -61,14 +61,21 @@ typedef struct MovieReconstructedCamera {
 typedef struct MovieTrackingCamera {
 	void *intrinsics;   /* intrinsics handle */
 
+	short distortion_model;
+	short pad;
+
 	float sensor_width; /* width of CCD sensor */
 	float pixel_aspect; /* pixel aspect ratio */
-	float pad;
 	float focal;        /* focal length */
 	short units;        /* units of focal length user is working with */
 	short pad1;
 	float principal[2]; /* principal point */
-	float k1, k2, k3;   /* radial distortion */
+
+	/* Polynomial distortion */
+	float k1, k2, k3;   /* polynomial radial distortion */
+
+	/* Division distortion model coefficients */
+	float division_k1, division_k2;
 } MovieTrackingCamera;
 
 typedef struct MovieTrackingMarker {
@@ -348,6 +355,12 @@ typedef struct MovieTracking {
 	MovieTrackingDopesheet dopesheet;   /* dopesheet data */
 } MovieTracking;
 
+/* MovieTrackingCamera->distortion_model */
+enum {
+	TRACKING_DISTORTION_MODEL_POLYNOMIAL = 0,
+	TRACKING_DISTORTION_MODEL_DIVISION = 1
+};
+
 /* MovieTrackingCamera->units */
 enum {
 	CAMERA_UNITS_PX = 0,
diff --git a/source/blender/makesrna/intern/rna_tracking.c b/source/blender/makesrna/intern/rna_tracking.c
index 847efa2fad5..537ffe630a2 100644
--- a/source/blender/makesrna/intern/rna_tracking.c
+++ b/source/blender/makesrna/intern/rna_tracking.c
@@ -372,6 +372,17 @@ static void rna_tracking_stabTracks_active_index_range(PointerRNA *ptr, int *min
 	*max = max_ii(0, clip->tracking.stabilization.tot_track - 1);
 }
 
+static void rna_tracking_resetIntrinsics(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
+{
+	MovieClip *clip = (MovieClip *)ptr->id.data;
+	MovieTracking *tracking = &clip->tracking;
+
+	if (tracking->camera.intrinsics) {
+		BKE_tracking_distortion_free(tracking->camera.intrinsics);
+		tracking->camera.intrinsics = NULL;
+	}
+}
+
 static void rna_tracking_flushUpdate(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
 {
 	MovieClip *clip = (MovieClip *)ptr->id.data;
@@ -990,6 +1001,13 @@ static void rna_def_trackingCamera(BlenderRNA *brna)
 	StructRNA *srna;
 	PropertyRNA *prop;
 
+	static EnumPropertyItem distortion_model_items[] = {
+		{TRACKING_DISTORTION_MODEL_POLYNOMIAL, "POLYNOMIAL", 0, "Polynomial", "Radial distortion model which fits common cameras"},
+		{TRACKING_DISTORTION_MODEL_DIVISION, "DIVISION", 0, "Divisions", "Division distortion model which "
+		                                                                 "better represents wide-angle cameras"},
+		{0, NULL, 0, NULL, NULL}
+	};
+
 	static EnumPropertyItem camera_units_items[] = {
 		{CAMERA_UNITS_PX, "PIXELS", 0, "px", "Use pixels for units of focal length"},
 		{CAMERA_UNITS_MM, "MILLIMETERS", 0, "mm", "Use millimeters for units of focal length"},
@@ -1000,6 +1018,13 @@ static void rna_def_trackingCamera(BlenderRNA *brna)
 	RNA_def_struct_path_func(srna, "rna_trackingCamera_path");
 	RNA_def_struct_ui_text(srna, "Movie tracking camera data", "Match-moving camera data for tracking");
 
+	/* Distortion model */
+	prop = RNA_def_property(srna, "distortion_model", PROP_ENUM, PROP_NONE);
+	RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
+	RNA_def_property_enum_items(prop, distortion_model_items);
+	RNA_def_property_ui_text(prop, "Distortion Model", "Distortion model used for camera lenses");
+	RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_resetIntrinsics");
+
 	/* Sensor */
 	prop = RNA_def_property(srna, "sensor_width", PROP_FLOAT, PROP_NONE);
 	RNA_def_property_float_sdna(prop, NULL, "sensor_width");
@@ -1065,6 +1090,19 @@ static void rna_def_trackingCamera(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "K3", "Third coefficient of third order polynomial radial distortion");
 	RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
 
+	/* Division distortion parameters */
+	prop = RNA_def_property(srna, "division_k1", PROP_FLOAT, PROP_NONE);
+	RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
+	RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
+	RNA_def_property_ui_text(prop, "K1", "First coefficient of second order division distortion");
+	RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
+
+	prop = RNA_def_property(srna, "division_k2", PROP_FLOAT, PROP_NONE);
+	RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
+	RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
+	RNA_def_property_ui_text(prop, "K2", "First coefficient of second order division distortion");
+	RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
+
 	/* pixel aspect */
 	prop = RNA_def_property(srna, "pixel_aspect", PROP_FLOAT, PROP_XYZ);
 	RNA_def_property_float_sdna(prop, NULL, "pixel_aspect");