DNA_tracking_types.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2011 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "DNA_defs.h"
#include "DNA_listBase.h"
 
/* match-moving data */
 
struct Image;
struct MovieReconstructedCamera;
struct MovieTracking;
struct MovieTrackingCamera;
struct MovieTrackingMarker;
struct MovieTrackingTrack;
struct bGPdata;
 
typedef struct MovieReconstructedCamera {
  int framenr;
  float error;
  float mat[4][4];
} MovieReconstructedCamera;
 
typedef struct MovieTrackingCamera {
  void *intrinsics;
 
  short distortion_model;
  char _pad[2];
 
  float sensor_width;
  float pixel_aspect;
  float focal;
  short units;
  char _pad1[2];
 
  float principal_point[2];
 
  float principal_legacy[2];
 
  /* Polynomial distortion */
  float k1, k2, k3;
 
  /* Division distortion model coefficients */
  float division_k1, division_k2;
 
  /* Nuke distortion model coefficients */
  float nuke_k1, nuke_k2;
 
  /* Brown-Conrady distortion model coefficients */
  float brown_k1, brown_k2, brown_k3, brown_k4;
  float brown_p1, brown_p2;
} MovieTrackingCamera;
 
typedef struct MovieTrackingMarker {
  float pos[2];
 
  /* corners of pattern in the following order:
   *
   *       Y
   *       ^
   *       | (3) --- (2)
   *       |  |       |
   *       |  |       |
   *       |  |       |
   *       | (0) --- (1)
   *       +-------------> X
   *
   * the coordinates are stored relative to pos.
   */
  float pattern_corners[4][2];
 
  /* positions of left-bottom and right-top corners of search area (in unified 0..1 units,
   * relative to marker->pos
   */
  float search_min[2], search_max[2];
 
  int framenr;
  int flag;
} MovieTrackingMarker;
 
typedef struct MovieTrackingTrack {
  struct MovieTrackingTrack *next, *prev;
 
  char name[64];
 
  /* ** settings ** */
 
  /* positions of left-bottom and right-top corners of pattern (in unified 0..1 units,
   * relative to marker->pos)
   * moved to marker's corners since planar tracking implementation
   */
  float pat_min_legacy[2], pat_max_legacy[2];
 
  /* positions of left-bottom and right-top corners of search area (in unified 0..1 units,
   * relative to marker->pos
   * moved to marker since affine tracking implementation
   */
  float search_min_legacy[2], search_max_legacy[2];
 
  float offset[2];
 
  /* ** track ** */
  int markersnr;
  int _pad;
  MovieTrackingMarker *markers;
 
  /* ** reconstruction data ** */
  float bundle_pos[3];
  float error;
 
  /* ** UI editing ** */
  int flag, pat_flag, search_flag;
  float color[3];
 
  /* ** control how tracking happens */
  short frames_limit;
  short margin;
  short pattern_match;
 
  /* tracking parameters */
  short motion_model;
  int algorithm_flag;
  float minimum_correlation;
 
  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 its
   * weight is zero and then it gets faded up.
   *
   * Used to prevent jumps of the camera when tracks are appearing or
   * disappearing.
   */
  float weight;
 
  /* 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];
 
  int framenr;
  int flag;
} MovieTrackingPlaneMarker;
 
typedef struct MovieTrackingPlaneTrack {
  struct MovieTrackingPlaneTrack *next, *prev;
 
  char name[64];
 
  MovieTrackingTrack **point_tracks;
  int point_tracksnr;
  char _pad[4];
 
  MovieTrackingPlaneMarker *markers;
  int markersnr;
 
  int flag;
 
  struct Image *image;
  float image_opacity;
 
  /* Runtime data */
  int last_marker;
} MovieTrackingPlaneTrack;
 
typedef struct MovieTrackingSettings {
  /* ** default tracker settings */
  short default_motion_model;
  short default_algorithm_flag;
  float default_minimum_correlation;
  short default_pattern_size;
  short default_search_size;
  short default_frames_limit;
  short default_margin;
  short default_pattern_match;
  short default_flag;
  float default_weight;
 
  short motion_flag;
 
  /* ** common tracker settings ** */
  short speed;
 
  /* ** reconstruction settings ** */
  /* two keyframes for reconstruction initialization
   * were moved to per-tracking object settings
   */
  int keyframe1_legacy;
  int keyframe2_legacy;
 
  int reconstruction_flag;
 
  /* which camera intrinsics to refine. uses on the REFINE_* flags */
  int refine_camera_intrinsics;
 
  /* ** tool settings ** */
 
  /* set scale */
  float dist;
 
  /* cleanup */
  int clean_frames, clean_action;
  float clean_error;
 
  /* set object scale */
  float object_distance;
} MovieTrackingSettings;
 
typedef struct MovieTrackingStabilization {
  int flag;
  int tot_track, act_track;
  int tot_rot_track, act_rot_track;
 
  /* 2d stabilization */
  float maxscale;
  MovieTrackingTrack *rot_track_legacy;
 
  int anchor_frame;
  float target_pos[2];
  float target_rot;
  float scale;
 
  float locinf, scaleinf, rotinf;
 
  int filter;
 
  int _pad;
} MovieTrackingStabilization;
 
typedef struct MovieTrackingReconstruction {
  int flag;
 
  float error;
 
  int last_camera;
  int camnr;
  struct MovieReconstructedCamera *cameras;
} MovieTrackingReconstruction;
 
typedef struct MovieTrackingObject {
  struct MovieTrackingObject *next, *prev;
 
  char name[64];
  int flag;
  float scale;
 
  ListBase tracks;
  ListBase plane_tracks;
 
  MovieTrackingTrack *active_track;
  MovieTrackingPlaneTrack *active_plane_track;
 
  MovieTrackingReconstruction reconstruction;
 
  /* reconstruction options */
  int keyframe1, keyframe2;
} MovieTrackingObject;
 
typedef struct MovieTrackingStats {
  char message[256];
} MovieTrackingStats;
 
typedef struct MovieTrackingDopesheetChannel {
  struct MovieTrackingDopesheetChannel *next, *prev;
 
  MovieTrackingTrack *track;
  char _pad[4];
 
  char name[64];
 
  int tot_segment;
  int *segments;
  int max_segment, total_frames;
  int first_not_disabled_marker_framenr, last_not_disabled_marker_framenr;
} MovieTrackingDopesheetChannel;
 
typedef struct MovieTrackingDopesheetCoverageSegment {
  struct MovieTrackingDopesheetCoverageSegment *next, *prev;
 
  int coverage;
  int start_frame;
  int end_frame;
 
  char _pad[4];
} MovieTrackingDopesheetCoverageSegment;
 
typedef struct MovieTrackingDopesheet {
  int ok;
 
  short sort_method;
  short flag;
 
  /* ** runtime stuff ** */
 
  /* summary */
  ListBase coverage_segments;
 
  /* detailed */
  ListBase channels;
  int tot_channel;
 
  char _pad[4];
} MovieTrackingDopesheet;
 
typedef struct MovieTracking {
  MovieTrackingSettings settings;
  MovieTrackingCamera camera;
  ListBase tracks_legacy;
  ListBase plane_tracks_legacy;
 
  MovieTrackingReconstruction reconstruction_legacy;
 
  MovieTrackingStabilization stabilization;
 
  MovieTrackingTrack *act_track_legacy;
  MovieTrackingPlaneTrack *act_plane_track_legacy;
 
  ListBase objects;
  int objectnr, tot_object;
 
  MovieTrackingStats *stats;
 
  MovieTrackingDopesheet dopesheet;
} MovieTracking;
 
enum {
  TRACKING_DISTORTION_MODEL_POLYNOMIAL = 0,
  TRACKING_DISTORTION_MODEL_DIVISION = 1,
  TRACKING_DISTORTION_MODEL_NUKE = 2,
  TRACKING_DISTORTION_MODEL_BROWN = 3,
};
 
enum {
  CAMERA_UNITS_PX = 0,
  CAMERA_UNITS_MM = 1,
};
 
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),
};
 
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),
};
 
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,
};
 
enum {
  TRACK_ALGORITHM_FLAG_USE_BRUTE = (1 << 0),
  TRACK_ALGORITHM_FLAG_USE_NORMALIZATION = (1 << 2),
  TRACK_ALGORITHM_FLAG_USE_MASK = (1 << 3),
};
 
typedef enum eTrackFrameMatch {
  TRACK_MATCH_KEYFRAME = 0,
  TRACK_MATCH_PREVIOUS_FRAME = 1,
} eTrackFrameMatch;
 
enum {
  TRACKING_MOTION_TRIPOD = (1 << 0),
 
  TRACKING_MOTION_MODAL = (TRACKING_MOTION_TRIPOD),
};
 
enum {
  TRACKING_SPEED_FASTEST = 0,
  TRACKING_SPEED_REALTIME = 1,
  TRACKING_SPEED_HALF = 2,
  TRACKING_SPEED_QUARTER = 4,
  TRACKING_SPEED_DOUBLE = 5,
};
 
enum {
  /* TRACKING_USE_FALLBACK_RECONSTRUCTION = (1 << 0), */ /* DEPRECATED */
  TRACKING_USE_KEYFRAME_SELECTION = (1 << 1),
};
 
enum {
  REFINE_NO_INTRINSICS = (0),
 
  REFINE_FOCAL_LENGTH = (1 << 0),
  REFINE_PRINCIPAL_POINT = (1 << 1),
  REFINE_RADIAL_DISTORTION = (1 << 2),
  REFINE_TANGENTIAL_DISTORTION = (1 << 3),
};
 
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),
};
 
enum {
  TRACKING_FILTER_NEAREST = 0,
  TRACKING_FILTER_BILINEAR = 1,
  TRACKING_FILTER_BICUBIC = 2,
};
 
enum {
  TRACKING_RECONSTRUCTED = (1 << 0),
};
 
enum {
  TRACKING_OBJECT_CAMERA = (1 << 0),
};
 
enum {
  TRACKING_CLEAN_SELECT = 0,
  TRACKING_CLEAN_DELETE_TRACK = 1,
  TRACKING_CLEAN_DELETE_SEGMENT = 2,
};
 
enum {
  TRACKING_DOPE_SORT_NAME = 0,
  TRACKING_DOPE_SORT_LONGEST = 1,
  TRACKING_DOPE_SORT_TOTAL = 2,
  TRACKING_DOPE_SORT_AVERAGE_ERROR = 3,
  TRACKING_DOPE_SORT_START = 4,
  TRACKING_DOPE_SORT_END = 5,
};
 
enum {
  TRACKING_DOPE_SORT_INVERSE = (1 << 0),
  TRACKING_DOPE_SELECTED_ONLY = (1 << 1),
  TRACKING_DOPE_SHOW_HIDDEN = (1 << 2),
};
 
enum {
  TRACKING_COVERAGE_BAD = 0,
  TRACKING_COVERAGE_ACCEPTABLE = 1,
  TRACKING_COVERAGE_OK = 2,
};
 
enum {
  PLANE_MARKER_DISABLED = (1 << 0),
  PLANE_MARKER_TRACKED = (1 << 1),
};
 
enum {
  PLANE_TRACK_HIDDEN = (1 << 1),
  PLANE_TRACK_LOCKED = (1 << 2),
  PLANE_TRACK_AUTOKEY = (1 << 3),
};