Preferences: remove author field
[blender.git] / source / blender / makesdna / DNA_tracking_types.h
index 1ab64ed1cc15c1ecd1b227085c9e04c6a73366b1..d6a2df5b7e0d5345b5a0cb32b16479560483a103 100644 (file)
@@ -30,6 +30,8 @@
  *  \ingroup DNA
  *  \since may-2011
  *  \author Sergey Sharybin
+ *
+ * Structs used for camera tracking and the movie-clip editor.
  */
 
 #ifndef __DNA_TRACKING_TYPES_H__
 /* match-moving data */
 
 struct bGPdata;
-struct ImBuf;
+struct Image;
 struct MovieReconstructedCamera;
 struct MovieTrackingCamera;
-struct MovieTrackingBundle;
 struct MovieTrackingMarker;
 struct MovieTrackingTrack;
 struct MovieTracking;
@@ -56,20 +57,35 @@ typedef struct MovieReconstructedCamera {
 } MovieReconstructedCamera;
 
 typedef struct MovieTrackingCamera {
-       void *intrinsics;   /* intrinsics handle */
-
-       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 */
+       /** Intrinsics handle. */
+       void *intrinsics;
+
+       short distortion_model;
+       short pad;
+
+       /** Width of CCD sensor. */
+       float sensor_width;
+       /** Pixel aspect ratio. */
+       float pixel_aspect;
+       /** Focal length. */
+       float focal;
+       /** Units of focal length user is working with. */
+       short units;
        short pad1;
-       float principal[2]; /* principal point */
-       float k1, k2, k3;   /* radial distortion */
+       /** Principal point. */
+       float principal[2];
+
+       /* Polynomial distortion */
+       /** Polynomial radial distortion. */
+       float k1, k2, k3;
+
+       /* Division distortion model coefficients */
+       float division_k1, division_k2;
 } MovieTrackingCamera;
 
 typedef struct MovieTrackingMarker {
-       float pos[2];   /* 2d position of marker on frame (in unified 0..1 space) */
+       /** 2d position of marker on frame (in unified 0..1 space). */
+       float pos[2];
 
        /* corners of pattern in the following order:
         *
@@ -91,16 +107,19 @@ typedef struct MovieTrackingMarker {
         */
        float search_min[2], search_max[2];
 
-       int framenr;    /* number of frame marker is associated with */
-       int flag;       /* Marker's flag (alive, ...) */
+       /** Number of frame marker is associated with. */
+       int framenr;
+       /** Marker's flag (alive, ...). */
+       int flag;
 } MovieTrackingMarker;
 
 typedef struct MovieTrackingTrack {
        struct MovieTrackingTrack *next, *prev;
 
-       char name[64];  /* MAX_NAME */
+       /** MAX_NAME. */
+       char name[64];
 
-       /* ** setings ** */
+       /* ** settings ** */
 
        /* positions of left-bottom and right-top corners of pattern (in unified 0..1 units,
         * relative to marker->pos)
@@ -114,55 +133,160 @@ typedef struct MovieTrackingTrack {
         */
        float search_min[2] DNA_DEPRECATED, search_max[2] DNA_DEPRECATED;
 
-       float offset[2];                    /* offset to "parenting" point */
+       /** Offset to "parenting" point. */
+       float offset[2];
 
        /* ** track ** */
-       int markersnr;                  /* count of markers in track */
-       int last_marker;                /* most recently used marker */
-       MovieTrackingMarker *markers;   /* markers in track */
+       /** Count of markers in track. */
+       int markersnr;
+       /** Most recently used marker. */
+       int last_marker;
+       /** Markers in track. */
+       MovieTrackingMarker *markers;
 
        /* ** reconstruction data ** */
-       float bundle_pos[3];            /* reconstructed position */
-       float error;                    /* average track reprojection error */
+       /** Reconstructed position. */
+       float bundle_pos[3];
+       /** Average track reprojection error. */
+       float error;
 
        /* ** UI editing ** */
-       int flag, pat_flag, search_flag;    /* flags (selection, ...) */
-       float color[3];                     /* custom color for track */
+       /** Flags (selection, ...). */
+       int flag, pat_flag, search_flag;
+       /** Custom color for track. */
+       float color[3];
 
        /* ** control how tracking happens */
-       short frames_limit;     /* number of frames to be tarcked during single tracking session (if TRACKING_FRAMES_LIMIT is set) */
-       short margin;           /* margin from frame boundaries */
-       short pattern_match;    /* re-adjust every N frames */
+       /**
+        * Number of frames to be tarcked during single tracking session
+        * (if TRACKING_FRAMES_LIMIT is set).
+        */
+       short frames_limit;
+       /** Margin from frame boundaries. */
+       short margin;
+       /** Re-adjust every N frames. */
+       short pattern_match;
 
        /* tracking parameters */
-       short motion_model;     /* model of the motion for this track */
-       int algorithm_flag;    /* flags for the tracking algorithm (use brute, use esm, use pyramid, etc */
-       float minimum_correlation;          /* minimal correlation which is still treated as successful tracking */
+       /** Model of the motion for this track. */
+       short motion_model;
+       /** Flags for the tracking algorithm (use brute, use esm, use pyramid, etc. */
+       int algorithm_flag;
+       /** Minimal correlation which is still treated as successful tracking. */
+       float minimum_correlation;
+
+       /** Grease-pencil data. */
+       struct bGPdata *gpd;
+
+       /* Weight of this track.
+        *
+        * Weight defines how much the track affects on the final reconstruction,
+        * usually gets animated in a way so when track has just appeared it's
+        * weight is zero and then it gets faded up.
+        *
+        * Used to prevent jumps of the camera when tracks are appearing or
+        * disappearing.
+        */
+       float weight;
 
-       struct bGPdata *gpd;        /* grease-pencil data */
+       /* track weight especially for 2D stabilization */
+       float weight_stab;
 } MovieTrackingTrack;
 
+typedef struct MovieTrackingPlaneMarker {
+       /* Corners of the plane in the following order:
+        *
+        *       Y
+        *       ^
+        *       | (3) --- (2)
+        *       |  |       |
+        *       |  |       |
+        *       |  |       |
+        *       | (0) --- (1)
+        *       +-------------> X
+        *
+        * The coordinates are stored in frame normalized coordinates.
+        */
+       float corners[4][2];
+
+       /** Number of frame plane marker is associated with. */
+       int framenr;
+       /** Marker's flag (alive, ...). */
+       int flag;
+} MovieTrackingPlaneMarker;
+
+typedef struct MovieTrackingPlaneTrack {
+       struct MovieTrackingPlaneTrack *next, *prev;
+
+       /** MAX_NAME. */
+       char name[64];
+
+       /**
+        * Array of point tracks used to define this pla.ne.
+        * Each element is a pointer to MovieTrackingTrack.
+        */
+       MovieTrackingTrack **point_tracks;
+       /** Number of tracks in point_tracks array. */
+       int point_tracksnr, pad;
+
+       /** Markers in the plane track. */
+       MovieTrackingPlaneMarker *markers;
+       /** Count of markers in track (size of markers array). */
+       int markersnr;
+
+       /** Flags (selection, ...). */
+       int flag;
+
+       /** Image displaying during editing. */
+       struct Image *image;
+       /** Opacity of the image. */
+       float image_opacity;
+
+       /* Runtime data */
+       /** Most recently used marker. */
+       int last_marker;
+} MovieTrackingPlaneTrack;
+
 typedef struct MovieTrackingSettings {
        int flag;
 
        /* ** default tracker settings */
-       short default_motion_model;         /* model of the motion for this track */
-       short default_algorithm_flag;       /* flags for the tracking algorithm (use brute, use esm, use pyramid, etc */
-       float default_minimum_correlation;  /* minimal correlation which is still treated as successful tracking */
-       short default_pattern_size;         /* size of pattern area for new tracks */
-       short default_search_size;          /* size of search area for new tracks */
-       short default_frames_limit;         /* number of frames to be tarcked during single tracking session (if TRACKING_FRAMES_LIMIT is set) */
-       short default_margin;               /* margin from frame boundaries */
-       short default_pattern_match;        /* re-adjust every N frames */
-       short default_flag;                 /* default flags like color channels used by default */
-
-       short motion_flag;      /* flags describes motion type */
+       /** Model of the motion for this track. */
+       short default_motion_model;
+       /** Flags for the tracking algorithm (use brute, use esm, use pyramid, etc. */
+       short default_algorithm_flag;
+       /** Minimal correlation which is still treated as successful tracking. */
+       float default_minimum_correlation;
+       /** Size of pattern area for new tracks. */
+       short default_pattern_size;
+       /** Size of search area for new tracks. */
+       short default_search_size;
+       /** Number of frames to be tarcked during single tracking session (if TRACKING_FRAMES_LIMIT is set). */
+       short default_frames_limit;
+       /** Margin from frame boundaries. */
+       short default_margin;
+       /** Re-adjust every N frames. */
+       short default_pattern_match;
+       /** Default flags like color channels used by default. */
+       short default_flag;
+       /** Default weight of the track. */
+       float default_weight;
+
+       /** Flags describes motion type. */
+       short motion_flag;
 
        /* ** common tracker settings ** */
-       short speed;            /* speed of tracking */
+       /** Speed of tracking. */
+       short speed;
 
        /* ** reconstruction settings ** */
-       int keyframe1, keyframe2;   /* two keyframes for reconstrution initialization */
+       /* two keyframes for reconstruction initialization
+        * were moved to per-tracking object settings
+        */
+       int keyframe1 DNA_DEPRECATED,
+               keyframe2 DNA_DEPRECATED;
+
+       int reconstruction_flag;
 
        /* which camera intrinsics to refine. uses on the REFINE_* flags */
        short refine_camera_intrinsics, pad2;
@@ -170,56 +294,86 @@ typedef struct MovieTrackingSettings {
        /* ** tool settings ** */
 
        /* set scale */
-       float dist;                 /* distance between two bundles used for scene scaling */
+       /** Distance between two bundles used for scene scaling. */
+       float dist;
 
        /* cleanup */
        int clean_frames, clean_action;
        float clean_error;
 
        /* set object scale */
-       float object_distance;      /* distance between two bundles used for object scaling */
+       /** Distance between two bundles used for object scaling. */
+       float object_distance;
 
        int pad3;
 } MovieTrackingSettings;
 
 typedef struct MovieTrackingStabilization {
        int flag;
-       int tot_track, act_track;       /* total number and index of active track in list */
+       /** Total number of translation tracks and index of active track in list. */
+       int tot_track, act_track;
+       /** Total number of rotation tracks and index of active track in list. */
+       int tot_rot_track, act_rot_track;
 
        /* 2d stabilization */
-       float maxscale;         /* max auto-scale factor */
-       MovieTrackingTrack *rot_track;  /* track used to stabilize rotation */
-
-       float locinf, scaleinf, rotinf; /* influence on location, scale and rotation */
-
-       int filter;     /* filter used for pixel interpolation */
-
-       /* some pre-computing run-time variables */
-       int ok;                     /* are precomputed values and scaled buf relevant? */
-       float scale;                /* autoscale factor */
-
-       struct ImBuf *scaleibuf;    /* currently scaled ibuf */
+       /** Max auto-scale factor. */
+       float maxscale;
+       /** Use TRACK_USE_2D_STAB_ROT on individual tracks instead. */
+       MovieTrackingTrack *rot_track DNA_DEPRECATED;
+
+       /** Reference point to anchor stabilization offset. */
+       int anchor_frame;
+       /** Expected target position of frame after raw stabilization, will be subtracted. */
+       float target_pos[2];
+       /** Expected target rotation of frame after raw stabilization, will be compensated. */
+       float target_rot;
+       /** Zoom factor known to be present on original footage. Also used for autoscale. */
+       float scale;
+
+       /** Influence on location, scale and rotation. */
+       float locinf, scaleinf, rotinf;
+
+       /** Filter used for pixel interpolation. */
+       int filter;
+
+       /* initialization and run-time data */
+       /** Without effect now, we initialize on every frame. Formerly used for caching of init values. */
+       int ok DNA_DEPRECATED;
 } MovieTrackingStabilization;
 
 typedef struct MovieTrackingReconstruction {
        int flag;
 
-       float error;        /* average error of reconstruction */
+       /** Average error of reconstruction. */
+       float error;
 
-       int last_camera;        /* most recently used camera */
-       int camnr;              /* number of reconstructed cameras */
-       struct MovieReconstructedCamera *cameras;   /* reconstructed cameras */
+       /** Most recently used camera. */
+       int last_camera;
+       /** Number of reconstructed cameras. */
+       int camnr;
+       /** Reconstructed cameras. */
+       struct MovieReconstructedCamera *cameras;
 } MovieTrackingReconstruction;
 
 typedef struct MovieTrackingObject {
        struct MovieTrackingObject *next, *prev;
 
-       char name[64];          /* Name of tracking object, MAX_NAME */
+       /** Name of tracking object, MAX_NAME. */
+       char name[64];
        int flag;
-       float scale;            /* scale of object solution in amera space */
-
-       ListBase tracks;        /* list of tracks use to tracking this object */
-       MovieTrackingReconstruction reconstruction; /* reconstruction data for this object */
+       /** Scale of object solution in amera space. */
+       float scale;
+
+       /** List of tracks use to tracking this object. */
+       ListBase tracks;
+       /** List of plane tracks used by this object. */
+       ListBase plane_tracks;
+       /** Reconstruction data for this object. */
+       MovieTrackingReconstruction reconstruction;
+
+       /* reconstruction options */
+       /** Two keyframes for reconstruction initialization. */
+       int keyframe1, keyframe2;
 } MovieTrackingObject;
 
 typedef struct MovieTrackingStats {
@@ -229,23 +383,46 @@ typedef struct MovieTrackingStats {
 typedef struct MovieTrackingDopesheetChannel {
        struct MovieTrackingDopesheetChannel *next, *prev;
 
-       MovieTrackingTrack *track;  /* motion track for which channel is created */
+       /** Motion track for which channel is created. */
+       MovieTrackingTrack *track;
        int pad;
 
-       char name[64];          /* name of channel */
+       /** Name of channel. */
+       char name[64];
 
-       int tot_segment;        /* total number of segments */
-       int *segments;          /* tracked segments */
-       int max_segment, total_frames;  /* longest segment length and total number of tracked frames */
+       /** Total number of segments. */
+       int tot_segment;
+       /** Tracked segments. */
+       int *segments;
+       /** Longest segment length and total number of tracked frames. */
+       int max_segment, total_frames;
 } MovieTrackingDopesheetChannel;
 
+typedef struct MovieTrackingDopesheetCoverageSegment {
+       struct MovieTrackingDopesheetCoverageSegment *next, *prev;
+
+       int coverage;
+       int start_frame;
+       int end_frame;
+
+       int pad;
+} MovieTrackingDopesheetCoverageSegment;
+
 typedef struct MovieTrackingDopesheet {
-       int ok;                     /* flag if dopesheet information is still relevant */
+       /** Flag if dopesheet information is still relevant. */
+       int ok;
 
-       short sort_method;          /* method to be used to sort tracks */
-       short flag;                 /* dopesheet building flag such as inverted order of sort */
+       /** Method to be used to sort tracks. */
+       short sort_method;
+       /** Dopesheet building flag such as inverted order of sort. */
+       short flag;
 
-       /* runtime stuff */
+       /* ** runtime stuff ** */
+
+       /* summary */
+       ListBase coverage_segments;
+
+       /* detailed */
        ListBase channels;
        int tot_channel;
 
@@ -253,21 +430,40 @@ typedef struct MovieTrackingDopesheet {
 } MovieTrackingDopesheet;
 
 typedef struct MovieTracking {
-       MovieTrackingSettings settings; /* different tracking-related settings */
-       MovieTrackingCamera camera;     /* camera intrinsics */
-       ListBase tracks;                /* list of tracks used for camera object */
-       MovieTrackingReconstruction reconstruction; /* reconstruction data for camera object */
-       MovieTrackingStabilization stabilization;   /* stabilization data */
-       MovieTrackingTrack *act_track;      /* active track */
+       /** Different tracking-related settings. */
+       MovieTrackingSettings settings;
+       /** Camera intrinsics. */
+       MovieTrackingCamera camera;
+       /** List of tracks used for camera object. */
+       ListBase tracks;
+       /** List of plane tracks used by camera object. */
+       ListBase plane_tracks;
+       /** Reconstruction data for camera object. */
+       MovieTrackingReconstruction reconstruction;
+       /** Stabilization data. */
+       MovieTrackingStabilization stabilization;
+       /** Active track. */
+       MovieTrackingTrack *act_track;
+       /** Active plane track. */
+       MovieTrackingPlaneTrack *act_plane_track;
 
        ListBase objects;
-       int objectnr, tot_object;       /* index of active object and total number of objects */
+       /** Index of active object and total number of objects. */
+       int objectnr, tot_object;
 
-       MovieTrackingStats *stats;      /* statistics displaying in clip editor */
+       /** Statistics displaying in clip editor. */
+       MovieTrackingStats *stats;
 
-       MovieTrackingDopesheet dopesheet;   /* dopesheet data */
+       /** Dopesheet data. */
+       MovieTrackingDopesheet dopesheet;
 } MovieTracking;
 
+/* MovieTrackingCamera->distortion_model */
+enum {
+       TRACKING_DISTORTION_MODEL_POLYNOMIAL = 0,
+       TRACKING_DISTORTION_MODEL_DIVISION = 1
+};
+
 /* MovieTrackingCamera->units */
 enum {
        CAMERA_UNITS_PX = 0,
@@ -275,92 +471,154 @@ enum {
 };
 
 /* MovieTrackingMarker->flag */
-#define MARKER_DISABLED (1 << 0)
-#define MARKER_TRACKED  (1 << 1)
-#define MARKER_GRAPH_SEL_X (1 << 2)
-#define MARKER_GRAPH_SEL_Y (1 << 3)
-#define MARKER_GRAPH_SEL    (MARKER_GRAPH_SEL_X | MARKER_GRAPH_SEL_Y)
+enum {
+       MARKER_DISABLED    = (1 << 0),
+       MARKER_TRACKED     = (1 << 1),
+       MARKER_GRAPH_SEL_X = (1 << 2),
+       MARKER_GRAPH_SEL_Y = (1 << 3),
+       MARKER_GRAPH_SEL   = (MARKER_GRAPH_SEL_X | MARKER_GRAPH_SEL_Y)
+};
 
 /* MovieTrackingTrack->flag */
-#define TRACK_HAS_BUNDLE    (1 << 1)
-#define TRACK_DISABLE_RED   (1 << 2)
-#define TRACK_DISABLE_GREEN (1 << 3)
-#define TRACK_DISABLE_BLUE  (1 << 4)
-#define TRACK_HIDDEN        (1 << 5)
-#define TRACK_LOCKED        (1 << 6)
-#define TRACK_CUSTOMCOLOR   (1 << 7)
-#define TRACK_USE_2D_STAB   (1 << 8)
-#define TRACK_PREVIEW_GRAYSCALE (1 << 9)
-#define TRACK_DOPE_SEL      (1 << 10)
-#define TRACK_PREVIEW_ALPHA (1 << 11)
+enum {
+       TRACK_HAS_BUNDLE        = (1 << 1),
+       TRACK_DISABLE_RED       = (1 << 2),
+       TRACK_DISABLE_GREEN     = (1 << 3),
+       TRACK_DISABLE_BLUE      = (1 << 4),
+       TRACK_HIDDEN            = (1 << 5),
+       TRACK_LOCKED            = (1 << 6),
+       TRACK_CUSTOMCOLOR       = (1 << 7),
+       TRACK_USE_2D_STAB       = (1 << 8),
+       TRACK_PREVIEW_GRAYSCALE = (1 << 9),
+       TRACK_DOPE_SEL          = (1 << 10),
+       TRACK_PREVIEW_ALPHA     = (1 << 11),
+       TRACK_USE_2D_STAB_ROT   = (1 << 12)
+};
 
 /* MovieTrackingTrack->motion_model */
-#define TRACK_MOTION_MODEL_TRANSLATION                 0
-#define TRACK_MOTION_MODEL_TRANSLATION_ROTATION        1
-#define TRACK_MOTION_MODEL_TRANSLATION_SCALE           2
-#define TRACK_MOTION_MODEL_TRANSLATION_ROTATION_SCALE  3
-#define TRACK_MOTION_MODEL_AFFINE                      4
-#define TRACK_MOTION_MODEL_HOMOGRAPHY                  5
+enum {
+       TRACK_MOTION_MODEL_TRANSLATION                 = 0,
+       TRACK_MOTION_MODEL_TRANSLATION_ROTATION        = 1,
+       TRACK_MOTION_MODEL_TRANSLATION_SCALE           = 2,
+       TRACK_MOTION_MODEL_TRANSLATION_ROTATION_SCALE  = 3,
+       TRACK_MOTION_MODEL_AFFINE                      = 4,
+       TRACK_MOTION_MODEL_HOMOGRAPHY                  = 5
+};
 
 /* MovieTrackingTrack->algorithm_flag */
-#define TRACK_ALGORITHM_FLAG_USE_BRUTE                 (1 << 0)
-#define TRACK_ALGORITHM_FLAG_USE_NORMALIZATION (1 << 2)
-#define TRACK_ALGORITHM_FLAG_USE_MASK                  (1 << 3)
+enum {
+       TRACK_ALGORITHM_FLAG_USE_BRUTE                  = (1 << 0),
+       TRACK_ALGORITHM_FLAG_USE_NORMALIZATION  = (1 << 2),
+       TRACK_ALGORITHM_FLAG_USE_MASK                   = (1 << 3)
+};
 
 /* MovieTrackingTrack->adjframes */
-#define TRACK_MATCH_KEYFRAME        0
-#define TRACK_MATCH_PREVFRAME       1
+enum {
+       TRACK_MATCH_KEYFRAME  = 0,
+       TRACK_MATCH_PREVFRAME = 1
+};
 
 /* MovieTrackingSettings->flag */
-#define TRACKING_SETTINGS_SHOW_DEFAULT_EXPANDED (1 << 0)
+enum {
+       TRACKING_SETTINGS_SHOW_DEFAULT_EXPANDED = (1 << 0),
+       TRACKING_SETTINGS_SHOW_EXTRA_EXPANDED = (1 << 1)
+};
 
 /* MovieTrackingSettings->motion_flag */
-#define TRACKING_MOTION_TRIPOD      (1 << 0)
+enum {
+       TRACKING_MOTION_TRIPOD = (1 << 0),
 
-#define TRACKING_MOTION_MODAL       (TRACKING_MOTION_TRIPOD)
+       TRACKING_MOTION_MODAL  = (TRACKING_MOTION_TRIPOD)
+};
 
 /* MovieTrackingSettings->speed */
-#define TRACKING_SPEED_FASTEST      0
-#define TRACKING_SPEED_REALTIME     1
-#define TRACKING_SPEED_HALF         2
-#define TRACKING_SPEED_QUARTER      4
-#define TRACKING_SPEED_DOUBLE       5
+enum {
+       TRACKING_SPEED_FASTEST  = 0,
+       TRACKING_SPEED_REALTIME = 1,
+       TRACKING_SPEED_HALF     = 2,
+       TRACKING_SPEED_QUARTER  = 4,
+       TRACKING_SPEED_DOUBLE   = 5
+};
+
+/* MovieTrackingSettings->reconstruction_flag */
+enum {
+       /* TRACKING_USE_FALLBACK_RECONSTRUCTION = (1 << 0), */  /* DEPRECATED */
+       TRACKING_USE_KEYFRAME_SELECTION      = (1 << 1)
+};
 
 /* MovieTrackingSettings->refine_camera_intrinsics */
-#define REFINE_FOCAL_LENGTH         (1 << 0)
-#define REFINE_PRINCIPAL_POINT      (1 << 1)
-#define REFINE_RADIAL_DISTORTION_K1 (1 << 2)
-#define REFINE_RADIAL_DISTORTION_K2 (1 << 4)
+enum {
+       REFINE_FOCAL_LENGTH         = (1 << 0),
+       REFINE_PRINCIPAL_POINT      = (1 << 1),
+       REFINE_RADIAL_DISTORTION_K1 = (1 << 2),
+       REFINE_RADIAL_DISTORTION_K2 = (1 << 4)
+};
 
 /* MovieTrackingStrabilization->flag */
-#define TRACKING_2D_STABILIZATION   (1 << 0)
-#define TRACKING_AUTOSCALE          (1 << 1)
-#define TRACKING_STABILIZE_ROTATION (1 << 2)
+enum {
+       TRACKING_2D_STABILIZATION   = (1 << 0),
+       TRACKING_AUTOSCALE          = (1 << 1),
+       TRACKING_STABILIZE_ROTATION = (1 << 2),
+       TRACKING_STABILIZE_SCALE    = (1 << 3),
+       TRACKING_SHOW_STAB_TRACKS   = (1 << 5)
+};
 
 /* MovieTrackingStrabilization->filter */
-#define TRACKING_FILTER_NEAREAST    0
-#define TRACKING_FILTER_BILINEAR    1
-#define TRACKING_FILTER_BICUBIC     2
+enum {
+       TRACKING_FILTER_NEAREST  = 0,
+       TRACKING_FILTER_BILINEAR = 1,
+       TRACKING_FILTER_BICUBIC  = 2
+};
 
 /* MovieTrackingReconstruction->flag */
-#define TRACKING_RECONSTRUCTED  (1 << 0)
+enum {
+       TRACKING_RECONSTRUCTED = (1 << 0)
+};
 
 /* MovieTrackingObject->flag */
-#define TRACKING_OBJECT_CAMERA      (1 << 0)
+enum {
+       TRACKING_OBJECT_CAMERA = (1 << 0)
+};
 
-#define TRACKING_CLEAN_SELECT           0
-#define TRACKING_CLEAN_DELETE_TRACK     1
-#define TRACKING_CLEAN_DELETE_SEGMENT   2
+enum {
+       TRACKING_CLEAN_SELECT         = 0,
+       TRACKING_CLEAN_DELETE_TRACK   = 1,
+       TRACKING_CLEAN_DELETE_SEGMENT = 2
+};
 
 /* MovieTrackingDopesheet->sort_method */
-#define TRACKING_DOPE_SORT_NAME          0
-#define TRACKING_DOPE_SORT_LONGEST       1
-#define TRACKING_DOPE_SORT_TOTAL         2
-#define TRACKING_DOPE_SORT_AVERAGE_ERROR 3
+enum {
+       TRACKING_DOPE_SORT_NAME          = 0,
+       TRACKING_DOPE_SORT_LONGEST       = 1,
+       TRACKING_DOPE_SORT_TOTAL         = 2,
+       TRACKING_DOPE_SORT_AVERAGE_ERROR = 3
+};
 
 /* MovieTrackingDopesheet->flag */
-#define TRACKING_DOPE_SORT_INVERSE    (1 << 0)
-#define TRACKING_DOPE_SELECTED_ONLY   (1 << 1)
-#define TRACKING_DOPE_SHOW_HIDDEN     (1 << 2)
+enum {
+       TRACKING_DOPE_SORT_INVERSE  = (1 << 0),
+       TRACKING_DOPE_SELECTED_ONLY = (1 << 1),
+       TRACKING_DOPE_SHOW_HIDDEN   = (1 << 2)
+};
+
+/* MovieTrackingDopesheetCoverageSegment->trackness */
+enum {
+       TRACKING_COVERAGE_BAD        = 0,
+       TRACKING_COVERAGE_ACCEPTABLE = 1,
+       TRACKING_COVERAGE_OK         = 2
+};
+
+/* MovieTrackingPlaneMarker->flag */
+enum {
+       PLANE_MARKER_DISABLED = (1 << 0),
+       PLANE_MARKER_TRACKED  = (1 << 1),
+};
+
+/* MovieTrackingPlaneTrack->flag */
+enum {
+       PLANE_TRACK_HIDDEN  = (1 << 1),
+       PLANE_TRACK_LOCKED  = (1 << 2),
+       PLANE_TRACK_AUTOKEY = (1 << 3),
+};
 
-#endif
+#endif  /* __DNA_TRACKING_TYPES_H__ */