diff options
Diffstat (limited to 'source/blender/editors/space_clip/tracking_ops.c')
-rw-r--r-- | source/blender/editors/space_clip/tracking_ops.c | 2941 |
1 files changed, 2941 insertions, 0 deletions
diff --git a/source/blender/editors/space_clip/tracking_ops.c b/source/blender/editors/space_clip/tracking_ops.c new file mode 100644 index 00000000000..e5bf053aa1c --- /dev/null +++ b/source/blender/editors/space_clip/tracking_ops.c @@ -0,0 +1,2941 @@ +/* + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * The Original Code is Copyright (C) 2011 Blender Foundation. + * All rights reserved. + * + * + * Contributor(s): Blender Foundation, + * Sergey Sharybin + * + * ***** END GPL LICENSE BLOCK ***** + */ + +/** \file blender/editors/space_clip/tracking_ops.c + * \ingroup spclip + */ + +#include "MEM_guardedalloc.h" + +#include "DNA_camera_types.h" +#include "DNA_gpencil_types.h" +#include "DNA_movieclip_types.h" +#include "DNA_object_types.h" /* SELECT */ +#include "DNA_scene_types.h" + +#include "BLI_utildefines.h" +#include "BLI_math.h" +#include "BLI_listbase.h" +#include "BLI_rect.h" +#include "BLI_blenlib.h" + +#include "BKE_main.h" +#include "BKE_context.h" +#include "BKE_movieclip.h" +#include "BKE_tracking.h" +#include "BKE_global.h" +#include "BKE_depsgraph.h" +#include "BKE_object.h" +#include "BKE_report.h" +#include "BKE_scene.h" +#include "BKE_library.h" +#include "BKE_sound.h" + +#include "WM_api.h" +#include "WM_types.h" + +#include "ED_screen.h" +#include "ED_clip.h" +#include "ED_keyframing.h" + +#include "IMB_imbuf_types.h" +#include "IMB_imbuf.h" + +#include "UI_interface.h" + +#include "RNA_access.h" +#include "RNA_define.h" + +#include "PIL_time.h" + +#include "UI_view2d.h" + +#include "clip_intern.h" // own include + +static int space_clip_frame_poll(bContext *C) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + + if(sc) { + MovieClip *clip= ED_space_clip(sc); + + if(clip) + return BKE_movieclip_has_frame(clip, &sc->user); + } + + return 0; +} + +static int space_clip_frame_camera_poll(bContext *C) +{ + Scene *scene= CTX_data_scene(C); + + if(space_clip_frame_poll(C)) { + return scene->camera != NULL; + } + + return 0; +} + +static int space_clip_camera_poll(bContext *C) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + Scene *scene= CTX_data_scene(C); + + if(sc && sc->clip && scene->camera) + return 1; + + return 0; +} + +/********************** add marker operator *********************/ + +static void add_marker(SpaceClip *sc, float x, float y) +{ + MovieClip *clip= ED_space_clip(sc); + MovieTrackingTrack *track; + int width, height; + + ED_space_clip_size(sc, &width, &height); + + track= BKE_tracking_add_track(&clip->tracking, x, y, sc->user.framenr, width, height); + + BKE_tracking_select_track(&clip->tracking, track, TRACK_AREA_ALL, 0); + + clip->tracking.act_track= track; +} + +static int add_marker_exec(bContext *C, wmOperator *op) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + float pos[2]; + int width, height; + + ED_space_clip_size(sc, &width, &height); + if(!width || !height) + return OPERATOR_CANCELLED; + + RNA_float_get_array(op->ptr, "location", pos); + + add_marker(sc, pos[0], pos[1]); + + /* reset offset from locked position, so frame jumping wouldn't be so confusing */ + sc->xlockof= 0; + sc->ylockof= 0; + + WM_event_add_notifier(C, NC_MOVIECLIP|NA_EDITED, clip); + + return OPERATOR_FINISHED; +} + +static int add_marker_invoke(bContext *C, wmOperator *op, wmEvent *event) +{ + float co[2]; + + ED_clip_mouse_pos(C, event, co); + + RNA_float_set_array(op->ptr, "location", co); + + return add_marker_exec(C, op); +} + +void CLIP_OT_add_marker(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Add Marker"; + ot->idname= "CLIP_OT_add_marker"; + ot->description= "Place new marker at specified location"; + + /* api callbacks */ + ot->invoke= add_marker_invoke; + ot->exec= add_marker_exec; + ot->poll= space_clip_frame_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + /* properties */ + RNA_def_float_vector(ot->srna, "location", 2, NULL, -FLT_MIN, FLT_MAX, + "Location", "Location of marker on frame", -1.0f, 1.0f); +} + +/********************** delete track operator *********************/ + +static int delete_track_exec(bContext *C, wmOperator *UNUSED(op)) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTracking *tracking= &clip->tracking; + MovieTrackingTrack *track= tracking->tracks.first, *next; + + while(track) { + next= track->next; + + if(TRACK_VIEW_SELECTED(sc, track)) + clip_delete_track(C, clip, track); + + track= next; + } + + /* nothing selected now, unlock view so it can be scrolled nice again */ + sc->flag&= ~SC_LOCK_SELECTION; + + return OPERATOR_FINISHED; +} + +void CLIP_OT_delete_track(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Delete Track"; + ot->idname= "CLIP_OT_delete_track"; + ot->description= "Delete selected tracks"; + + /* api callbacks */ + ot->invoke= WM_operator_confirm; + ot->exec= delete_track_exec; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; +} + +/********************** delete marker operator *********************/ + +static int delete_marker_exec(bContext *C, wmOperator *UNUSED(op)) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTrackingTrack *track= clip->tracking.tracks.first, *next; + int framenr= sc->user.framenr; + int has_selection= 0; + + while(track) { + next= track->next; + + if(TRACK_VIEW_SELECTED(sc, track)) { + MovieTrackingMarker *marker= BKE_tracking_exact_marker(track, framenr); + + if(marker) { + has_selection|= track->markersnr>1; + + clip_delete_marker(C, clip, track, marker); + } + } + + track= next; + } + + if(!has_selection) { + /* nothing selected now, unlock view so it can be scrolled nice again */ + sc->flag&= ~SC_LOCK_SELECTION; + } + + return OPERATOR_FINISHED; +} + +void CLIP_OT_delete_marker(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Delete Marker"; + ot->idname= "CLIP_OT_delete_marker"; + ot->description= "Delete marker for current frame from selected tracks"; + + /* api callbacks */ + ot->invoke= WM_operator_confirm; + ot->exec= delete_marker_exec; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; +} + +/********************** slide marker operator *********************/ + +#define SLIDE_ACTION_POS 0 +#define SLIDE_ACTION_SIZE 1 +#define SLIDE_ACTION_OFFSET 2 + +typedef struct { + int area, action; + MovieTrackingTrack *track; + MovieTrackingMarker *marker; + + int mval[2]; + int width, height; + float *min, *max, *pos, *offset; + float smin[2], smax[2], spos[2], soff[2]; + float (*smarkers)[2]; + + int lock, accurate; +} SlideMarkerData; + +static SlideMarkerData *create_slide_marker_data(SpaceClip *sc, MovieTrackingTrack *track, + MovieTrackingMarker *marker, wmEvent *event, int area, int action, int width, int height) +{ + SlideMarkerData *data= MEM_callocN(sizeof(SlideMarkerData), "slide marker data"); + + marker= BKE_tracking_ensure_marker(track, sc->user.framenr); + + data->area= area; + data->action= action; + data->track= track; + data->marker= marker; + + if(area==TRACK_AREA_POINT) { + data->pos= marker->pos; + data->offset= track->offset; + copy_v2_v2(data->spos, marker->pos); + copy_v2_v2(data->soff, track->offset); + } else if(area==TRACK_AREA_PAT) { + if(action==SLIDE_ACTION_SIZE) { + data->min= track->pat_min; + data->max= track->pat_max; + } else { + int a; + + data->pos= marker->pos; + data->offset= track->offset; + + copy_v2_v2(data->soff, track->offset); + + data->smarkers= MEM_callocN(sizeof(*data->smarkers)*track->markersnr, "slide marekrs"); + for(a= 0; a<track->markersnr; a++) + copy_v2_v2(data->smarkers[a], track->markers[a].pos); + } + } else if(area==TRACK_AREA_SEARCH) { + data->min= track->search_min; + data->max= track->search_max; + } + + if(area==TRACK_AREA_SEARCH || (area==TRACK_AREA_PAT && action!=SLIDE_ACTION_OFFSET)) { + copy_v2_v2(data->smin, data->min); + copy_v2_v2(data->smax, data->max); + } + + data->mval[0]= event->mval[0]; + data->mval[1]= event->mval[1]; + + data->width= width; + data->height= height; + + if(action==SLIDE_ACTION_SIZE) + data->lock= 1; + + return data; +} + +/* corner = 0: right-bottom corner, + corner = 1: left-top corner */ +static int mouse_on_corner(SpaceClip *sc, MovieTrackingTrack *track, MovieTrackingMarker *marker, + int area, float co[2], int corner, int width, int height) +{ + int inside= 0; + float size= 12.0f; + float min[2], max[2]; + float crn[2], dx, dy, tdx, tdy; + + if(area==TRACK_AREA_SEARCH) { + copy_v2_v2(min, track->search_min); + copy_v2_v2(max, track->search_max); + } else { + copy_v2_v2(min, track->pat_min); + copy_v2_v2(max, track->pat_max); + } + + dx= size/width/sc->zoom; + dy= size/height/sc->zoom; + + tdx= 5.0f/width/sc->zoom; + tdy= 5.0f/height/sc->zoom; + + dx= MIN2(dx, (max[0]-min[0])/6.0f) + tdx; + dy= MIN2(dy, (max[1]-min[1])/6.0f) + tdy; + + if(corner==0) { + crn[0]= marker->pos[0]+max[0]; + crn[1]= marker->pos[1]+min[1]; + + inside= co[0]>=crn[0]-dx && co[0]<=crn[0]+tdx && co[1]>=crn[1]-tdy && co[1]<=crn[1]+dy; + } else { + crn[0]= marker->pos[0]+min[0]; + crn[1]= marker->pos[1]+max[1]; + + inside= co[0]>=crn[0]-dx && co[0]<=crn[0]+dx && co[1]>=crn[1]-dy && co[1]<=crn[1]+dy; + } + + return inside; +} + +static int mouse_on_offset(SpaceClip *sc, MovieTrackingTrack *track, MovieTrackingMarker *marker, + float co[2], int width, int height) +{ + float pos[2], dx, dy; + + add_v2_v2v2(pos, marker->pos, track->offset); + + dx= 12.0f/width/sc->zoom; + dy= 12.0f/height/sc->zoom; + + dx=MIN2(dx, (track->pat_max[0]-track->pat_min[0])/2.0f); + dy=MIN2(dy, (track->pat_max[1]-track->pat_min[1])/2.0f); + + return co[0]>=pos[0]-dx && co[0]<=pos[0]+dx && co[1]>=pos[1]-dy && co[1]<=pos[1]+dy; +} + +static void hide_cursor(bContext *C) +{ + wmWindow *win= CTX_wm_window(C); + + WM_cursor_set(win, CURSOR_NONE); +} + +static void show_cursor(bContext *C) +{ + wmWindow *win= CTX_wm_window(C); + + WM_cursor_set(win, CURSOR_STD); +} + +static void *slide_marker_customdata(bContext *C, wmEvent *event) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTrackingTrack *track; + int width, height; + float co[2]; + void *customdata= NULL; + + ED_space_clip_size(sc, &width, &height); + + if(width==0 || height==0) + return NULL; + + ED_clip_mouse_pos(C, event, co); + + track= clip->tracking.tracks.first; + while(track) { + if(TRACK_VIEW_SELECTED(sc, track) && (track->flag&TRACK_LOCKED)==0) { + MovieTrackingMarker *marker= BKE_tracking_get_marker(track, sc->user.framenr); + + if((marker->flag&MARKER_DISABLED)==0) { + if(!customdata) + if(mouse_on_offset(sc, track, marker, co, width, height)) + customdata= create_slide_marker_data(sc, track, marker, event, TRACK_AREA_POINT, SLIDE_ACTION_POS, width, height); + + if(sc->flag&SC_SHOW_MARKER_SEARCH) { + if(mouse_on_corner(sc, track, marker, TRACK_AREA_SEARCH, co, 1, width, height)) + customdata= create_slide_marker_data(sc, track, marker, event, TRACK_AREA_SEARCH, SLIDE_ACTION_OFFSET, width, height); + else if(mouse_on_corner(sc, track, marker, TRACK_AREA_SEARCH, co, 0, width, height)) + customdata= create_slide_marker_data(sc, track, marker, event, TRACK_AREA_SEARCH, SLIDE_ACTION_SIZE, width, height); + } + + if(!customdata && sc->flag&SC_SHOW_MARKER_PATTERN) { + if(mouse_on_corner(sc, track, marker, TRACK_AREA_PAT, co, 1, width, height)) + customdata= create_slide_marker_data(sc, track, marker, event, TRACK_AREA_PAT, SLIDE_ACTION_OFFSET, width, height); + + if(!customdata && mouse_on_corner(sc, track, marker, TRACK_AREA_PAT, co, 0, width, height)) + customdata= create_slide_marker_data(sc, track, marker, event, TRACK_AREA_PAT, SLIDE_ACTION_SIZE, width, height); + } + + if(customdata) + break; + } + } + + track= track->next; + } + + return customdata; +} + +static int slide_marker_invoke(bContext *C, wmOperator *op, wmEvent *event) +{ + SlideMarkerData *slidedata= slide_marker_customdata(C, event); + + if(slidedata) { + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTracking *tracking= &clip->tracking; + + tracking->act_track= slidedata->track; + + op->customdata= slidedata; + + hide_cursor(C); + WM_event_add_modal_handler(C, op); + + WM_event_add_notifier(C, NC_GEOM|ND_SELECT, NULL); + + return OPERATOR_RUNNING_MODAL; + } + + return OPERATOR_PASS_THROUGH; +} + +static void cancel_mouse_slide(SlideMarkerData *data) +{ + /* cancel sliding */ + if(data->area == TRACK_AREA_POINT) { + if(data->action==SLIDE_ACTION_OFFSET) + copy_v2_v2(data->offset, data->soff); + else + copy_v2_v2(data->pos, data->spos); + } else { + if(data->action==SLIDE_ACTION_SIZE) { + copy_v2_v2(data->min, data->smin); + copy_v2_v2(data->max, data->smax); + } else { + int a; + + for(a= 0; a<data->track->markersnr; a++) + copy_v2_v2(data->track->markers[a].pos, data->smarkers[a]); + + copy_v2_v2(data->offset, data->soff); + } + } +} + +static void free_slide_data(SlideMarkerData *data) +{ + if(data->smarkers) MEM_freeN(data->smarkers); + MEM_freeN(data); +} + +static int slide_marker_modal(bContext *C, wmOperator *op, wmEvent *event) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + SlideMarkerData *data= (SlideMarkerData *)op->customdata; + float dx, dy, mdelta[2]; + + switch(event->type) { + case LEFTCTRLKEY: + case RIGHTCTRLKEY: + case LEFTSHIFTKEY: + case RIGHTSHIFTKEY: + if(data->action==SLIDE_ACTION_SIZE) + if(ELEM(event->type, LEFTCTRLKEY, RIGHTCTRLKEY)) + data->lock= event->val==KM_RELEASE; + + if(ELEM(event->type, LEFTSHIFTKEY, RIGHTSHIFTKEY)) + data->accurate= event->val==KM_PRESS; + + /* no break! update area size */ + + case MOUSEMOVE: + mdelta[0]= event->mval[0]-data->mval[0]; + mdelta[1]= event->mval[1]-data->mval[1]; + + dx= mdelta[0]/data->width/sc->zoom; + + if(data->lock) dy= -dx/data->height*data->width; + else dy= mdelta[1]/data->height/sc->zoom; + + if(data->accurate) { + dx/= 5; + dy/= 5; + } + + if(data->area==TRACK_AREA_POINT) { + if(data->action==SLIDE_ACTION_OFFSET) { + data->offset[0]= data->soff[0]+dx; + data->offset[1]= data->soff[1]+dy; + } else { + data->pos[0]= data->spos[0]+dx; + data->pos[1]= data->spos[1]+dy; + + data->marker->flag&= ~MARKER_TRACKED; + } + + WM_event_add_notifier(C, NC_OBJECT|ND_TRANSFORM, NULL); + DAG_id_tag_update(&sc->clip->id, 0); + } else { + if(data->action==SLIDE_ACTION_SIZE) { + data->min[0]= data->smin[0]-dx; + data->max[0]= data->smax[0]+dx; + + data->min[1]= data->smin[1]+dy; + data->max[1]= data->smax[1]-dy; + + if(data->area==TRACK_AREA_SEARCH) BKE_tracking_clamp_track(data->track, CLAMP_SEARCH_DIM); + else BKE_tracking_clamp_track(data->track, CLAMP_PAT_DIM); + } else { + float d[2]={dx, dy}; + + if(data->area==TRACK_AREA_SEARCH) { + add_v2_v2v2(data->min, data->smin, d); + add_v2_v2v2(data->max, data->smax, d); + } else { + int a; + + for(a= 0; a<data->track->markersnr; a++) + add_v2_v2v2(data->track->markers[a].pos, data->smarkers[a], d); + + sub_v2_v2v2(data->offset, data->soff, d); + } + + if(data->area==TRACK_AREA_SEARCH) + BKE_tracking_clamp_track(data->track, CLAMP_SEARCH_POS); + } + } + + WM_event_add_notifier(C, NC_MOVIECLIP|NA_EDITED, NULL); + + break; + + case LEFTMOUSE: + if(event->val==KM_RELEASE) { + free_slide_data(op->customdata); + + show_cursor(C); + + return OPERATOR_FINISHED; + } + + break; + + case ESCKEY: + cancel_mouse_slide(op->customdata); + + free_slide_data(op->customdata); + + show_cursor(C); + + WM_event_add_notifier(C, NC_MOVIECLIP|NA_EDITED, NULL); + + return OPERATOR_CANCELLED; + } + + return OPERATOR_RUNNING_MODAL; +} + +void CLIP_OT_slide_marker(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Slide Marker"; + ot->description= "Slide marker areas"; + ot->idname= "CLIP_OT_slide_marker"; + + /* api callbacks */ + ot->poll= space_clip_frame_poll; + ot->invoke= slide_marker_invoke; + ot->modal= slide_marker_modal; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO|OPTYPE_GRAB_POINTER|OPTYPE_BLOCKING; + + /* properties */ + RNA_def_float_vector(ot->srna, "offset", 2, NULL, -FLT_MAX, FLT_MAX, + "Offset", "Offset in floating point units, 1.0 is the width and height of the image", -FLT_MAX, FLT_MAX); +} + +/********************** mouse select operator *********************/ + +static int mouse_on_side(float co[2], float x1, float y1, float x2, float y2, float epsx, float epsy) +{ + if(x1>x2) SWAP(float, x1, x2); + if(y1>y2) SWAP(float, y1, y2); + + return (co[0]>=x1-epsx && co[0]<=x2+epsx) && (co[1]>=y1-epsy && co[1]<=y2+epsy); +} + +static int mouse_on_rect(float co[2], float pos[2], float min[2], float max[2], float epsx, float epsy) +{ + return mouse_on_side(co, pos[0]+min[0], pos[1]+min[1], pos[0]+max[0], pos[1]+min[1], epsx, epsy) || + mouse_on_side(co, pos[0]+min[0], pos[1]+min[1], pos[0]+min[0], pos[1]+max[1], epsx, epsy) || + mouse_on_side(co, pos[0]+min[0], pos[1]+max[1], pos[0]+max[0], pos[1]+max[1], epsx, epsy) || + mouse_on_side(co, pos[0]+max[0], pos[1]+min[1], pos[0]+max[0], pos[1]+max[1], epsx, epsy); +} + +static int track_mouse_area(SpaceClip *sc, float co[2], MovieTrackingTrack *track) +{ + MovieTrackingMarker *marker= BKE_tracking_get_marker(track, sc->user.framenr); + float epsx, epsy; + int width, height; + + ED_space_clip_size(sc, &width, &height); + + epsx= MIN4(track->pat_min[0]-track->search_min[0], track->search_max[0]-track->pat_max[0], + fabsf(track->pat_min[0]), fabsf(track->pat_max[0])) / 2; + epsy= MIN4(track->pat_min[1]-track->search_min[1], track->search_max[1]-track->pat_max[1], + fabsf(track->pat_min[1]), fabsf(track->pat_max[1])) / 2; + + epsx= MAX2(epsy, 2.0f / width); + epsy= MAX2(epsy, 2.0f / height); + + if(sc->flag&SC_SHOW_MARKER_SEARCH) + if(mouse_on_rect(co, marker->pos, track->search_min, track->search_max, epsx, epsy)) + return TRACK_AREA_SEARCH; + + if((marker->flag&MARKER_DISABLED)==0) { + if(sc->flag&SC_SHOW_MARKER_PATTERN) + if(mouse_on_rect(co, marker->pos, track->pat_min, track->pat_max, epsx, epsy)) + return TRACK_AREA_PAT; + + epsx= 12.0f/width; + epsy= 12.0f/height; + + if(fabsf(co[0]-marker->pos[0]-track->offset[0])< epsx && fabsf(co[1]-marker->pos[1]-track->offset[1])<=epsy) + return TRACK_AREA_POINT; + } + + return TRACK_AREA_NONE; +} + +static float dist_to_rect(float co[2], float pos[2], float min[2], float max[2]) +{ + float d1, d2, d3, d4; + float p[2]= {co[0]-pos[0], co[1]-pos[1]}; + float v1[2]= {min[0], min[1]}, v2[2]= {max[0], min[1]}, + v3[2]= {max[0], max[1]}, v4[2]= {min[0], max[1]}; + + d1= dist_to_line_segment_v2(p, v1, v2); + d2= dist_to_line_segment_v2(p, v2, v3); + d3= dist_to_line_segment_v2(p, v3, v4); + d4= dist_to_line_segment_v2(p, v4, v1); + + return MIN4(d1, d2, d3, d4); +} + +static MovieTrackingTrack *find_nearest_track(SpaceClip *sc, MovieClip *clip, float co[2]) +{ + MovieTrackingTrack *track= NULL, *cur; + float mindist= 0.0f; + + cur= clip->tracking.tracks.first; + while(cur) { + MovieTrackingMarker *marker= BKE_tracking_get_marker(cur, sc->user.framenr); + + if(((cur->flag&TRACK_HIDDEN)==0) && MARKER_VISIBLE(sc, marker)) { + float dist, d1, d2=FLT_MAX, d3=FLT_MAX; + + d1= sqrtf((co[0]-marker->pos[0]-cur->offset[0])*(co[0]-marker->pos[0]-cur->offset[0])+ + (co[1]-marker->pos[1]-cur->offset[1])*(co[1]-marker->pos[1]-cur->offset[1])); /* distance to marker point */ + + /* distance to pattern boundbox */ + if(sc->flag&SC_SHOW_MARKER_PATTERN) + d2= dist_to_rect(co, marker->pos, cur->pat_min, cur->pat_max); + + /* distance to search boundbox */ + if(sc->flag&SC_SHOW_MARKER_SEARCH) + d3= dist_to_rect(co, marker->pos, cur->search_min, cur->search_max); + + /* choose minimal distance. useful for cases of overlapped markers. */ + dist= MIN3(d1, d2, d3); + + if(track==NULL || dist<mindist) { + track= cur; + mindist= dist; + } + } + + cur= cur->next; + } + + return track; +} + +static int mouse_select(bContext *C, float co[2], int extend) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTracking *tracking= &clip->tracking; + MovieTrackingTrack *act_track= tracking->act_track; + MovieTrackingTrack *track= NULL; /* selected marker */ + + track= find_nearest_track(sc, clip, co); + + if(track) { + int area= track_mouse_area(sc, 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_deselect_track(track, area); + else + clip->tracking.act_track= track; + } else { + if(area==TRACK_AREA_POINT) + area= TRACK_AREA_ALL; + + BKE_tracking_select_track(tracking, track, area, extend); + clip->tracking.act_track= track; + } + } + + if(!extend) { + sc->xlockof= 0.0f; + sc->ylockof= 0.0f; + } + + WM_event_add_notifier(C, NC_GEOM|ND_SELECT, NULL); + + return OPERATOR_FINISHED; +} + +static int select_exec(bContext *C, wmOperator *op) +{ + float co[2]; + int extend; + + RNA_float_get_array(op->ptr, "location", co); + extend= RNA_boolean_get(op->ptr, "extend"); + + return mouse_select(C, co, extend); +} + +static int select_invoke(bContext *C, wmOperator *op, wmEvent *event) +{ + float co[2]; + int extend= RNA_boolean_get(op->ptr, "extend"); + + if(!extend) { + SlideMarkerData *slidedata= slide_marker_customdata(C, event); + + if(slidedata) { + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + + clip->tracking.act_track= slidedata->track; + + WM_event_add_notifier(C, NC_GEOM|ND_SELECT, NULL); + + MEM_freeN(slidedata); + + return OPERATOR_PASS_THROUGH; + } + } + + ED_clip_mouse_pos(C, event, co); + RNA_float_set_array(op->ptr, "location", co); + + return select_exec(C, op); +} + +void CLIP_OT_select(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Select"; + ot->description= "Select tracking markers"; + ot->idname= "CLIP_OT_select"; + + /* api callbacks */ + ot->exec= select_exec; + ot->invoke= select_invoke; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_UNDO; + + /* properties */ + RNA_def_boolean(ot->srna, "extend", 0, + "Extend", "Extend selection rather than clearing the existing selection"); + RNA_def_float_vector(ot->srna, "location", 2, NULL, -FLT_MAX, FLT_MAX, + "Location", "Mouse location in normalized coordinates, 0.0 to 1.0 is within the image bounds", -100.0f, 100.0f); +} + +/********************** border select operator *********************/ + +static int border_select_exec(bContext *C, wmOperator *op) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTrackingTrack *track; + rcti rect; + rctf rectf; + int change= 0, mode; + + /* get rectangle from operator */ + rect.xmin= RNA_int_get(op->ptr, "xmin"); + rect.ymin= RNA_int_get(op->ptr, "ymin"); + rect.xmax= RNA_int_get(op->ptr, "xmax"); + rect.ymax= RNA_int_get(op->ptr, "ymax"); + + ED_clip_point_stable_pos(C, rect.xmin, rect.ymin, &rectf.xmin, &rectf.ymin); + ED_clip_point_stable_pos(C, rect.xmax, rect.ymax, &rectf.xmax, &rectf.ymax); + + mode= RNA_int_get(op->ptr, "gesture_mode"); + + /* do actual selection */ + track= clip->tracking.tracks.first; + while(track) { + if((track->flag&TRACK_HIDDEN)==0) { + MovieTrackingMarker *marker= BKE_tracking_get_marker(track, sc->user.framenr); + + if(MARKER_VISIBLE(sc, marker) && BLI_in_rctf(&rectf, marker->pos[0], marker->pos[1])) { + BKE_tracking_track_flag(track, TRACK_AREA_ALL, SELECT, mode!=GESTURE_MODAL_SELECT); + + change= 1; + } + } + + track= track->next; + } + + if(change) { + WM_event_add_notifier(C, NC_GEOM|ND_SELECT, NULL); + + return OPERATOR_FINISHED; + } + + return OPERATOR_CANCELLED; +} + +void CLIP_OT_select_border(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Border Select"; + ot->description= "Select markers using border selection"; + ot->idname= "CLIP_OT_select_border"; + + /* api callbacks */ + ot->invoke= WM_border_select_invoke; + ot->exec= border_select_exec; + ot->modal= WM_border_select_modal; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + /* properties */ + WM_operator_properties_gesture_border(ot, FALSE); +} + +/********************** circle select operator *********************/ + +static int marker_inside_ellipse(MovieTrackingMarker *marker, float offset[2], float ellipse[2]) +{ + /* normalized ellipse: ell[0] = scaleX, ell[1] = scaleY */ + float x, y; + + x= (marker->pos[0] - offset[0])*ellipse[0]; + y= (marker->pos[1] - offset[1])*ellipse[1]; + + return x*x + y*y < 1.0f; +} + +static int circle_select_exec(bContext *C, wmOperator *op) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + ARegion *ar= CTX_wm_region(C); + MovieTrackingTrack *track; + int x, y, radius, width, height, mode, change= 0; + float zoomx, zoomy, offset[2], ellipse[2]; + + /* 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_size(sc, &width, &height); + ED_space_clip_zoom(sc, ar, &zoomx, &zoomy); + + ellipse[0]= width*zoomx/radius; + ellipse[1]= height*zoomy/radius; + + ED_clip_point_stable_pos(C, x, y, &offset[0], &offset[1]); + + /* do selection */ + track= clip->tracking.tracks.first; + while(track) { + if((track->flag&TRACK_HIDDEN)==0) { + MovieTrackingMarker *marker= BKE_tracking_get_marker(track, sc->user.framenr); + + if(MARKER_VISIBLE(sc, marker) && marker_inside_ellipse(marker, offset, ellipse)) { + BKE_tracking_track_flag(track, TRACK_AREA_ALL, SELECT, mode!=GESTURE_MODAL_SELECT); + + change= 1; + } + } + + track= track->next; + } + + if(change) { + WM_event_add_notifier(C, NC_GEOM|ND_SELECT, NULL); + + return OPERATOR_FINISHED; + } + + return OPERATOR_CANCELLED; +} + +void CLIP_OT_select_circle(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Circle Select"; + ot->description= "Select markers using circle selection"; + ot->idname= "CLIP_OT_select_circle"; + + /* api callbacks */ + ot->invoke= WM_gesture_circle_invoke; + ot->modal= WM_gesture_circle_modal; + ot->exec= circle_select_exec; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + /* properties */ + RNA_def_int(ot->srna, "x", 0, INT_MIN, INT_MAX, "X", "", INT_MIN, INT_MAX); + RNA_def_int(ot->srna, "y", 0, INT_MIN, INT_MAX, "Y", "", INT_MIN, INT_MAX); + RNA_def_int(ot->srna, "radius", 0, INT_MIN, INT_MAX, "Radius", "", INT_MIN, INT_MAX); + RNA_def_int(ot->srna, "gesture_mode", 0, INT_MIN, INT_MAX, "Gesture Mode", "", INT_MIN, INT_MAX); +} + +/********************** select all operator *********************/ + +static int select_all_exec(bContext *C, wmOperator *op) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTrackingTrack *track= NULL; /* selected track */ + int action= RNA_enum_get(op->ptr, "action"); + int framenr= sc->user.framenr; + int has_selection= 0; + + if(action == SEL_TOGGLE){ + action= SEL_SELECT; + track= clip->tracking.tracks.first; + while(track) { + if(TRACK_VIEW_SELECTED(sc, track)) { + action= SEL_DESELECT; + break; + } + + track= track->next; + } + } + + track= clip->tracking.tracks.first; + while(track) { + if((track->flag&TRACK_HIDDEN)==0) { + MovieTrackingMarker *marker= BKE_tracking_get_marker(track, framenr); + + if(marker && MARKER_VISIBLE(sc, marker)) { + switch (action) { + case SEL_SELECT: + track->flag|= SELECT; + track->pat_flag|= SELECT; + track->search_flag|= SELECT; + break; + case SEL_DESELECT: + track->flag&= ~SELECT; + track->pat_flag&= ~SELECT; + track->search_flag&= ~SELECT; + break; + case SEL_INVERT: + track->flag^= SELECT; + track->pat_flag^= SELECT; + track->search_flag^= SELECT; + break; + } + } + } + + if(TRACK_VIEW_SELECTED(sc, track)) + has_selection= 1; + + track= track->next; + } + + if(!has_selection) + sc->flag&= ~SC_LOCK_SELECTION; + + WM_event_add_notifier(C, NC_GEOM|ND_SELECT, NULL); + + return OPERATOR_FINISHED; +} + +void CLIP_OT_select_all(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Select or Deselect All"; + ot->description= "Change selection of all tracking markers"; + ot->idname= "CLIP_OT_select_all"; + + /* api callbacks */ + ot->exec= select_all_exec; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + WM_operator_properties_select_all(ot); +} + +/********************** select grouped operator *********************/ + +static int select_groped_exec(bContext *C, wmOperator *op) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTrackingTrack *track; + MovieTrackingMarker *marker; + int group= RNA_enum_get(op->ptr, "group"); + + track= clip->tracking.tracks.first; + while(track) { + int ok= 0; + + marker= BKE_tracking_get_marker(track, sc->user.framenr); + + if(group==0) { /* Keyframed */ + ok= marker->framenr==sc->user.framenr && (marker->flag&MARKER_TRACKED)==0; + } + else if(group==1) { /* Estimated */ + ok= marker->framenr!=sc->user.framenr; + } + else if(group==2) { /* tracked */ + ok= marker->framenr==sc->user.framenr && (marker->flag&MARKER_TRACKED); + } + else if(group==3) { /* locked */ + ok= track->flag&TRACK_LOCKED; + } + else if(group==4) { /* disabled */ + ok= marker->flag&MARKER_DISABLED; + } + else if(group==5) { /* color */ + if(clip->tracking.act_track) { + ok= (track->flag&TRACK_CUSTOMCOLOR) == (clip->tracking.act_track->flag&TRACK_CUSTOMCOLOR); + + if(ok && track->flag&TRACK_CUSTOMCOLOR) + ok= equals_v3v3(track->color, clip->tracking.act_track->color); + } + } + else if(group==6) { /* failed */ + ok= (track->flag&TRACK_HAS_BUNDLE) == 0; + } + + if(ok) { + track->flag|= SELECT; + if(sc->flag&SC_SHOW_MARKER_PATTERN) track->pat_flag|= SELECT;; + if(sc->flag&SC_SHOW_MARKER_SEARCH) track->search_flag|= SELECT;; + } + + track= track->next; + } + + WM_event_add_notifier(C, NC_MOVIECLIP|ND_DISPLAY, clip); + + return OPERATOR_FINISHED; +} + +void CLIP_OT_select_grouped(wmOperatorType *ot) +{ + static EnumPropertyItem select_group_items[] = { + {0, "KEYFRAMED", 0, "Keyframed tracks", "Select all keyframed tracks"}, + {1, "ESTIMATED", 0, "Estimated tracks", "Select all estimated tracks"}, + {2, "TRACKED", 0, "Tracked tracks", "Select all tracked tracks"}, + {3, "LOCKED", 0, "Locked tracks", "Select all locked tracks"}, + {4, "DISABLED", 0, "Disabled tracks", "Select all disabled tracks"}, + {5, "COLOR", 0, "Tracks with same color", "Select all tracks with same color as actiev track"}, + {6, "FAILED", 0, "Failed Tracks", "Select all tracks which failed to be reconstructed"}, + {0, NULL, 0, NULL, NULL} + }; + + /* identifiers */ + ot->name= "Select Grouped"; + ot->description= "Joint Selected Tracks"; + ot->idname= "CLIP_OT_select_grouped"; + + /* api callbacks */ + ot->exec= select_groped_exec; + ot->poll= space_clip_frame_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + /* proeprties */ + RNA_def_enum(ot->srna, "group", select_group_items, TRACK_CLEAR_REMAINED, "Action", "Clear action to execute"); +} + +/********************** track operator *********************/ + +typedef struct TrackMarkersJob { + struct MovieTrackingContext *context; /* tracking context */ + int sfra, efra, lastfra; /* Start, end and recently tracked frames */ + int backwards; /* Backwards tracking flag */ + MovieClip *clip; /* Clip which is tracking */ + float delay; /* Delay in milliseconds to allow tracking at fixed FPS */ + + struct Main *main; + struct Scene *scene; + struct bScreen *screen; +} TrackMarkersJob; + +static int track_markers_testbreak(void) +{ + return G.afbreek; +} + +static int track_count_markers(SpaceClip *sc, MovieClip *clip) +{ + int tot= 0; + MovieTrackingTrack *track; + + track= clip->tracking.tracks.first; + while(track) { + if(TRACK_VIEW_SELECTED(sc, track) && (track->flag&TRACK_LOCKED)==0) + tot++; + + track= track->next; + } + + return tot; +} + +static void track_init_markers(SpaceClip *sc, MovieClip *clip) +{ + MovieTrackingTrack *track; + int framenr= sc->user.framenr, hidden= 0; + + if((sc->flag&SC_SHOW_MARKER_PATTERN)==0) hidden|= TRACK_AREA_PAT; + if((sc->flag&SC_SHOW_MARKER_SEARCH)==0) hidden|= TRACK_AREA_SEARCH; + + track= clip->tracking.tracks.first; + while(track) { + if(hidden) + BKE_tracking_track_flag(track, hidden, SELECT, 1); + + if(TRACK_SELECTED(track)) { + if((track->flag&TRACK_HIDDEN)==0 && (track->flag&TRACK_LOCKED)==0) + BKE_tracking_ensure_marker(track, framenr); + } + + track= track->next; + } +} + +static int track_markers_check_direction(int backwards, int curfra, int efra) +{ + if(backwards) { + if(curfra<efra) return 0; + } + else { + if(curfra>efra) return 0; + } + + return 1; +} + +static int track_markers_initjob(bContext *C, TrackMarkersJob *tmj, int backwards) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + Scene *scene= CTX_data_scene(C); + MovieTrackingSettings *settings= &clip->tracking.settings; + + tmj->sfra= sc->user.framenr; + tmj->clip= clip; + tmj->backwards= backwards; + + if(backwards) tmj->efra= SFRA; + else tmj->efra= EFRA; + + /* limit frames to be tracked by user setting */ + if(settings->frames_limit) { + if(backwards) tmj->efra= MAX2(tmj->efra, tmj->sfra-settings->frames_limit); + else tmj->efra= MIN2(tmj->efra, tmj->sfra+settings->frames_limit); + } + + if(settings->speed!=TRACKING_SPEED_FASTEST) { + tmj->delay= 1.0f/scene->r.frs_sec*1000.0f; + + if(settings->speed==TRACKING_SPEED_HALF) tmj->delay*= 2; + else if(settings->speed==TRACKING_SPEED_QUARTER) tmj->delay*= 4; + else if(settings->speed==TRACKING_SPEED_DOUBLE) tmj->delay/= 2; + } + + track_init_markers(sc, clip); + + tmj->context= BKE_tracking_context_new(clip, &sc->user, backwards, 1); + + clip->tracking_context= tmj->context; + + tmj->lastfra= tmj->sfra; + + /* XXX: silly to store this, but this data is needed to update scene and movieclip + frame numbers when tracking is finished. This introduces better feedback for artists. + Maybe there's another way to solve this problem, but can't think better way atm. + Anyway, this way isn't more unstable as animation rendering animation + which uses the same approach (except storing screen). */ + tmj->scene= scene; + tmj->main= CTX_data_main(C); + tmj->screen= CTX_wm_screen(C); + + return track_markers_check_direction(backwards, tmj->sfra, tmj->efra); +} + +static void track_markers_startjob(void *tmv, short *stop, short *do_update, float *progress) +{ + TrackMarkersJob *tmj= (TrackMarkersJob *)tmv; + int framenr= tmj->sfra; + //double t= PIL_check_seconds_timer(); + + while(framenr != tmj->efra) { + if(tmj->delay>0) { + /* tracking should happen with fixed fps. Calculate time + using current timer value before tracking frame and after. + + Small (and maybe unneeded optimization): do not calculate exec_time + for "Fastest" tracking */ + + double start_time= PIL_check_seconds_timer(), exec_time; + + if(!BKE_tracking_next(tmj->context)) + break; + + exec_time= PIL_check_seconds_timer()-start_time; + if(tmj->delay>exec_time) + PIL_sleep_ms(tmj->delay-exec_time); + } else if(!BKE_tracking_next(tmj->context)) + break; + + *do_update= 1; + *progress=(float)(framenr-tmj->sfra) / (tmj->efra-tmj->sfra); + + if(tmj->backwards) framenr--; + else framenr++; + + tmj->lastfra= framenr; + + if(*stop || track_markers_testbreak()) + break; + } + + //printf("Tracking time: %lf\n", PIL_check_seconds_timer()-t); +} + +static void track_markers_updatejob(void *tmv) +{ + TrackMarkersJob *tmj= (TrackMarkersJob *)tmv; + + BKE_tracking_sync(tmj->context); +} + +static void track_markers_freejob(void *tmv) +{ + TrackMarkersJob *tmj= (TrackMarkersJob *)tmv; + + tmj->clip->tracking_context= NULL; + tmj->scene->r.cfra= tmj->lastfra; + ED_update_for_newframe(tmj->main, tmj->scene, tmj->screen, 0); + + BKE_tracking_sync(tmj->context); + BKE_tracking_context_free(tmj->context); + + MEM_freeN(tmj); + + WM_main_add_notifier(NC_SCENE|ND_FRAME, tmj->scene); +} + +static int track_markers_exec(bContext *C, wmOperator *op) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + Scene *scene= CTX_data_scene(C); + struct MovieTrackingContext *context; + int framenr= sc->user.framenr; + int sfra= framenr, efra; + int backwards= RNA_boolean_get(op->ptr, "backwards"); + int sequence= RNA_boolean_get(op->ptr, "sequence"); + MovieTrackingSettings *settings= &clip->tracking.settings; + + if(track_count_markers(sc, clip)==0) + return OPERATOR_CANCELLED; + + if(backwards) efra= SFRA; + else efra= EFRA; + + /* limit frames to be tracked by user setting */ + if(settings->frames_limit) { + if(backwards) efra= MAX2(efra, sfra-settings->frames_limit); + else efra= MIN2(efra, sfra+settings->frames_limit); + } + + if(!track_markers_check_direction(backwards, framenr, efra)) + return OPERATOR_CANCELLED; + + track_init_markers(sc, clip); + + /* do not disable tracks due to threshold when tracking frame-by-frame */ + context= BKE_tracking_context_new(clip, &sc->user, backwards, sequence); + + while(framenr != efra) { + if(!BKE_tracking_next(context)) + break; + + if(backwards) framenr--; + else framenr++; + + if(!sequence) + break; + } + + BKE_tracking_sync(context); + BKE_tracking_context_free(context); + + /* update scene current frame to the lastes tracked frame */ + scene->r.cfra= framenr; + + WM_event_add_notifier(C, NC_MOVIECLIP|NA_EVALUATED, clip); + WM_event_add_notifier(C, NC_SCENE|ND_FRAME, scene); + + return OPERATOR_FINISHED; +} + +static int track_markers_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event)) +{ + TrackMarkersJob *tmj; + ScrArea *sa= CTX_wm_area(C); + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + wmJob *steve; + int backwards= RNA_boolean_get(op->ptr, "backwards"); + int sequence= RNA_boolean_get(op->ptr, "sequence"); + + if(clip->tracking_context) + return OPERATOR_CANCELLED; + + if(track_count_markers(sc, clip)==0) + return OPERATOR_CANCELLED; + + if(!sequence) + return track_markers_exec(C, op); + + tmj= MEM_callocN(sizeof(TrackMarkersJob), "TrackMarkersJob data"); + if(!track_markers_initjob(C, tmj, backwards)) { + track_markers_freejob(tmj); + + return OPERATOR_CANCELLED; + } + + /* setup job */ + steve= WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), sa, "Track Markers", WM_JOB_PROGRESS); + WM_jobs_customdata(steve, tmj, track_markers_freejob); + + /* if there's delay set in tracking job, tracking should happen + with fixed FPS. To deal with editor refresh we have to syncronize + tracks from job and tracks in clip. Do this in timer callback + to prevent threading conflicts. */ + if(tmj->delay>0) WM_jobs_timer(steve, tmj->delay/1000.0f, NC_MOVIECLIP|NA_EVALUATED, 0); + else WM_jobs_timer(steve, 0.2, NC_MOVIECLIP|NA_EVALUATED, 0); + + WM_jobs_callbacks(steve, track_markers_startjob, NULL, track_markers_updatejob, NULL); + + G.afbreek= 0; + + WM_jobs_start(CTX_wm_manager(C), steve); + WM_cursor_wait(0); + + /* add modal handler for ESC */ + WM_event_add_modal_handler(C, op); + + return OPERATOR_RUNNING_MODAL; +} + +static int track_markers_modal(bContext *C, wmOperator *UNUSED(op), wmEvent *event) +{ + /* no running blender, remove handler and pass through */ + if(0==WM_jobs_test(CTX_wm_manager(C), CTX_wm_area(C))) + return OPERATOR_FINISHED|OPERATOR_PASS_THROUGH; + + /* running tracking */ + switch (event->type) { + case ESCKEY: + return OPERATOR_RUNNING_MODAL; + break; + } + + return OPERATOR_PASS_THROUGH; +} + +void CLIP_OT_track_markers(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Track Markers"; + ot->description= "Track selected markers"; + ot->idname= "CLIP_OT_track_markers"; + + /* api callbacks */ + ot->exec= track_markers_exec; + ot->invoke= track_markers_invoke; + ot->poll= space_clip_frame_poll; + ot->modal= track_markers_modal; + + /* flags */ + ot->flag= OPTYPE_UNDO; + + /* properties */ + RNA_def_boolean(ot->srna, "backwards", 0, "Backwards", "Do backwards tracking"); + RNA_def_boolean(ot->srna, "sequence", 0, "Track Sequence", "Track marker during image sequence rather than single image"); +} + +/********************** solve camera operator *********************/ + +static int check_solve_track_count(MovieTracking *tracking) +{ + int tot= 0; + int frame1= tracking->settings.keyframe1, frame2= tracking->settings.keyframe2; + MovieTrackingTrack *track; + + track= tracking->tracks.first; + while(track) { + if(BKE_tracking_has_marker(track, frame1)) + if(BKE_tracking_has_marker(track, frame2)) + tot++; + + track= track->next; + } + + return tot>=8; +} + +static int solve_camera_exec(bContext *C, wmOperator *op) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + Scene *scene= CTX_data_scene(C); + MovieTracking *tracking= &clip->tracking; + int width, height; + float error; + + if(!check_solve_track_count(tracking)) { + BKE_report(op->reports, RPT_ERROR, "At least 8 tracks on both of keyframes are needed for reconstruction"); + return OPERATOR_CANCELLED; + } + + /* could fail if footage uses images with different sizes */ + BKE_movieclip_get_size(clip, NULL, &width, &height); + + error= BKE_tracking_solve_reconstruction(tracking, width, height); + + if(error<0) + BKE_report(op->reports, RPT_WARNING, "Some data failed to reconstruct, see console for details"); + else + BKE_reportf(op->reports, RPT_INFO, "Average reprojection error %.3f", error); + + scene->clip= clip; + id_us_plus(&clip->id); + + if(!scene->camera) + scene->camera= scene_find_camera(scene); + + if(scene->camera) { + /* set blender camera focal length so result would look fine there */ + Camera *camera= (Camera*)scene->camera->data; + + BKE_tracking_camera_to_blender(tracking, scene, camera, width, height); + + WM_event_add_notifier(C, NC_OBJECT, camera); + } + + DAG_id_tag_update(&clip->id, 0); + + WM_event_add_notifier(C, NC_MOVIECLIP|NA_EVALUATED, clip); + WM_event_add_notifier(C, NC_OBJECT|ND_TRANSFORM, NULL); + + /* update active clip displayed in scene buttons */ + WM_event_add_notifier(C, NC_SCENE, scene); + + return OPERATOR_FINISHED; +} + +void CLIP_OT_solve_camera(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Solve Camera"; + ot->description= "Solve camera motion from tracks"; + ot->idname= "CLIP_OT_solve_camera"; + + /* api callbacks */ + ot->exec= solve_camera_exec; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; +} + +/********************** clear solution operator *********************/ + +static int clear_solution_exec(bContext *C, wmOperator *UNUSED(op)) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTracking *tracking= &clip->tracking; + MovieTrackingTrack *track= tracking->tracks.first; + + while(track) { + track->flag&= ~TRACK_HAS_BUNDLE; + + track= track->next; + } + + if(tracking->reconstruction.cameras) + MEM_freeN(tracking->reconstruction.cameras); + + tracking->reconstruction.cameras= NULL; + tracking->reconstruction.camnr= 0; + + tracking->reconstruction.flag&= ~TRACKING_RECONSTRUCTED; + + DAG_id_tag_update(&clip->id, 0); + + WM_event_add_notifier(C, NC_MOVIECLIP|NA_EVALUATED, clip); + WM_event_add_notifier(C, NC_SPACE|ND_SPACE_VIEW3D, NULL); + + return OPERATOR_FINISHED; +} + +void CLIP_OT_clear_solution(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Clear Solution"; + ot->description= "Clear all calculated data"; + ot->idname= "CLIP_OT_clear_solution"; + + /* api callbacks */ + ot->exec= clear_solution_exec; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; +} + +/********************** clear track operator *********************/ + +static int clear_track_path_exec(bContext *C, wmOperator *op) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTrackingTrack *track; + int action= RNA_enum_get(op->ptr, "action"); + + track= clip->tracking.tracks.first; + while(track) { + if(TRACK_VIEW_SELECTED(sc, track)) + BKE_tracking_clear_path(track, sc->user.framenr, action); + + track= track->next; + } + + WM_event_add_notifier(C, NC_MOVIECLIP|NA_EVALUATED, clip); + + return OPERATOR_FINISHED; +} + +void CLIP_OT_clear_track_path(wmOperatorType *ot) +{ + static EnumPropertyItem clear_path_actions[] = { + {TRACK_CLEAR_UPTO, "UPTO", 0, "Clear up-to", "Clear path up to current frame"}, + {TRACK_CLEAR_REMAINED, "REMAINED", 0, "Clear remained", "Clear path at remained frames (after current)"}, + {TRACK_CLEAR_ALL, "ALL", 0, "Clear all", "Clear the whole path"}, + {0, NULL, 0, NULL, NULL} + }; + + /* identifiers */ + ot->name= "Clear Track Path"; + ot->description= "Clear path of selected tracks"; + ot->idname= "CLIP_OT_clear_track_path"; + + /* api callbacks */ + ot->exec= clear_track_path_exec; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + /* proeprties */ + RNA_def_enum(ot->srna, "action", clear_path_actions, TRACK_CLEAR_REMAINED, "Action", "Clear action to execute"); +} + +/********************** disable markers operator *********************/ + +static int disable_markers_exec(bContext *C, wmOperator *op) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTracking *tracking= &clip->tracking; + MovieTrackingTrack *track= tracking->tracks.first; + int action= RNA_enum_get(op->ptr, "action"); + + while(track) { + if(TRACK_VIEW_SELECTED(sc, track) && (track->flag&TRACK_LOCKED)==0) { + MovieTrackingMarker *marker= BKE_tracking_ensure_marker(track, sc->user.framenr); + + if(action==0) marker->flag|= MARKER_DISABLED; + else if(action==1) marker->flag&= ~MARKER_DISABLED; + else marker->flag^= MARKER_DISABLED; + } + + track= track->next; + } + + DAG_id_tag_update(&clip->id, 0); + + WM_event_add_notifier(C, NC_MOVIECLIP|NA_EVALUATED, clip); + + return OPERATOR_FINISHED; +} + +void CLIP_OT_disable_markers(wmOperatorType *ot) +{ + static EnumPropertyItem actions_items[] = { + {0, "DISABLE", 0, "Disable", "Disable selected markers"}, + {1, "ENABLE", 0, "Enable", "Enable selected markers"}, + {2, "TOGGLE", 0, "Toggle", "Toggle disabled flag for selected markers"}, + {0, NULL, 0, NULL, NULL} + }; + + /* identifiers */ + ot->name= "Disable Markers"; + ot->description= "Disable/enable selected markers"; + ot->idname= "CLIP_OT_disable_markers"; + + /* api callbacks */ + ot->exec= disable_markers_exec; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + /* properties */ + RNA_def_enum(ot->srna, "action", actions_items, 0, "Action", "Disable action to execute"); +} + +/********************** set origin operator *********************/ + +static int count_selected_bundles(bContext *C) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTrackingTrack *track; + int tot= 0; + + track= clip->tracking.tracks.first; + while(track) { + if(TRACK_VIEW_SELECTED(sc, track) && (track->flag&TRACK_HAS_BUNDLE)) + tot++; + + track= track->next; + } + + return tot; +} + +static int set_origin_exec(bContext *C, wmOperator *op) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTrackingTrack *track; + Scene *scene= CTX_data_scene(C); + Object *parent= scene->camera; + float mat[4][4], vec[3]; + + if(count_selected_bundles(C)!=1) { + BKE_report(op->reports, RPT_ERROR, "Track with bundle should be selected to define origin position"); + return OPERATOR_CANCELLED; + } + + if(scene->camera->parent) + parent= scene->camera->parent; + + track= clip->tracking.tracks.first; + while(track) { + if(TRACK_VIEW_SELECTED(sc, track)) + break; + + track= track->next; + } + + BKE_get_tracking_mat(scene, NULL, mat); + mul_v3_m4v3(vec, mat, track->bundle_pos); + + sub_v3_v3(parent->loc, vec); + + DAG_id_tag_update(&clip->id, 0); + DAG_id_tag_update(&parent->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; +} + +void CLIP_OT_set_origin(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Set Origin"; + ot->description= "Set active marker as origin by moving camera (or it's parent if present) in 3d space"; + ot->idname= "CLIP_OT_set_origin"; + + /* api callbacks */ + ot->exec= set_origin_exec; + ot->poll= space_clip_frame_camera_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; +} + +/********************** set floor operator *********************/ + +static void set_axis(Scene *scene, Object *ob, MovieTrackingTrack *track, char axis) +{ + float mat[4][4], vec[3], obmat[4][4]; + + BKE_get_tracking_mat(scene, NULL, mat); + mul_v3_m4v3(vec, mat, track->bundle_pos); + + if(len_v2(vec)<1e-3) + return; + + unit_m4(mat); + + if(axis=='X') { + if(fabsf(vec[1])<1e-3) { + mat[0][0]= -1.0f; mat[0][1]= 0.0f; mat[0][2]= 0.0f; + mat[1][0]= 0.0f; mat[1][1]= -1.0f; mat[1][2]= 0.0f; + mat[2][0]= 0.0f; mat[2][1]= 0.0f; mat[2][2]= 1.0f; + } else { + copy_v3_v3(mat[0], vec); + mat[0][2]= 0.0f; + mat[2][0]= 0.0f; mat[2][1]= 0.0f; mat[2][2]= 1.0f; + cross_v3_v3v3(mat[1], mat[2], mat[0]); + } + } else { + if(fabsf(vec[0])<1e-3) { + mat[0][0]= -1.0f; mat[0][1]= 0.0f; mat[0][2]= 0.0f; + mat[1][0]= 0.0f; mat[1][1]= -1.0f; mat[1][2]= 0.0f; + mat[2][0]= 0.0f; mat[2][1]= 0.0f; mat[2][2]= 1.0f; + } else { + copy_v3_v3(mat[1], vec); + mat[1][2]= 0.0f; + mat[2][0]= 0.0f; mat[2][1]= 0.0f; mat[2][2]= 1.0f; + cross_v3_v3v3(mat[0], mat[1], mat[2]); + } + } + + normalize_v3(mat[0]); + normalize_v3(mat[1]); + normalize_v3(mat[2]); + + invert_m4(mat); + + object_to_mat4(ob, obmat); + mul_m4_m4m4(mat, obmat, mat); + object_apply_mat4(ob, mat, 0, 0); +} + +static int set_floor_exec(bContext *C, wmOperator *op) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + Scene *scene= CTX_data_scene(C); + MovieTrackingTrack *track, *axis_track= NULL; + Object *camera= scene->camera; + Object *parent= camera; + int tot= 0; + float vec[3][3], mat[4][4], obmat[4][4], newmat[4][4], orig[3]= {0.0f, 0.0f, 0.0f}; + float rot[4][4]={{0.0f, 0.0f, -1.0f, 0.0f}, + {0.0f, 1.0f, 0.0f, 0.0f}, + {1.0f, 0.0f, 0.0f, 0.0f}, + {0.0f, 0.0f, 0.0f, 1.0f}}; /* 90 degrees Y-axis rotation matrix */ + + if(count_selected_bundles(C)!=3) { + BKE_report(op->reports, RPT_ERROR, "Three tracks with bundles are needed to orient the floor"); + return OPERATOR_CANCELLED; + } + + if(scene->camera->parent) + parent= scene->camera->parent; + + BKE_get_tracking_mat(scene, NULL, mat); + + /* get 3 bundles to use as reference */ + track= clip->tracking.tracks.first; + while(track && tot<3) { + if(track->flag&TRACK_HAS_BUNDLE && TRACK_VIEW_SELECTED(sc, track)) { + mul_v3_m4v3(vec[tot], mat, track->bundle_pos); + + if(tot==0 || track==clip->tracking.act_track) + copy_v3_v3(orig, vec[tot]); + else + axis_track= track; + + tot++; + } + + track= track->next; + } + + sub_v3_v3(vec[1], vec[0]); + sub_v3_v3(vec[2], vec[0]); + + /* construct ortho-normal basis */ + unit_m4(mat); + + cross_v3_v3v3(mat[0], vec[1], vec[2]); + copy_v3_v3(mat[1], vec[1]); + cross_v3_v3v3(mat[2], mat[0], mat[1]); + + normalize_v3(mat[0]); + normalize_v3(mat[1]); + normalize_v3(mat[2]); + + /* move to origin point */ + mat[3][0]= orig[0]; + mat[3][1]= orig[1]; + mat[3][2]= orig[2]; + + invert_m4(mat); + + object_to_mat4(parent, obmat); + mul_m4_m4m4(mat, obmat, mat); + mul_m4_m4m4(newmat, mat, rot); + object_apply_mat4(parent, newmat, 0, 0); + + /* make camera have positive z-coordinate */ + mul_v3_m4v3(vec[0], mat, camera->loc); + if(camera->loc[2]<0) { + invert_m4(rot); + mul_m4_m4m4(newmat, mat, rot); + object_apply_mat4(camera, newmat, 0, 0); + } + + where_is_object(scene, parent); + set_axis(scene, parent, axis_track, 'X'); + + DAG_id_tag_update(&clip->id, 0); + DAG_id_tag_update(&parent->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; +} + +void CLIP_OT_set_floor(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Set Floor"; + ot->description= "Set floor based on 3 selected bundles by moving camera (or it's parent if present) in 3d space"; + ot->idname= "CLIP_OT_set_floor"; + + /* api callbacks */ + ot->exec= set_floor_exec; + ot->poll= space_clip_camera_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; +} + +/********************** set axis operator *********************/ + +static int set_axis_exec(bContext *C, wmOperator *op) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTrackingTrack *track; + Scene *scene= CTX_data_scene(C); + Object *parent= scene->camera; + 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; + } + + if(scene->camera->parent) + parent= scene->camera->parent; + + track= clip->tracking.tracks.first; + while(track) { + if(TRACK_VIEW_SELECTED(sc, track)) + break; + + track= track->next; + } + + set_axis(scene, parent, track, axis==0?'X':'Y'); + + DAG_id_tag_update(&clip->id, 0); + DAG_id_tag_update(&parent->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; +} + +void CLIP_OT_set_axis(wmOperatorType *ot) +{ + static EnumPropertyItem axis_actions[] = { + {0, "X", 0, "X", "Align bundle align X axis"}, + {1, "Y", 0, "Y", "Align bundle align Y axis"}, + {0, NULL, 0, NULL, NULL} + }; + + /* identifiers */ + ot->name= "Set Axis"; + ot->description= "Set direction of scene axis rotating camera (or it's parent if present) and assuming selected track lies on real axis joining it with the origin"; + ot->idname= "CLIP_OT_set_axis"; + + /* api callbacks */ + ot->exec= set_axis_exec; + ot->poll= space_clip_frame_camera_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + /* properties */ + RNA_def_enum(ot->srna, "axis", axis_actions, 0, "Axis", "Axis to use to align bundle along"); +} + +/********************** set scale operator *********************/ + +static int set_scale_exec(bContext *C, wmOperator *op) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTrackingTrack *track; + Scene *scene= CTX_data_scene(C); + Object *parent= scene->camera; + int tot= 0; + float vec[2][3], mat[4][4], scale; + float dist= RNA_float_get(op->ptr, "distance"); + + if(count_selected_bundles(C)!=2) { + BKE_report(op->reports, RPT_ERROR, "Two tracks with bundles should be selected to scale scene"); + + return OPERATOR_CANCELLED; + } + + if(scene->camera->parent) + parent= scene->camera->parent; + + BKE_get_tracking_mat(scene, NULL, mat); + + track= clip->tracking.tracks.first; + while(track) { + if(TRACK_VIEW_SELECTED(sc, track)) { + mul_v3_m4v3(vec[tot], mat, track->bundle_pos); + tot++; + } + + track= track->next; + } + + sub_v3_v3(vec[0], vec[1]); + + if(len_v3(vec[0])>1e-5) { + scale= dist / len_v3(vec[0]); + + mul_v3_fl(parent->size, scale); + mul_v3_fl(parent->loc, scale); + + DAG_id_tag_update(&clip->id, 0); + DAG_id_tag_update(&parent->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 int set_scale_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event)) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + float dist= RNA_float_get(op->ptr, "distance"); + + if(dist==0.0f) + RNA_float_set(op->ptr, "distance", clip->tracking.settings.dist); + + return set_scale_exec(C, op); +} + +void CLIP_OT_set_scale(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Set Scale"; + ot->description= "Set scale of scene by scaling camera (or it's parent if present)"; + ot->idname= "CLIP_OT_set_scale"; + + /* api callbacks */ + ot->exec= set_scale_exec; + ot->invoke= set_scale_invoke; + ot->poll= space_clip_frame_camera_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + /* properties */ + RNA_def_float(ot->srna, "distance", 0.0f, -FLT_MAX, FLT_MAX, + "Distance", "Distance between selected tracks", -100.0f, 100.0f); +} + +/********************** set principal center operator *********************/ + +static int set_center_principal_exec(bContext *C, wmOperator *UNUSED(op)) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + int width, height; + + BKE_movieclip_get_size(clip, &sc->user, &width, &height); + + if(width==0 || height==0) + return OPERATOR_CANCELLED; + + clip->tracking.camera.principal[0]= ((float)width)/2.0f; + clip->tracking.camera.principal[1]= ((float)height)/2.0f; + + WM_event_add_notifier(C, NC_MOVIECLIP|NA_EDITED, clip); + + return OPERATOR_FINISHED; +} + +void CLIP_OT_set_center_principal(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Set Principal to Center"; + ot->description= "Set principal point to center of footage"; + ot->idname= "CLIP_OT_set_center_principal"; + + /* api callbacks */ + ot->exec= set_center_principal_exec; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; +} + +/********************** hide tracks operator *********************/ + +static int hide_tracks_exec(bContext *C, wmOperator *op) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTrackingTrack *track; + int unselected; + + unselected= RNA_boolean_get(op->ptr, "unselected"); + + track= clip->tracking.tracks.first; + while(track) { + if(unselected==0 && TRACK_VIEW_SELECTED(sc, track)) { + track->flag|= TRACK_HIDDEN; + } else if(unselected==1 && !TRACK_VIEW_SELECTED(sc, track)) { + track->flag|= TRACK_HIDDEN; + } + + track= track->next; + } + + if(clip->tracking.act_track && clip->tracking.act_track->flag&TRACK_HIDDEN) + clip->tracking.act_track= NULL; + + if(unselected==0) { + /* no selection on screen now, unlock view so it can be scrolled nice again */ + sc->flag&= ~SC_LOCK_SELECTION; + } + + WM_event_add_notifier(C, NC_MOVIECLIP|ND_DISPLAY, NULL); + + return OPERATOR_FINISHED; +} + +void CLIP_OT_hide_tracks(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Hide Tracks"; + ot->description= "Hide selected tracks"; + ot->idname= "CLIP_OT_hide_tracks"; + + /* api callbacks */ + ot->exec= hide_tracks_exec; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + /* properties */ + RNA_def_boolean(ot->srna, "unselected", 0, "Unselected", "Hide unselected tracks"); +} + +/********************** hide tracks clear operator *********************/ + +static int hide_tracks_clear_exec(bContext *C, wmOperator *UNUSED(op)) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTrackingTrack *track; + + track= clip->tracking.tracks.first; + while(track) { + track->flag&= ~TRACK_HIDDEN; + + track= track->next; + } + + WM_event_add_notifier(C, NC_MOVIECLIP|ND_DISPLAY, NULL); + + return OPERATOR_FINISHED; +} + +void CLIP_OT_hide_tracks_clear(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Hide Tracks Clear"; + ot->description= "Clear hide selected tracks"; + ot->idname= "CLIP_OT_hide_tracks_clear"; + + /* api callbacks */ + ot->exec= hide_tracks_clear_exec; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; +} + +/********************** detect features operator *********************/ + +static bGPDlayer *detect_get_layer(MovieClip *clip) +{ + bGPDlayer *layer; + + if(!clip->gpd) + return NULL; + + layer= clip->gpd->layers.first; + while(layer) { + if(layer->flag&GP_LAYER_ACTIVE) + return layer; + + layer= layer->next; + } + + return NULL; +} + +static int detect_features_exec(bContext *C, wmOperator *op) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + ImBuf *ibuf= BKE_movieclip_get_ibuf_flag(clip, &sc->user, 0); + MovieTrackingTrack *track= clip->tracking.tracks.first; + int placement= RNA_enum_get(op->ptr, "placement"); + int margin= RNA_int_get(op->ptr, "margin"); + int min_trackness= RNA_int_get(op->ptr, "min_trackness"); + int min_distance= RNA_int_get(op->ptr, "min_distance"); + int place_outside_layer= 0; + bGPDlayer *layer= NULL; + + if(placement!=0) { + layer= detect_get_layer(clip); + place_outside_layer= placement==2; + } + + /* deselect existing tracks */ + while(track) { + track->flag&= ~SELECT; + track->pat_flag&= ~SELECT; + track->search_flag&= ~SELECT; + + track= track->next; + } + + BKE_tracking_detect_fast(&clip->tracking, ibuf, sc->user.framenr, margin, min_trackness, min_distance, layer, place_outside_layer); + + IMB_freeImBuf(ibuf); + + WM_event_add_notifier(C, NC_MOVIECLIP|NA_EDITED, NULL); + + return OPERATOR_FINISHED; +} + +void CLIP_OT_detect_features(wmOperatorType *ot) +{ + static EnumPropertyItem placement_items[] = { + {0, "FRAME", 0, "Whole Frame", "Place markers across the whole frame"}, + {1, "INSIDE_GPENCIL", 0, "Inside grease pencil", "Place markers only inside areas oulined with grease pencil"}, + {2, "OUTSIDE_GPENCIL", 0, "Outside grease pencil", "Place markers only outside areas oulined with grease pencil"}, + {0, NULL, 0, NULL, NULL} + }; + + /* identifiers */ + ot->name= "Detect Features"; + ot->description= "Automatically detect features to track"; + ot->idname= "CLIP_OT_detect_features"; + + /* api callbacks */ + ot->exec= detect_features_exec; + ot->poll= space_clip_frame_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + /* properties */ + RNA_def_enum(ot->srna, "placement", placement_items, 0, "Placement", "Placement for detected features"); + RNA_def_int(ot->srna, "margin", 16, 0, INT_MAX, "Margin", "Only corners further than margin pixels from the image edges are considered", 0, 300); + RNA_def_int(ot->srna, "min_trackness", 16, 0, INT_MAX, "Trackness", "Minimum score to add a corner", 0, 300); + RNA_def_int(ot->srna, "min_distance", 120, 0, INT_MAX, "Distance", "Minimal distance accepted between two corners", 0, 300); +} + +/********************** frame jump operator *********************/ + +static int frame_jump_exec(bContext *C, wmOperator *op) +{ + Scene *scene= CTX_data_scene(C); + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTrackingTrack *track; + int pos= RNA_enum_get(op->ptr, "position"); + int delta; + + if(pos<=1) { /* jump to path */ + track= clip->tracking.act_track; + + if(!track) + return OPERATOR_CANCELLED; + + delta= pos == 1 ? 1 : -1; + + while(sc->user.framenr+delta >= SFRA && sc->user.framenr+delta <= EFRA) { + MovieTrackingMarker *marker= BKE_tracking_exact_marker(track, sc->user.framenr+delta); + + if(!marker || marker->flag&MARKER_DISABLED) + break; + + sc->user.framenr+= delta; + } + } + else { /* to to failed frame */ + if(clip->tracking.reconstruction.flag&TRACKING_RECONSTRUCTED) { + int a= sc->user.framenr; + MovieTracking *tracking= &clip->tracking; + + delta= pos == 3 ? 1 : -1; + + a+= delta; + + while(a+delta >= SFRA && a+delta <= EFRA) { + MovieReconstructedCamera *cam= BKE_tracking_get_reconstructed_camera(tracking, a); + + if(!cam) { + sc->user.framenr= a; + + break; + } + + a+= delta; + } + } + } + + if(CFRA!=sc->user.framenr) { + CFRA= sc->user.framenr; + sound_seek_scene(CTX_data_main(C), CTX_data_scene(C)); + + WM_event_add_notifier(C, NC_SCENE|ND_FRAME, scene); + } + + WM_event_add_notifier(C, NC_MOVIECLIP|ND_DISPLAY, NULL); + + return OPERATOR_FINISHED; +} + +void CLIP_OT_frame_jump(wmOperatorType *ot) +{ + static EnumPropertyItem position_items[] = { + {0, "PATHSTART", 0, "Path Start", "Jump to start of current path"}, + {1, "PATHEND", 0, "Path End", "Jump to end of current path"}, + {2, "FAILEDPREV", 0, "Previons Failed", "Jump to previous failed frame"}, + {2, "FAILNEXT", 0, "Next Failed", "Jump to next failed frame"}, + {0, NULL, 0, NULL, NULL} + }; + + /* identifiers */ + ot->name= "Jump to Frame"; + ot->description= "Jump to special frame"; + ot->idname= "CLIP_OT_frame_jump"; + + /* api callbacks */ + ot->exec= frame_jump_exec; + ot->poll= space_clip_frame_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + /* properties */ + RNA_def_enum(ot->srna, "position", position_items, 0, "Position", "Position to jumo to"); +} + +/********************** join tracks operator *********************/ + +static int join_tracks_exec(bContext *C, wmOperator *op) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTrackingTrack *act_track, *track, *next; + + act_track= clip->tracking.act_track; + + if(!act_track) { + BKE_report(op->reports, RPT_ERROR, "No active track to join to"); + return OPERATOR_CANCELLED; + } + + track= clip->tracking.tracks.first; + while(track) { + if(TRACK_VIEW_SELECTED(sc, track) && track!=act_track) { + if(!BKE_tracking_test_join_tracks(act_track, track)) { + BKE_report(op->reports, RPT_ERROR, "Some selected tracks have got keyframed markers to the same frame"); + return OPERATOR_CANCELLED; + } + } + + track= track->next; + } + + track= clip->tracking.tracks.first; + while(track) { + next= track->next; + + if(TRACK_VIEW_SELECTED(sc, track) && track!=act_track) { + BKE_tracking_join_tracks(act_track, track); + + BKE_tracking_free_track(track); + BLI_freelinkN(&clip->tracking.tracks, track); + } + + track= next; + } + + WM_event_add_notifier(C, NC_MOVIECLIP|NA_EDITED, clip); + + return OPERATOR_FINISHED; +} + +void CLIP_OT_join_tracks(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Join Tracks"; + ot->description= "Joint Selected Tracks"; + ot->idname= "CLIP_OT_join_tracks"; + + /* api callbacks */ + ot->exec= join_tracks_exec; + ot->poll= space_clip_frame_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; +} + +/********************** lock tracks operator *********************/ + +static int lock_tracks_exec(bContext *C, wmOperator *op) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTracking *tracking= &clip->tracking; + MovieTrackingTrack *track= tracking->tracks.first; + int action= RNA_enum_get(op->ptr, "action"); + + while(track) { + if(TRACK_VIEW_SELECTED(sc, track)) { + if(action==0) track->flag|= TRACK_LOCKED; + else if(action==1) track->flag&= ~TRACK_LOCKED; + else track->flag^= TRACK_LOCKED; + } + + track= track->next; + } + + WM_event_add_notifier(C, NC_MOVIECLIP|NA_EVALUATED, clip); + + return OPERATOR_FINISHED; +} + +void CLIP_OT_lock_tracks(wmOperatorType *ot) +{ + static EnumPropertyItem actions_items[] = { + {0, "LOCK", 0, "Lock", "Lock selected tracks"}, + {1, "UNLOCK", 0, "Unlock", "Unlock selected tracks"}, + {2, "TOGGLE", 0, "Toggle", "Toggle locked flag for selected tracks"}, + {0, NULL, 0, NULL, NULL} + }; + + /* identifiers */ + ot->name= "Lock Tracks"; + ot->description= "Lock/unlock selected tracks"; + ot->idname= "CLIP_OT_lock_tracks"; + + /* api callbacks */ + ot->exec= lock_tracks_exec; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + /* properties */ + RNA_def_enum(ot->srna, "action", actions_items, 0, "Action", "Lock action to execute"); +} + +/********************** track copy color operator *********************/ + +static int track_copy_color_exec(bContext *C, wmOperator *UNUSED(op)) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTrackingTrack *track, *act_track= clip->tracking.act_track; + + if(!act_track) + return OPERATOR_CANCELLED; + + track= clip->tracking.tracks.first; + while(track) { + if(TRACK_VIEW_SELECTED(sc, track) && track!=act_track) { + track->flag&= ~TRACK_CUSTOMCOLOR; + + if(act_track->flag&TRACK_CUSTOMCOLOR) { + copy_v3_v3(track->color, act_track->color); + track->flag|= TRACK_CUSTOMCOLOR; + } + } + + track= track->next; + } + + WM_event_add_notifier(C, NC_MOVIECLIP|ND_DISPLAY, clip); + + return OPERATOR_FINISHED; +} + +void CLIP_OT_track_copy_color(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Copy Color"; + ot->description= "Copy color to all selected tracks"; + ot->idname= "CLIP_OT_track_copy_color"; + + /* api callbacks */ + ot->exec= track_copy_color_exec; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; +} + +/********************** add 2d stabilization tracks operator *********************/ + +static int stabilize_2d_add_exec(bContext *C, wmOperator *UNUSED(op)) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTracking *tracking= &clip->tracking; + MovieTrackingTrack *track; + MovieTrackingStabilization *stab= &tracking->stabilization; + int update= 0; + + track= tracking->tracks.first; + while(track) { + if(TRACK_VIEW_SELECTED(sc, track) && (track->flag&TRACK_USE_2D_STAB)==0) { + track->flag|= TRACK_USE_2D_STAB; + stab->tot_track++; + + update= 1; + } + + track= track->next; + } + + if(update) { + stab->ok= 0; + + DAG_id_tag_update(&clip->id, 0); + WM_event_add_notifier(C, NC_MOVIECLIP|ND_DISPLAY, clip); + } + + return OPERATOR_FINISHED; +} + +void CLIP_OT_stabilize_2d_add(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Add Stabilization Tracks"; + ot->description= "Add selected tracks to 2D stabilization tool"; + ot->idname= "CLIP_OT_stabilize_2d_add"; + + /* api callbacks */ + ot->exec= stabilize_2d_add_exec; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; +} + +/********************** remove 2d stabilization tracks operator *********************/ + +static int stabilize_2d_remove_exec(bContext *C, wmOperator *UNUSED(op)) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTracking *tracking= &clip->tracking; + MovieTrackingStabilization *stab= &tracking->stabilization; + MovieTrackingTrack *track; + int a= 0, update= 0; + + track= tracking->tracks.first; + while(track) { + if(track->flag&TRACK_USE_2D_STAB) { + if(a==stab->act_track) { + track->flag&= ~TRACK_USE_2D_STAB; + + stab->act_track--; + stab->tot_track--; + + if(stab->act_track<0) + stab->act_track= 0; + + update= 1; + + break; + } + + a++; + } + + track= track->next; + } + + if(update) { + stab->ok= 0; + + DAG_id_tag_update(&clip->id, 0); + WM_event_add_notifier(C, NC_MOVIECLIP|ND_DISPLAY, clip); + } + + return OPERATOR_FINISHED; +} + +void CLIP_OT_stabilize_2d_remove(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Remove Stabilization Track"; + ot->description= "Remove selected track from stabilization"; + ot->idname= "CLIP_OT_stabilize_2d_remove"; + + /* api callbacks */ + ot->exec= stabilize_2d_remove_exec; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; +} + +/********************** select 2d stabilization tracks operator *********************/ + +static int stabilize_2d_select_exec(bContext *C, wmOperator *UNUSED(op)) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTracking *tracking= &clip->tracking; + MovieTrackingTrack *track; + int update= 0; + + track= tracking->tracks.first; + while(track) { + if(track->flag&TRACK_USE_2D_STAB) { + BKE_tracking_track_flag(track, TRACK_AREA_ALL, SELECT, 0); + + update= 1; + } + + track= track->next; + } + + if(update) + WM_event_add_notifier(C, NC_MOVIECLIP|ND_SELECT, clip); + + return OPERATOR_FINISHED; +} + +void CLIP_OT_stabilize_2d_select(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Select Stabilization Tracks"; + ot->description= "Select track which are used for stabilization"; + ot->idname= "CLIP_OT_stabilize_2d_select"; + + /* api callbacks */ + ot->exec= stabilize_2d_select_exec; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; +} + +/********************** set 2d stabilization rotation track operator *********************/ + +static int stabilize_2d_set_rotation_exec(bContext *C, wmOperator *UNUSED(op)) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTracking *tracking= &clip->tracking; + + if(tracking->act_track) { + MovieTrackingStabilization *stab= &tracking->stabilization; + + stab->rot_track= tracking->act_track; + stab->ok= 0; + + DAG_id_tag_update(&clip->id, 0); + WM_event_add_notifier(C, NC_MOVIECLIP|ND_DISPLAY, clip); + } + + return OPERATOR_FINISHED; +} + +void CLIP_OT_stabilize_2d_set_rotation(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Set Rotation Track"; + ot->description= "Use active track to compensate rotaiton when doing 2D stabilization"; + ot->idname= "CLIP_OT_stabilize_2d_set_rotation"; + + /* api callbacks */ + ot->exec= stabilize_2d_set_rotation_exec; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; +} + +/********************** clean tracks operator *********************/ + +static int is_track_clean(MovieTrackingTrack *track, int frames, int del) +{ + int ok= 1, a, prev= -1, count= 0; + MovieTrackingMarker *markers= track->markers, *new_markers= NULL; + int start_disabled= 0; + int markersnr= track->markersnr; + + if(del) + new_markers= MEM_callocN(markersnr*sizeof(MovieTrackingMarker), "track cleaned markers"); + + for(a= 0; a<markersnr; a++) { + int end= 0; + + if(prev==-1) { + if((markers[a].flag&MARKER_DISABLED)==0) + prev= a; + else + start_disabled= 1; + } + + if(prev >= 0) { + end= a == markersnr-1; + end|= (a < markersnr-1) && (markers[a].framenr != markers[a+1].framenr-1 || + markers[a].flag&MARKER_DISABLED); + } + + if(end) { + int segok= 1, len= 0; + + if(a != prev && markers[a].framenr != markers[a-1].framenr+1) + len= a-prev; + else if(markers[a].flag&MARKER_DISABLED) + len= a-prev; + else len= a-prev+1; + + if(frames) { + if(len < frames) { + segok= 0; + ok= 0; + + if(!del) + break; + } + } + + if(del) { + if(segok) { + int t= len; + + if(markers[a].flag&MARKER_DISABLED) + t++; + + /* place disabled marker in front of current segment */ + if(start_disabled) { + memcpy(new_markers+count, markers+prev, sizeof(MovieTrackingMarker)); + new_markers[count].framenr--; + new_markers[count].flag|= MARKER_DISABLED; + + count++; + start_disabled= 0; + } + + memcpy(new_markers+count, markers+prev, t*sizeof(MovieTrackingMarker)); + count+= t; + } + else if(markers[a].flag&MARKER_DISABLED) { + /* current segment which would be deleted was finished by disabled marker, + so next segment should be started from disabled marker */ + start_disabled= 1; + } + } + + prev= -1; + } + } + + if(del) { + MEM_freeN(track->markers); + + if(count) { + track->markers= new_markers; + } + else { + track->markers= NULL; + MEM_freeN(new_markers); + } + + track->markersnr= count; + } + + return ok; +} + +static int clean_tracks_exec(bContext *C, wmOperator *op) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + MovieTracking *tracking= &clip->tracking; + MovieTrackingTrack *track, *next, *act_track= clip->tracking.act_track; + int frames= RNA_int_get(op->ptr, "frames"); + int action= RNA_enum_get(op->ptr, "action"); + float error= RNA_float_get(op->ptr, "error"); + + if(error && action==TRACKING_CLEAN_DELETE_SEGMENT) + action= TRACKING_CLEAN_DELETE_TRACK; + + track= tracking->tracks.first; + while(track) { + next= track->next; + + if((track->flag&TRACK_HIDDEN)==0 && (track->flag&TRACK_LOCKED)==0) { + int ok= 1; + + ok= (is_track_clean(track, frames, action==TRACKING_CLEAN_DELETE_SEGMENT)) && + (error == 0.0f || (track->flag&TRACK_HAS_BUNDLE)==0 || track->error < error); + + if(!ok) { + if(action==TRACKING_CLEAN_SELECT) { + BKE_tracking_track_flag(track, TRACK_AREA_ALL, SELECT, 0); + } + else if(action==TRACKING_CLEAN_DELETE_TRACK) { + if(track==act_track) + clip->tracking.act_track= NULL; + + BKE_tracking_free_track(track); + BLI_freelinkN(&clip->tracking.tracks, track); + track= NULL; + } + + /* happens when all tracking segments are not long enough */ + if(track && track->markersnr==0) { + if(track==act_track) + clip->tracking.act_track= NULL; + + BKE_tracking_free_track(track); + BLI_freelinkN(&clip->tracking.tracks, track); + } + } + } + + track= next; + } + + WM_event_add_notifier(C, NC_MOVIECLIP|ND_SELECT, clip); + + return OPERATOR_FINISHED; +} + +static int clean_tracks_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event)) +{ + SpaceClip *sc= CTX_wm_space_clip(C); + MovieClip *clip= ED_space_clip(sc); + int frames= RNA_int_get(op->ptr, "frames"); + float error= RNA_float_get(op->ptr, "error"); + int action= RNA_enum_get(op->ptr, "action"); + + if(frames==0 && error==0 && action==0) { + RNA_int_set(op->ptr, "frames", clip->tracking.settings.clean_frames); + RNA_float_set(op->ptr, "error", clip->tracking.settings.clean_error); + RNA_enum_set(op->ptr, "action", clip->tracking.settings.clean_action); + } + + return clean_tracks_exec(C, op); +} + +void CLIP_OT_clean_tracks(wmOperatorType *ot) +{ + static EnumPropertyItem actions_items[] = { + {TRACKING_CLEAN_SELECT, "SELECT", 0, "Select", "Select unclean tracks"}, + {TRACKING_CLEAN_DELETE_TRACK, "DELETE_TRACK", 0, "Delete Track", "Delete unclean tracks"}, + {TRACKING_CLEAN_DELETE_SEGMENT, "DELETE_SEGMENTS", 0, "Delete Segments", "Delete unclean segments of tracks"}, + {0, NULL, 0, NULL, NULL} + }; + + /* identifiers */ + ot->name= "Clean Tracks"; + ot->description= "Clean tracks"; + ot->idname= "CLIP_OT_clean_tracks"; + + /* api callbacks */ + ot->exec= clean_tracks_exec; + ot->invoke= clean_tracks_invoke; + ot->poll= ED_space_clip_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + /* properties */ + RNA_def_int(ot->srna, "frames", 0, 0, INT_MAX, "Tracked Frames", "Effect on tracks which are tracked less than specified amount of frames", 0, INT_MAX); + RNA_def_float(ot->srna, "error", 0.0f, 0.0f, FLT_MAX, "Reprojection Error", "Effect on tracks with have got larger reprojection error", 0.0f, 100.0f); + RNA_def_enum(ot->srna, "action", actions_items, 0, "Action", "Cleanup action to execute"); +} |