Revision: 46621
http://projects.blender.org/scm/viewvc.php?view=rev&root=bf-blender&revision=46621
Author: keir
Date: 2012-05-14 10:47:25 +0000 (Mon, 14 May 2012)
Log Message:
-----------
Start migrating away from pat_min and pat_max for markers
This starts converting markers in the movie clip editor / 2D
tracker from using pat_min and pat_max notation to using the
a more general, 4-corner representation. There is still
considerable porting work to do; in particular:
- The preview widget does not respect the new
representation
- The corners cannot yet be edited individually.
- The clamping does not do the right thing for general
corners; e.g. detecting a convex quad.
- The tracking code in Blender does not actually invoke the
corner tracking version of libmv's tracking API.
Next steps:
- Convert libmv's legacy ESM tracker and brute tracker to
work under the new TrackRegion() API.
- Make Blender use the new TrackRegion() API; this will
allow real planar tracking tests.
- Everything else (UI, etc).
This patch is mostly the work of Sergey Sharybin.
Modified Paths:
--------------
branches/soc-2011-tomato/source/blender/blenkernel/BKE_tracking.h
branches/soc-2011-tomato/source/blender/blenkernel/intern/movieclip.c
branches/soc-2011-tomato/source/blender/blenkernel/intern/tracking.c
branches/soc-2011-tomato/source/blender/blenloader/intern/readfile.c
branches/soc-2011-tomato/source/blender/editors/space_clip/clip_buttons.c
branches/soc-2011-tomato/source/blender/editors/space_clip/clip_draw.c
branches/soc-2011-tomato/source/blender/editors/space_clip/space_clip.c
branches/soc-2011-tomato/source/blender/editors/space_clip/tracking_ops.c
branches/soc-2011-tomato/source/blender/editors/transform/transform_conversions.c
branches/soc-2011-tomato/source/blender/makesdna/DNA_tracking_types.h
Modified: branches/soc-2011-tomato/source/blender/blenkernel/BKE_tracking.h
===================================================================
--- branches/soc-2011-tomato/source/blender/blenkernel/BKE_tracking.h
2012-05-13 23:29:49 UTC (rev 46620)
+++ branches/soc-2011-tomato/source/blender/blenkernel/BKE_tracking.h
2012-05-14 10:47:25 UTC (rev 46621)
@@ -57,6 +57,7 @@
struct
MovieTrackingMarker *marker);
void BKE_tracking_delete_marker(struct MovieTrackingTrack *track, int framenr);
+void BKE_tracking_marker_pattern_minmax(struct MovieTrackingMarker *marker,
float min[2], float max[2]);
struct MovieTrackingMarker *BKE_tracking_get_marker(struct MovieTrackingTrack
*track, int framenr);
struct MovieTrackingMarker *BKE_tracking_ensure_marker(struct
MovieTrackingTrack *track, int framenr);
struct MovieTrackingMarker *BKE_tracking_exact_marker(struct
MovieTrackingTrack *track, int framenr);
Modified: branches/soc-2011-tomato/source/blender/blenkernel/intern/movieclip.c
===================================================================
--- branches/soc-2011-tomato/source/blender/blenkernel/intern/movieclip.c
2012-05-13 23:29:49 UTC (rev 46620)
+++ branches/soc-2011-tomato/source/blender/blenkernel/intern/movieclip.c
2012-05-14 10:47:25 UTC (rev 46621)
@@ -1076,10 +1076,18 @@
}
if ((track->flag & TRACK_LOCKED) == 0) {
+ float pat_min[2], pat_max[2];
+
scopes->marker = marker;
scopes->track = track;
- scopes->slide_scale[0] = track->pat_max[0] -
track->pat_min[0];
- scopes->slide_scale[1] = track->pat_max[1] -
track->pat_min[1];
+
+ /* XXX: would work fine with non-transformed
patterns, but would likely fail
+ * with transformed patterns, but that
would be easier to debug when
+ * we'll have real pattern sampling (at
least to test) */
+ BKE_tracking_marker_pattern_minmax(marker,
pat_min, pat_max);
+
+ scopes->slide_scale[0] = pat_max[0] -
pat_min[0];
+ scopes->slide_scale[1] = pat_max[1] -
pat_min[1];
}
}
}
Modified: branches/soc-2011-tomato/source/blender/blenkernel/intern/tracking.c
===================================================================
--- branches/soc-2011-tomato/source/blender/blenkernel/intern/tracking.c
2012-05-13 23:29:49 UTC (rev 46620)
+++ branches/soc-2011-tomato/source/blender/blenkernel/intern/tracking.c
2012-05-14 10:47:25 UTC (rev 46621)
@@ -102,59 +102,67 @@
void BKE_tracking_clamp_track(MovieTrackingTrack *track, int event)
{
int a;
- float pat_min[2];
- float pat_max[2];
+ float pat_min[2], pat_max[2];
+ float eff_pat_min[2], eff_pat_max[2];
float max_pyramid_level_factor = 1.0;
if (track->tracker == TRACKER_KLT) {
max_pyramid_level_factor = 1 << (track->pyramid_levels - 1);
}
- /* sort */
- for (a = 0; a < 2; a++) {
- if (track->pat_min[a] > track->pat_max[a])
- SWAP(float, track->pat_min[a], track->pat_max[a]);
+ /* XXX: currently search area is global, pattern size is per-marker, so
we'll need to
+ * find maximal size of pattern to clamp search size nicely */
+ INIT_MINMAX2(pat_min, pat_max);
- if (track->search_min[a] > track->search_max[a])
- SWAP(float, track->search_min[a], track->search_max[a]);
+ for (a = 0; a < track->markersnr; a++) {
+ float cur_pat_min[2], cur_pat_max[2];
+
+ BKE_tracking_marker_pattern_minmax(&track->markers[a],
cur_pat_min, cur_pat_max);
+
+ DO_MINMAX2(cur_pat_min, pat_min, pat_max);
+ DO_MINMAX2(cur_pat_max, pat_min, pat_max);
}
/* compute the effective pattern size, which differs from the fine
resolution
* pattern size for the pyramid KLT tracker */
for (a = 0; a < 2; a++) {
- pat_min[a] = max_pyramid_level_factor * track->pat_min[a];
- pat_max[a] = max_pyramid_level_factor * track->pat_max[a];
+ eff_pat_min[a] = max_pyramid_level_factor * pat_min[a];
+ eff_pat_max[a] = max_pyramid_level_factor * pat_max[a];
}
if (event == CLAMP_PAT_DIM) {
for (a = 0; a < 2; a++) {
/* search shouldn't be resized smaller than pattern */
- track->search_min[a] = MIN2(pat_min[a],
track->search_min[a]);
- track->search_max[a] = MAX2(pat_max[a],
track->search_max[a]);
+ track->search_min[a] = MIN2(eff_pat_min[a],
track->search_min[a]);
+ track->search_max[a] = MAX2(eff_pat_max[a],
track->search_max[a]);
}
}
else if (event == CLAMP_PAT_POS) {
float dim[2];
- sub_v2_v2v2(dim, track->pat_max, track->pat_min);
+ sub_v2_v2v2(dim, pat_max, pat_min);
+#if 0
+ /* XXX: needs porting, but we need to know marker here, will be
ported after a bit
+ * more global refactoring */
for (a = 0; a < 2; a++) {
/* pattern shouldn't be moved outside of search */
- if (pat_min[a] < track->search_min[a]) {
- track->pat_min[a] = track->search_min[a] -
(pat_min[a] - track->pat_min[a]);
+ if (eff_pat_min[a] < track->search_min[a]) {
+ track->pat_min[a] = track->search_min[a] -
(eff_pat_min[a] - pat_min[a]);
track->pat_max[a] = track->pat_min[a] + dim[a];
}
- if (track->pat_max[a] > track->search_max[a]) {
- track->pat_max[a] = track->search_max[a] -
(pat_max[a] - track->pat_max[a]);
+ if (eff_pat_max[a] > track->search_max[a]) {
+ track->pat_max[a] = track->search_max[a] -
(eff_pat_max[a] - pat_max[a]);
track->pat_min[a] = track->pat_max[a] - dim[a];
}
}
+#endif
}
else if (event == CLAMP_SEARCH_DIM) {
for (a = 0; a < 2; a++) {
/* search shouldn't be resized smaller than pattern */
- track->search_min[a] = MIN2(pat_min[a],
track->search_min[a]);
- track->search_max[a] = MAX2(pat_max[a],
track->search_max[a]);
+ track->search_min[a] = MIN2(eff_pat_min[a],
track->search_min[a]);
+ track->search_max[a] = MAX2(eff_pat_max[a],
track->search_max[a]);
}
}
else if (event == CLAMP_SEARCH_POS) {
@@ -164,42 +172,30 @@
for (a = 0; a < 2; a++) {
/* search shouldn't be moved inside pattern */
- if (track->search_min[a] > pat_min[a]) {
- track->search_min[a] = pat_min[a];
+ if (track->search_min[a] > eff_pat_min[a]) {
+ track->search_min[a] = eff_pat_min[a];
track->search_max[a] = track->search_min[a] +
dim[a];
}
- if (track->search_max[a] < pat_max[a]) {
- track->search_max[a] = pat_max[a];
+ if (track->search_max[a] < eff_pat_max[a]) {
+ track->search_max[a] = eff_pat_max[a];
track->search_min[a] = track->search_max[a] -
dim[a];
}
}
}
else if (event == CLAMP_PYRAMID_LEVELS || (event == CLAMP_SEARCH_DIM &&
track->tracker == TRACKER_KLT)) {
float dim[2];
- sub_v2_v2v2(dim, track->pat_max, track->pat_min);
+ sub_v2_v2v2(dim, pat_max, pat_min);
{
float search_ratio = 2.3f * max_pyramid_level_factor;
/* resize the search area to something sensible based
* on the number of pyramid levels */
for (a = 0; a < 2; a++) {
- track->search_min[a] = search_ratio *
track->pat_min[a];
- track->search_max[a] = search_ratio *
track->pat_max[a];
+ track->search_min[a] = search_ratio *
pat_min[a];
+ track->search_max[a] = search_ratio *
pat_max[a];
}
}
}
-
- /* marker's center should be in center of pattern */
- if (event == CLAMP_PAT_DIM || event == CLAMP_PAT_POS) {
- float dim[2];
-
- sub_v2_v2v2(dim, track->pat_max, track->pat_min);
-
- for (a = 0; a < 2; a++) {
- track->pat_min[a] = -dim[a] / 2.0f;
- track->pat_max[a] = dim[a] / 2.0f;
- }
- }
}
void BKE_tracking_track_flag(MovieTrackingTrack *track, int area, int flag,
int clear)
@@ -258,9 +254,15 @@
marker.pos[1] = y;
marker.framenr = framenr;
- copy_v2_v2(track->pat_max, pat);
- negate_v2_v2(track->pat_min, pat);
+ marker.pattern_corners[0][0] = -pat[0];
+ marker.pattern_corners[0][1] = -pat[1];
+ marker.pattern_corners[1][0] = pat[0];
+ marker.pattern_corners[1][1] = -pat[1];
+
+ negate_v2_v2(marker.pattern_corners[2], marker.pattern_corners[0]);
+ negate_v2_v2(marker.pattern_corners[3], marker.pattern_corners[1]);
+
copy_v2_v2(track->search_max, search);
negate_v2_v2(track->search_min, search);
@@ -337,6 +339,16 @@
}
}
+void BKE_tracking_marker_pattern_minmax(MovieTrackingMarker *marker, float
min[2], float max[2])
+{
+ INIT_MINMAX2(min, max);
+
+ DO_MINMAX2(marker->pattern_corners[0], min, max);
+ DO_MINMAX2(marker->pattern_corners[1], min, max);
+ DO_MINMAX2(marker->pattern_corners[2], min, max);
+ DO_MINMAX2(marker->pattern_corners[3], min, max);
+}
+
MovieTrackingMarker *BKE_tracking_get_marker(MovieTrackingTrack *track, int
framenr)
{
int a = track->markersnr - 1;
@@ -1002,29 +1014,39 @@
#ifdef WITH_LIBMV
{
- float patx =
(int)((track->pat_max[0] - track->pat_min[0]) * width),
- paty =
(int)((track->pat_max[1] - track->pat_min[1]) * height);
+ float search_size_x,
search_size_y;
+ float pattern_size_x,
pattern_size_y;
+ float pat_min[2], pat_max[2],
patx, paty;
+ float search_to_pattern_ratio,
log2_search_to_pattern_ratio;
+ int wndx, wndy, half_wnd,
max_pyramid_levels, level;
- float search_size_x =
(track->search_max[0] - track->search_min[0]) * width;
- float search_size_y =
(track->search_max[1] - track->search_min[1]) * height;
- float pattern_size_x =
(track->pat_max[0] - track->pat_min[0]) * width;
- float pattern_size_y =
(track->pat_max[1] - track->pat_min[1]) * height;
- int wndx = (int)patx / 2, wndy
= (int)paty / 2;
- int half_wnd = MAX2(wndx, wndy);
+ struct libmv_RegionTracker
*region_tracker;
- /* compute the maximum
pyramid size */
- float search_to_pattern_ratio =
MIN2(search_size_x, search_size_y)
- / MAX2(pattern_size_x,
pattern_size_y);
- float
log2_search_to_pattern_ratio = log(floor(search_to_pattern_ratio)) / M_LN2;
- int max_pyramid_levels =
floor(log2_search_to_pattern_ratio + 1);
+ /* XXX: use boundbox of
marker's pattern for now
+ * no idea how it should
behave with non-affine tracking */
+
BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
+ patx = (int)((pat_max[0] -
pat_min[0]) * width);
+ paty = (int)((pat_max[1] -
pat_min[1]) * height);
+ wndx = (int)patx / 2;
+ wndy = (int)paty / 2;
+ half_wnd = MAX2(wndx, wndy);
+
+ search_size_x =
(track->search_max[0] - track->search_min[0]) * width;
+ search_size_y =
(track->search_max[1] - track->search_min[1]) * height;
+ pattern_size_x = (pat_max[0] -
pat_min[0]) * width;
+ pattern_size_y = (pat_max[1] -
pat_min[1]) * height;
+
@@ Diff output truncated at 10240 characters. @@
_______________________________________________
Bf-blender-cvs mailing list
[email protected]
http://lists.blender.org/mailman/listinfo/bf-blender-cvs
