自学教程：C++ ED_space_clip_get_clip函数代码示例

static int circle_select_exec(bContext *C, wmOperator *op){	SpaceClip *sc = CTX_wm_space_clip(C);	ARegion *ar = CTX_wm_region(C);	MovieClip *clip = ED_space_clip_get_clip(sc);	MovieTracking *tracking = &clip->tracking;	MovieTrackingTrack *track;	ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);	int x, y, radius, width, height, mode, change = FALSE;	float zoomx, zoomy, offset[2], ellipse[2];	int framenr = ED_space_clip_get_clip_frame_number(sc);	/* get operator properties */	x = RNA_int_get(op->ptr, "x");	y = RNA_int_get(op->ptr, "y");	radius = RNA_int_get(op->ptr, "radius");	mode = RNA_int_get(op->ptr, "gesture_mode");	/* compute ellipse and position in unified coordinates */	ED_space_clip_get_size(sc, &width, &height);	ED_space_clip_get_zoom(sc, ar, &zoomx, &zoomy);	ellipse[0] = width * zoomx / radius;	ellipse[1] = height * zoomy / radius;	ED_clip_point_stable_pos(sc, ar, x, y, &offset[0], &offset[1]);	/* do selection */	track = tracksbase->first;	while (track) {		if ((track->flag & TRACK_HIDDEN) == 0) {			MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);			if (MARKER_VISIBLE(sc, track, marker) && marker_inside_ellipse(marker, offset, ellipse)) {				if (mode == GESTURE_MODAL_SELECT)					BKE_tracking_track_flag_set(track, TRACK_AREA_ALL, SELECT);				else					BKE_tracking_track_flag_clear(track, TRACK_AREA_ALL, SELECT);				change = TRUE;			}		}		track = track->next;	}	if (change) {		BKE_tracking_dopesheet_tag_update(tracking);		WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);		return OPERATOR_FINISHED;	}	return OPERATOR_CANCELLED;}

static int set_origin_exec(bContext *C, wmOperator *op){  SpaceClip *sc = CTX_wm_space_clip(C);  MovieClip *clip = ED_space_clip_get_clip(sc);  MovieTracking *tracking = &clip->tracking;  Scene *scene = CTX_data_scene(C);  Object *camera = get_camera_with_movieclip(scene, clip);  int selected_count = count_selected_bundles(C);  if (selected_count == 0) {    BKE_report(op->reports,               RPT_ERROR,               "At least one track with bundle should be selected to "               "define origin position");    return OPERATOR_CANCELLED;  }  Object *object = get_orientation_object(C);  if (object == NULL) {    BKE_report(op->reports, RPT_ERROR, "No object to apply orientation on");    return OPERATOR_CANCELLED;  }  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);  ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);  float median[3] = {0.0f, 0.0f, 0.0f};  zero_v3(median);  for (MovieTrackingTrack *track = tracksbase->first; track != NULL; track = track->next) {    if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_HAS_BUNDLE)) {      add_v3_v3(median, track->bundle_pos);    }  }  mul_v3_fl(median, 1.0f / selected_count);  float mat[4][4], vec[3];  BKE_tracking_get_camera_object_matrix(scene, camera, mat);  mul_v3_m4v3(vec, mat, median);  if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {    sub_v3_v3(object->loc, vec);  }  else {    object_solver_inverted_matrix(scene, object, mat);    mul_v3_m4v3(vec, mat, vec);    copy_v3_v3(object->loc, vec);  }  DEG_id_tag_update(&clip->id, 0);  DEG_id_tag_update(&object->id, ID_RECALC_TRANSFORM);  WM_event_add_notifier(C, NC_MOVIECLIP | NA_EVALUATED, clip);  WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);  return OPERATOR_FINISHED;}

static int apply_solution_scale_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event)){  SpaceClip *sc = CTX_wm_space_clip(C);  MovieClip *clip = ED_space_clip_get_clip(sc);  if (!RNA_struct_property_is_set(op->ptr, "distance")) {    RNA_float_set(op->ptr, "distance", clip->tracking.settings.dist);  }  return apply_solution_scale_exec(C, op);}

void clip_draw_cache_and_notes(const bContext *C, SpaceClip *sc, ARegion *ar){	Scene *scene = CTX_data_scene(C);	MovieClip *clip = ED_space_clip_get_clip(sc);	if (clip) {		draw_movieclip_cache(sc, ar, clip, scene);		draw_movieclip_notes(sc, ar);	}}

static bool mouse_select_knot(bContext *C, float co[2], bool extend){	SpaceClip *sc = CTX_wm_space_clip(C);	MovieClip *clip = ED_space_clip_get_clip(sc);	ARegion *ar = CTX_wm_region(C);	View2D *v2d = &ar->v2d;	MovieTracking *tracking = &clip->tracking;	MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);	static const int delta = 6;	if (act_track) {		MouseSelectUserData userdata;		mouse_select_init_data(&userdata, co);		clip_graph_tracking_values_iterate_track(sc, act_track, &userdata,		                                         find_nearest_tracking_knot_cb, NULL, NULL);		if (userdata.marker) {			int x1, y1, x2, y2;			if (UI_view2d_view_to_region_clip(v2d, co[0], co[1], &x1, &y1) &&			    UI_view2d_view_to_region_clip(v2d, userdata.min_co[0], userdata.min_co[1], &x2, &y2) &&			    (abs(x2 - x1) <= delta && abs(y2 - y1) <= delta))			{				if (!extend) {					SelectUserData selectdata = {SEL_DESELECT};					clip_graph_tracking_iterate(sc,					                            (sc->flag & SC_SHOW_GRAPH_SEL_ONLY) != 0,					                            (sc->flag & SC_SHOW_GRAPH_HIDDEN) != 0,					                            &selectdata,					                            toggle_selection_cb);				}				if (userdata.coord == 0) {					if (extend && (userdata.marker->flag & MARKER_GRAPH_SEL_X) != 0)						userdata.marker->flag &= ~MARKER_GRAPH_SEL_X;					else						userdata.marker->flag |= MARKER_GRAPH_SEL_X;				}				else {					if (extend && (userdata.marker->flag & MARKER_GRAPH_SEL_Y) != 0)						userdata.marker->flag &= ~MARKER_GRAPH_SEL_Y;					else						userdata.marker->flag |= MARKER_GRAPH_SEL_Y;				}				return true;			}		}	}	return false;}

static int do_lasso_select_marker(bContext *C, int mcords[][2], short moves, short select){	SpaceClip *sc = CTX_wm_space_clip(C);	ARegion *ar = CTX_wm_region(C);	MovieClip *clip = ED_space_clip_get_clip(sc);	MovieTracking *tracking = &clip->tracking;	MovieTrackingTrack *track;	ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);	rcti rect;	int change = FALSE;	int framenr = ED_space_clip_get_clip_frame_number(sc);	/* get rectangle from operator */	BLI_lasso_boundbox(&rect, mcords, moves);	/* do actual selection */	track = tracksbase->first;	while (track) {		if ((track->flag & TRACK_HIDDEN) == 0) {			MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);			if (MARKER_VISIBLE(sc, track, marker)) {				float screen_co[2];				/* marker in screen coords */				ED_clip_point_stable_pos__reverse(sc, ar, marker->pos, screen_co);				if (BLI_in_rcti(&rect, screen_co[0], screen_co[1]) &&				    BLI_lasso_is_point_inside(mcords, moves, screen_co[0], screen_co[1], V2D_IS_CLIPPED))				{					if (select)						BKE_tracking_track_flag_set(track, TRACK_AREA_ALL, SELECT);					else						BKE_tracking_track_flag_clear(track, TRACK_AREA_ALL, SELECT);				}				change = TRUE;			}		}		track = track->next;	}	if (change) {		BKE_tracking_dopesheet_tag_update(tracking);		WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);	}	return change;}

static bool apply_solution_scale_poll(bContext *C){  SpaceClip *sc = CTX_wm_space_clip(C);  if (sc != NULL) {    MovieClip *clip = ED_space_clip_get_clip(sc);    if (clip != NULL) {      MovieTracking *tracking = &clip->tracking;      MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);      return (tracking_object->flag & TRACKING_OBJECT_CAMERA) != 0;    }  }  return 0;}

static int count_selected_bundles(bContext *C){  SpaceClip *sc = CTX_wm_space_clip(C);  MovieClip *clip = ED_space_clip_get_clip(sc);  ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);  int tot = 0;  for (MovieTrackingTrack *track = tracksbase->first; track != NULL; track = track->next) {    if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_HAS_BUNDLE)) {      tot++;    }  }  return tot;}

static int delete_curve_exec(bContext *C, wmOperator *UNUSED(op)){	SpaceClip *sc = CTX_wm_space_clip(C);	MovieClip *clip = ED_space_clip_get_clip(sc);	MovieTracking *tracking = &clip->tracking;	MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);	if (!act_track)		return OPERATOR_CANCELLED;	clip_delete_track(C, clip, act_track);	return OPERATOR_FINISHED;}

static MovieTrackingPlaneTrack *tracking_plane_marker_check_slide(bContext *C,                                                                  const wmEvent *event,                                                                  int *corner_r){  const float distance_clip_squared = 12.0f * 12.0f;  SpaceClip *sc = CTX_wm_space_clip(C);  ARegion *ar = CTX_wm_region(C);  MovieClip *clip = ED_space_clip_get_clip(sc);  MovieTracking *tracking = &clip->tracking;  int width, height;  float co[2];  ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(tracking);  int framenr = ED_space_clip_get_clip_frame_number(sc);  ED_space_clip_get_size(sc, &width, &height);  if (width == 0 || height == 0) {    return NULL;  }  ED_clip_mouse_pos(sc, ar, event->mval, co);  float min_distance_squared = FLT_MAX;  int min_corner = -1;  MovieTrackingPlaneTrack *min_plane_track = NULL;  for (MovieTrackingPlaneTrack *plane_track = plane_tracks_base->first; plane_track != NULL;       plane_track = plane_track->next) {    if (PLANE_TRACK_VIEW_SELECTED(plane_track)) {      MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get(plane_track, framenr);      for (int i = 0; i < 4; i++) {        float distance_squared = mouse_to_plane_slide_zone_distance_squared(            co, plane_marker->corners[i], width, height);        if (distance_squared < min_distance_squared) {          min_distance_squared = distance_squared;          min_corner = i;          min_plane_track = plane_track;        }      }    }  }  if (min_distance_squared < distance_clip_squared / sc->zoom) {    if (corner_r != NULL) {      *corner_r = min_corner;    }    return min_plane_track;  }  return NULL;}

static int graph_select_all_markers_exec(bContext *C, wmOperator *op){	SpaceClip *sc = CTX_wm_space_clip(C);	MovieClip *clip = ED_space_clip_get_clip(sc);	MovieTracking *tracking = &clip->tracking;	MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);	MovieTrackingMarker *marker;	int action = RNA_enum_get(op->ptr, "action");	int a;	if (!act_track)		return OPERATOR_CANCELLED;	if (action == SEL_TOGGLE) {		action = SEL_SELECT;		for (a = 0; a < act_track->markersnr; a++) {			marker = &act_track->markers[a];			if (marker->flag & MARKER_GRAPH_SEL) {				action = SEL_DESELECT;				break;			}		}	}	for (a = 0; a < act_track->markersnr; a++) {		marker = &act_track->markers[a];		switch (action) {			case SEL_SELECT:				marker->flag |= MARKER_GRAPH_SEL;				break;			case SEL_DESELECT:				marker->flag &= ~MARKER_GRAPH_SEL;				break;			case SEL_INVERT:				marker->flag ^= MARKER_GRAPH_SEL;				break;		}	}	WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);	return OPERATOR_FINISHED;}

static int set_axis_exec(bContext *C, wmOperator *op){    SpaceClip *sc = CTX_wm_space_clip(C);    MovieClip *clip = ED_space_clip_get_clip(sc);    MovieTracking *tracking = &clip->tracking;    MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);    Scene *scene = CTX_data_scene(C);    Object *object;    int axis = RNA_enum_get(op->ptr, "axis");    if (count_selected_bundles(C) != 1) {        BKE_report(op->reports,                   RPT_ERROR,                   "Single track with bundle should be selected to define axis");        return OPERATOR_CANCELLED;    }    object = get_orientation_object(C);    if (object == NULL) {        BKE_report(op->reports, RPT_ERROR, "No object to apply orientation on");        return OPERATOR_CANCELLED;    }    ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking,                           tracking_object);    MovieTrackingTrack *track = tracksbase->first;    while (track) {        if (TRACK_VIEW_SELECTED(sc, track) &&                (track->flag & TRACK_HAS_BUNDLE))        {            break;        }        track = track->next;    }    set_axis(scene, object, clip, tracking_object, track, axis == 0 ? 'X' : 'Y');    DAG_id_tag_update(&clip->id, 0);    DAG_id_tag_update(&object->id, OB_RECALC_OB);    WM_event_add_notifier(C, NC_MOVIECLIP | NA_EVALUATED, clip);    WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);    return OPERATOR_FINISHED;}

static bool mouse_select_curve(bContext *C, float co[2], bool extend){	SpaceClip *sc = CTX_wm_space_clip(C);	MovieClip *clip = ED_space_clip_get_clip(sc);	MovieTracking *tracking = &clip->tracking;	MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);	MouseSelectUserData userdata;	mouse_select_init_data(&userdata, co);	clip_graph_tracking_values_iterate(sc,	                                   (sc->flag & SC_SHOW_GRAPH_SEL_ONLY) != 0,	                                   (sc->flag & SC_SHOW_GRAPH_HIDDEN) != 0,	                                   &userdata, find_nearest_tracking_segment_cb,	                                   NULL, find_nearest_tracking_segment_end_cb);	if (userdata.track) {		if (extend) {			if (act_track == userdata.track) {				/* currently only single curve can be selected (selected curve represents active track) */				act_track = NULL;			}		}		else if (act_track != userdata.track) {			SelectUserData selectdata = {SEL_DESELECT};			MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);			tracking->act_track = userdata.track;			if ((sc->flag & SC_SHOW_GRAPH_SEL_ONLY) == 0) {				ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);				BKE_tracking_track_select(tracksbase, userdata.track, TRACK_AREA_ALL, false);			}			/* deselect all knots on newly selected curve */			clip_graph_tracking_iterate(sc,			                            (sc->flag & SC_SHOW_GRAPH_SEL_ONLY) != 0,			                            (sc->flag & SC_SHOW_GRAPH_HIDDEN) != 0,			                            &selectdata, toggle_selection_cb);		}		return true;	}	return false;}

static int dopesheet_select_channel_exec(bContext *C, wmOperator *op){	SpaceClip *sc = CTX_wm_space_clip(C);	MovieClip *clip = ED_space_clip_get_clip(sc);	MovieTracking *tracking = &clip->tracking;	MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);	MovieTrackingDopesheet *dopesheet = &tracking->dopesheet;	MovieTrackingDopesheetChannel *channel;	ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);	float location[2];	const bool extend = RNA_boolean_get(op->ptr, "extend");	int current_channel_index = 0, channel_index;	const bool show_selected_only = (dopesheet->flag & TRACKING_DOPE_SELECTED_ONLY) != 0;	RNA_float_get_array(op->ptr, "location", location);	channel_index = -(location[1] - (CHANNEL_FIRST + CHANNEL_HEIGHT_HALF)) / CHANNEL_STEP;	for (channel = dopesheet->channels.first; channel; channel = channel->next) {		MovieTrackingTrack *track = channel->track;		if (current_channel_index == channel_index) {			if (extend)				track->flag ^= TRACK_DOPE_SEL;			else				track->flag |= TRACK_DOPE_SEL;			if (track->flag & TRACK_DOPE_SEL) {				tracking->act_track = track;				BKE_tracking_track_select(tracksbase, track, TRACK_AREA_ALL, true);			}			else if (show_selected_only == false) {				BKE_tracking_track_deselect(track, TRACK_AREA_ALL);			}		}		else if (!extend)			track->flag &= ~TRACK_DOPE_SEL;		current_channel_index++;	}	WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);	return OPERATOR_FINISHED;}

static void draw_movieclip_notes(SpaceClip *sc, ARegion *ar){	MovieClip *clip = ED_space_clip_get_clip(sc);	MovieTracking *tracking = &clip->tracking;	char str[256] = {0};	int block = FALSE;	if (tracking->stats) {		BLI_strncpy(str, tracking->stats->message, sizeof(str));		block = TRUE;	}	else {		if (sc->flag & SC_LOCK_SELECTION)			strcpy(str, "Locked");	}	if (str[0])		ED_region_info_draw(ar, str, block, 0.6f);}

static bool set_orientation_poll(bContext *C){  SpaceClip *sc = CTX_wm_space_clip(C);  if (sc != NULL) {    ViewLayer *view_layer = CTX_data_view_layer(C);    MovieClip *clip = ED_space_clip_get_clip(sc);    if (clip != NULL) {      MovieTracking *tracking = &clip->tracking;      MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);      if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {        return true;      }      else {        return OBACT(view_layer) != NULL;      }    }  }  return false;}

static int mouse_select(bContext *C, float co[2], int extend){	SpaceClip *sc = CTX_wm_space_clip(C);	MovieClip *clip = ED_space_clip_get_clip(sc);	MovieTracking *tracking = &clip->tracking;	ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);	MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);	MovieTrackingTrack *track = NULL;   /* selected marker */	track = find_nearest_track(sc, tracksbase, co);	if (track) {		int area = track_mouse_area(C, co, track);		if (!extend || !TRACK_VIEW_SELECTED(sc, track))			area = TRACK_AREA_ALL;		if (extend && TRACK_AREA_SELECTED(track, area)) {			if (track == act_track)				BKE_tracking_track_deselect(track, area);			else				clip->tracking.act_track = track;		}		else {			if (area == TRACK_AREA_POINT)				area = TRACK_AREA_ALL;			BKE_tracking_track_select(tracksbase, track, area, extend);			clip->tracking.act_track = track;		}	}	if (!extend) {		sc->xlockof = 0.0f;		sc->ylockof = 0.0f;	}	BKE_tracking_dopesheet_tag_update(tracking);	WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);	return OPERATOR_FINISHED;}

static void draw_movieclip_buffer(const bContext *C, SpaceClip *sc, ARegion *ar, ImBuf *ibuf,                                  int width, int height, float zoomx, float zoomy){	MovieClip *clip = ED_space_clip_get_clip(sc);	int filter = GL_LINEAR;	int x, y;	/* find window pixel coordinates of origin */	UI_view2d_view_to_region(&ar->v2d, 0.0f, 0.0f, &x, &y);	/* checkerboard for case alpha */	if (ibuf->planes == 32) {		glEnable(GL_BLEND);		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);		fdrawcheckerboard(x, y, x + zoomx * ibuf->x, y + zoomy * ibuf->y);	}	/* non-scaled proxy shouldn't use filtering */	if ((clip->flag & MCLIP_USE_PROXY) == 0 ||	    ELEM(sc->user.render_size, MCLIP_PROXY_RENDER_SIZE_FULL, MCLIP_PROXY_RENDER_SIZE_100))	{		filter = GL_NEAREST;	}	/* set zoom */	glPixelZoom(zoomx * width / ibuf->x, zoomy * height / ibuf->y);	glaDrawImBuf_glsl_ctx(C, ibuf, x, y, filter);	/* reset zoom */	glPixelZoom(1.0f, 1.0f);	if (sc->flag & SC_SHOW_METADATA) {		rctf frame;		BLI_rctf_init(&frame, 0.0f, ibuf->x, 0.0f, ibuf->y);		ED_region_image_metadata_draw(x, y, ibuf, &frame, zoomx * width / ibuf->x, zoomy * height / ibuf->y);	}	if (ibuf->planes == 32)		glDisable(GL_BLEND);}

static void draw_movieclip_notes(SpaceClip *sc, ARegion *ar){	MovieClip *clip = ED_space_clip_get_clip(sc);	MovieTracking *tracking = &clip->tracking;	char str[256] = {0};	bool block = false;	if (tracking->stats) {		BLI_strncpy(str, tracking->stats->message, sizeof(str));		block = true;	}	else {		if (sc->flag & SC_LOCK_SELECTION)			strcpy(str, "Locked");	}	if (str[0]) {		float fill_color[4] = {0.0f, 0.0f, 0.0f, 0.6f};		ED_region_info_draw(ar, str, block, fill_color);	}}

static void draw_tracks_motion_curves(View2D *v2d, SpaceClip *sc){	MovieClip *clip = ED_space_clip_get_clip(sc);	MovieTracking *tracking = &clip->tracking;	MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);	int width, height;	TrackMotionCurveUserData userdata;	BKE_movieclip_get_size(clip, &sc->user, &width, &height);	if (!width || !height)		return;	/* non-selected knot handles */	userdata.hsize = UI_GetThemeValuef(TH_HANDLE_VERTEX_SIZE);	userdata.sel = false;	userdata.act_track = act_track;	UI_view2d_scale_get(v2d, &userdata.xscale, &userdata.yscale);	clip_graph_tracking_values_iterate(sc,	                                   (sc->flag & SC_SHOW_GRAPH_SEL_ONLY) != 0,	                                   (sc->flag & SC_SHOW_GRAPH_HIDDEN) != 0,	                                   &userdata, tracking_segment_knot_cb, NULL, NULL);	/* draw graph lines */	glEnable(GL_BLEND);	clip_graph_tracking_values_iterate(sc,	                                   (sc->flag & SC_SHOW_GRAPH_SEL_ONLY) != 0,	                                   (sc->flag & SC_SHOW_GRAPH_HIDDEN) != 0,	                                   act_track, tracking_segment_point_cb, tracking_segment_start_cb,	                                   tracking_segment_end_cb);	glDisable(GL_BLEND);	/* selected knot handles on top of curves */	userdata.sel = true;	clip_graph_tracking_values_iterate(sc,	                                   (sc->flag & SC_SHOW_GRAPH_SEL_ONLY) != 0,	                                   (sc->flag & SC_SHOW_GRAPH_HIDDEN) != 0,	                                   &userdata, tracking_segment_knot_cb, NULL, NULL);}

static Object *get_orientation_object(bContext *C){    Scene *scene = CTX_data_scene(C);    SpaceClip *sc = CTX_wm_space_clip(C);    MovieClip *clip = ED_space_clip_get_clip(sc);    MovieTracking *tracking = &clip->tracking;    MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);    Object *object = NULL;    if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {        object = get_camera_with_movieclip(scene, clip);    }    else {        object = OBACT;    }    if (object != NULL && object->parent != NULL) {        object = object->parent;    }    return object;}

static int delete_knot_exec(bContext *C, wmOperator *UNUSED(op)){	SpaceClip *sc = CTX_wm_space_clip(C);	MovieClip *clip = ED_space_clip_get_clip(sc);	MovieTracking *tracking = &clip->tracking;	MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);	if (act_track) {		int a = 0;		while (a < act_track->markersnr) {			MovieTrackingMarker *marker = &act_track->markers[a];			if (marker->flag & MARKER_GRAPH_SEL)				clip_delete_marker(C, clip, act_track, marker);			else				a++;		}	}	return OPERATOR_FINISHED;}

void clip_graph_tracking_values_iterate(        SpaceClip *sc, bool selected_only, bool include_hidden, void *userdata,        void (*func)(void *userdata, MovieTrackingTrack *track, MovieTrackingMarker *marker,                     int coord, int scene_framenr, float val),        void (*segment_start)(void *userdata, MovieTrackingTrack *track, int coord),        void (*segment_end)(void *userdata, int coord)){	MovieClip *clip = ED_space_clip_get_clip(sc);	MovieTracking *tracking = &clip->tracking;	ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);	MovieTrackingTrack *track;	for (track = tracksbase->first; track; track = track->next) {		if (!include_hidden && (track->flag & TRACK_HIDDEN) != 0)			continue;		if (selected_only && !TRACK_SELECTED(track))			continue;		clip_graph_tracking_values_iterate_track(sc, track, userdata, func, segment_start, segment_end);	}}

static int clip_rebuild_proxy_exec(bContext *C, wmOperator *UNUSED(op)){	wmJob *wm_job;	ProxyJob *pj;	Scene *scene = CTX_data_scene(C);	ScrArea *sa = CTX_wm_area(C);	SpaceClip *sc = CTX_wm_space_clip(C);	MovieClip *clip = ED_space_clip_get_clip(sc);	if ((clip->flag & MCLIP_USE_PROXY) == 0)		return OPERATOR_CANCELLED;	wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), sa, "Building Proxies",	                     WM_JOB_PROGRESS, WM_JOB_TYPE_CLIP_BUILD_PROXY);	pj = MEM_callocN(sizeof(ProxyJob), "proxy rebuild job");	pj->scene = scene;	pj->main = CTX_data_main(C);	pj->clip = clip;	pj->clip_flag = clip->flag & MCLIP_TIMECODE_FLAGS;	if (clip->anim) {		pj->index_context = IMB_anim_index_rebuild_context(clip->anim, clip->proxy.build_tc_flag,		                                                   clip->proxy.build_size_flag, clip->proxy.quality,		                                                   true, NULL);	}	WM_jobs_customdata_set(wm_job, pj, proxy_freejob);	WM_jobs_timer(wm_job, 0.2, NC_MOVIECLIP | ND_DISPLAY, 0);	WM_jobs_callbacks(wm_job, proxy_startjob, NULL, NULL, proxy_endjob);	G.is_break = false;	WM_jobs_start(CTX_wm_manager(C), wm_job);	ED_area_tag_redraw(sa);	return OPERATOR_FINISHED;}

/* draw grease pencil */void clip_draw_grease_pencil(bContext *C, int onlyv2d){	SpaceClip *sc = CTX_wm_space_clip(C);	MovieClip *clip = ED_space_clip_get_clip(sc);	if (!clip)		return;	if (onlyv2d) {		bool is_track_source = sc->gpencil_src == SC_GPENCIL_SRC_TRACK;		/* if manual calibration is used then grease pencil data		 * associated with the clip is already drawn in draw_distortion		 */		if ((sc->flag & SC_MANUAL_CALIBRATION) == 0 || is_track_source) {			glPushMatrix();			glMultMatrixf(sc->unistabmat);			if (is_track_source) {				MovieTrackingTrack *track = BKE_tracking_track_get_active(&sc->clip->tracking);				if (track) {					int framenr = ED_space_clip_get_clip_frame_number(sc);					MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);					glTranslate2fv(marker->pos);				}			}			ED_gpencil_draw_2dimage(C);			glPopMatrix();		}	}	else {		ED_gpencil_draw_view2d(C, 0);	}}

static void draw_stabilization_border(SpaceClip *sc, ARegion *ar, int width, int height, float zoomx, float zoomy){	int x, y;	MovieClip *clip = ED_space_clip_get_clip(sc);	/* find window pixel coordinates of origin */	UI_view2d_view_to_region(&ar->v2d, 0.0f, 0.0f, &x, &y);	/* draw boundary border for frame if stabilization is enabled */	if (sc->flag & SC_SHOW_STABLE && clip->tracking.stabilization.flag & TRACKING_2D_STABILIZATION) {		glColor3f(0.0f, 0.0f, 0.0f);		GPU_basic_shader_bind_enable(GPU_SHADER_LINE | GPU_SHADER_STIPPLE);		GPU_basic_shader_line_stipple(3, 0xAAAA);		glEnable(GL_COLOR_LOGIC_OP);		glLogicOp(GL_NOR);		glPushMatrix();		glTranslatef(x, y, 0.0f);		glScalef(zoomx, zoomy, 1.0f);		glMultMatrixf(sc->stabmat);		glBegin(GL_LINE_LOOP);		glVertex2f(0.0f, 0.0f);		glVertex2f(width, 0.0f);		glVertex2f(width, height);		glVertex2f(0.0f, height);		glEnd();		glPopMatrix();		glDisable(GL_COLOR_LOGIC_OP);		GPU_basic_shader_bind_disable(GPU_SHADER_LINE | GPU_SHADER_STIPPLE);	}}