4 * Copyright (C) 2012 Adam Williams <broadcast at earthling dot net>
5 * Copyright (C) 2003-2016 Cinelerra CV contributors
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include "bcdisplayinfo.h"
27 #include "bcsignals.h"
31 #include "mainerror.h"
33 #include "motionscan.h"
34 #include "motionwindow.h"
36 #include "overlayframe.h"
37 #include "rotateframe.h"
38 #include "transportque.h"
44 REGISTER_PLUGIN(MotionMain)
49 MotionConfig::MotionConfig()
51 global_range_w = 25; //5;
52 global_range_h = 25; //5;
53 rotation_range = 8; //5;
56 global_block_w = 33; //MIN_BLOCK;
57 global_block_h = 33; //MIN_BLOCK;
62 global_positions = 256;
63 rotate_positions = 8; // 4;
65 rotate_magnitude = 30;
66 return_speed = 5; //0;
67 rotate_return_speed = 5; //0;
68 action_type = MotionScan::STABILIZE;
72 addtrackedframeoffset = 0;
73 strcpy(tracking_file, TRACKING_FILE);
74 tracking_type = MotionScan::SAVE; //MotionScan::NO_CALCULATE;
75 tracking_object = MotionScan::TRACK_PREVIOUS; //TRACK_SINGLE;
76 draw_vectors = 1; //0;
84 void MotionConfig::boundaries()
86 CLAMP(global_range_w, MIN_RADIUS, MAX_RADIUS);
87 CLAMP(global_range_h, MIN_RADIUS, MAX_RADIUS);
88 CLAMP(rotation_range, MIN_ROTATION, MAX_ROTATION);
89 CLAMP(rotation_center, -MAX_ROTATION, MAX_ROTATION);
90 CLAMP(block_count, MIN_BLOCKS, MAX_BLOCKS);
91 CLAMP(global_block_w, MIN_BLOCK, MAX_BLOCK);
92 CLAMP(global_block_h, MIN_BLOCK, MAX_BLOCK);
95 int MotionConfig::equivalent(MotionConfig &that)
97 return global_range_w == that.global_range_w &&
98 global_range_h == that.global_range_h &&
99 rotation_range == that.rotation_range &&
100 rotation_center == that.rotation_center &&
101 action_type == that.action_type &&
102 global == that.global && rotate == that.rotate &&
103 twopass == that.twopass &&
104 addtrackedframeoffset == that.addtrackedframeoffset &&
105 draw_vectors == that.draw_vectors &&
106 block_count == that.block_count &&
107 global_block_w == that.global_block_w &&
108 global_block_h == that.global_block_h &&
109 EQUIV(block_x, that.block_x) &&
110 EQUIV(block_y, that.block_y) &&
111 noise_level == that.noise_level &&
112 noise_rotation == that.noise_rotation &&
113 global_positions == that.global_positions &&
114 rotate_positions == that.rotate_positions &&
115 magnitude == that.magnitude &&
116 return_speed == that.return_speed &&
117 rotate_return_speed == that.rotate_return_speed &&
118 rotate_magnitude == that.rotate_magnitude &&
119 tracking_object == that.tracking_object &&
120 track_frame == that.track_frame &&
121 bottom_is_master == that.bottom_is_master &&
122 horizontal_only == that.horizontal_only &&
123 vertical_only == that.vertical_only;
126 void MotionConfig::copy_from(MotionConfig &that)
128 global_range_w = that.global_range_w;
129 global_range_h = that.global_range_h;
130 rotation_range = that.rotation_range;
131 rotation_center = that.rotation_center;
132 action_type = that.action_type;
133 global = that.global;
134 rotate = that.rotate;
135 twopass = that.twopass;
136 addtrackedframeoffset = that.addtrackedframeoffset;
137 tracking_type = that.tracking_type;
138 draw_vectors = that.draw_vectors;
139 block_count = that.block_count;
140 block_x = that.block_x;
141 block_y = that.block_y;
142 noise_level = that.noise_level;
143 noise_rotation = that.noise_rotation;
144 global_positions = that.global_positions;
145 rotate_positions = that.rotate_positions;
146 global_block_w = that.global_block_w;
147 global_block_h = that.global_block_h;
148 magnitude = that.magnitude;
149 return_speed = that.return_speed;
150 rotate_magnitude = that.rotate_magnitude;
151 rotate_return_speed = that.rotate_return_speed;
152 tracking_object = that.tracking_object;
153 track_frame = that.track_frame;
154 bottom_is_master = that.bottom_is_master;
155 horizontal_only = that.horizontal_only;
156 vertical_only = that.vertical_only;
159 void MotionConfig::interpolate(MotionConfig &prev, MotionConfig &next,
160 int64_t prev_frame, int64_t next_frame, int64_t current_frame)
166 MotionMain::MotionMain(PluginServer *server)
167 : PluginVClient(server)
179 previous_frame_number = -1;
182 current_global_ref = 0;
183 global_target_src = 0;
184 global_target_dst = 0;
187 cache_fp = active_fp = 0;
189 cache_key = active_key = -1;
190 dx_offset = dy_offset = 0;
193 save_dx = load_dx = 0;
194 save_dy = load_dy = 0;
195 save_dt = load_dt = 0;
198 current_rotate_ref = 0;
199 rotate_target_src = 0;
200 rotate_target_dst = 0;
203 MotionMain::~MotionMain()
208 delete [] search_area;
210 delete rotate_engine;
211 delete motion_rotate;
213 delete prev_global_ref;
214 delete current_global_ref;
215 delete global_target_src;
216 delete global_target_dst;
220 delete prev_rotate_ref;
221 delete current_rotate_ref;
222 delete rotate_target_src;
223 delete rotate_target_dst;
226 const char* MotionMain::plugin_title() { return N_("Motion"); }
227 int MotionMain::is_realtime() { return 1; }
228 int MotionMain::is_multichannel() { return 1; }
231 NEW_WINDOW_MACRO(MotionMain, MotionWindow)
233 LOAD_CONFIGURATION_MACRO(MotionMain, MotionConfig)
237 void MotionMain::update_gui()
239 if( !thread ) return;
240 if( !load_configuration() ) return;
241 thread->window->lock_window("MotionMain::update_gui");
242 MotionWindow *window = (MotionWindow*)thread->window;
244 char string[BCTEXTLEN];
245 sprintf(string, "%d", config.global_positions);
246 window->global_search_positions->set_text(string);
247 sprintf(string, "%d", config.rotate_positions);
248 window->rotation_search_positions->set_text(string);
250 window->global_block_w->update(config.global_block_w);
251 window->global_block_h->update(config.global_block_h);
252 window->block_x->update(config.block_x);
253 window->block_y->update(config.block_y);
254 window->block_x_text->update((float)config.block_x);
255 window->block_y_text->update((float)config.block_y);
256 window->noise_level->update(config.noise_level);
257 window->noise_level_text->update((float)config.noise_level);
258 window->noise_rotation->update(config.noise_rotation);
259 window->noise_rotation_text->update((float)config.noise_rotation);
260 window->magnitude->update(config.magnitude);
261 window->return_speed->update(config.return_speed);
262 window->rotate_magnitude->update(config.rotate_magnitude);
263 window->rotate_return_speed->update(config.rotate_return_speed);
264 window->rotation_range->update(config.rotation_range);
265 window->rotation_center->update(config.rotation_center);
268 window->track_single->update(config.tracking_object == MotionScan::TRACK_SINGLE);
269 window->track_frame_number->update(config.track_frame);
270 window->track_previous->update(config.tracking_object == MotionScan::TRACK_PREVIOUS);
271 window->previous_same->update(config.tracking_object == MotionScan::PREVIOUS_SAME_BLOCK);
272 if( config.tracking_object != MotionScan::TRACK_SINGLE )
274 window->track_frame_number->disable();
275 window->frame_current->disable();
279 window->track_frame_number->enable();
280 window->frame_current->enable();
283 window->action_type->set_text(
284 ActionType::to_text(config.action_type));
285 window->tracking_type->set_text(
286 TrackingType::to_text(config.tracking_type));
287 window->track_direction->set_text(
288 TrackDirection::to_text(config.horizontal_only, config.vertical_only));
289 window->master_layer->set_text(
290 MasterLayer::to_text(config.bottom_is_master));
292 window->update_mode();
293 thread->window->unlock_window();
299 void MotionMain::save_data(KeyFrame *keyframe)
303 // cause data to be stored directly in text
304 output.set_shared_output(keyframe->xbuf);
305 output.tag.set_title("MOTION");
307 output.tag.set_property("BLOCK_COUNT", config.block_count);
308 output.tag.set_property("GLOBAL_POSITIONS", config.global_positions);
309 output.tag.set_property("ROTATE_POSITIONS", config.rotate_positions);
310 output.tag.set_property("GLOBAL_BLOCK_W", config.global_block_w);
311 output.tag.set_property("GLOBAL_BLOCK_H", config.global_block_h);
312 output.tag.set_property("BLOCK_X", config.block_x);
313 output.tag.set_property("BLOCK_Y", config.block_y);
314 output.tag.set_property("GLOBAL_RANGE_W", config.global_range_w);
315 output.tag.set_property("GLOBAL_RANGE_H", config.global_range_h);
316 output.tag.set_property("ROTATION_RANGE", config.rotation_range);
317 output.tag.set_property("ROTATION_CENTER", config.rotation_center);
318 output.tag.set_property("MAGNITUDE", config.magnitude);
319 output.tag.set_property("RETURN_SPEED", config.return_speed);
320 output.tag.set_property("ROTATE_MAGNITUDE", config.rotate_magnitude);
321 output.tag.set_property("ROTATE_RETURN_SPEED", config.rotate_return_speed);
322 output.tag.set_property("NOISE_LEVEL", config.noise_level);
323 output.tag.set_property("NOISE_ROTATION", config.noise_rotation);
324 output.tag.set_property("ACTION_TYPE", config.action_type);
325 output.tag.set_property("GLOBAL", config.global);
326 output.tag.set_property("ROTATE", config.rotate);
327 output.tag.set_property("TWOPASS", config.twopass);
328 output.tag.set_property("ADDTRACKEDFRAMEOFFSET", config.addtrackedframeoffset);
329 output.tag.set_property("TRACKING_FILE", config.tracking_file);
330 output.tag.set_property("TRACKING_TYPE", config.tracking_type);
331 output.tag.set_property("DRAW_VECTORS", config.draw_vectors);
332 output.tag.set_property("TRACKING_OBJECT", config.tracking_object);
333 output.tag.set_property("TRACK_FRAME", config.track_frame);
334 output.tag.set_property("BOTTOM_IS_MASTER", config.bottom_is_master);
335 output.tag.set_property("HORIZONTAL_ONLY", config.horizontal_only);
336 output.tag.set_property("VERTICAL_ONLY", config.vertical_only);
338 output.tag.set_title("/MOTION");
340 output.terminate_string();
343 void MotionMain::read_data(KeyFrame *keyframe)
346 input.set_shared_input(keyframe->xbuf);
349 while( !(result = input.read_tag()) ) {
350 if( input.tag.title_is("MOTION") ) {
351 config.block_count = input.tag.get_property("BLOCK_COUNT", config.block_count);
352 config.global_positions = input.tag.get_property("GLOBAL_POSITIONS", config.global_positions);
353 config.rotate_positions = input.tag.get_property("ROTATE_POSITIONS", config.rotate_positions);
354 config.global_block_w = input.tag.get_property("GLOBAL_BLOCK_W", config.global_block_w);
355 config.global_block_h = input.tag.get_property("GLOBAL_BLOCK_H", config.global_block_h);
356 config.block_x = input.tag.get_property("BLOCK_X", config.block_x);
357 config.block_y = input.tag.get_property("BLOCK_Y", config.block_y);
358 config.global_range_w = input.tag.get_property("GLOBAL_RANGE_W", config.global_range_w);
359 config.global_range_h = input.tag.get_property("GLOBAL_RANGE_H", config.global_range_h);
360 config.rotation_range = input.tag.get_property("ROTATION_RANGE", config.rotation_range);
361 config.rotation_center = input.tag.get_property("ROTATION_CENTER", config.rotation_center);
362 config.magnitude = input.tag.get_property("MAGNITUDE", config.magnitude);
363 config.return_speed = input.tag.get_property("RETURN_SPEED", config.return_speed);
364 config.rotate_magnitude = input.tag.get_property("ROTATE_MAGNITUDE", config.rotate_magnitude);
365 config.rotate_return_speed = input.tag.get_property("ROTATE_RETURN_SPEED", config.rotate_return_speed);
366 config.noise_level = input.tag.get_property("NOISE_LEVEL", config.noise_level);
367 config.noise_rotation = input.tag.get_property("NOISE_ROTATION", config.noise_rotation);
368 config.action_type = input.tag.get_property("ACTION_TYPE", config.action_type);
369 config.global = input.tag.get_property("GLOBAL", config.global);
370 config.rotate = input.tag.get_property("ROTATE", config.rotate);
371 config.twopass = input.tag.get_property("TWOPASS", config.twopass);
372 config.addtrackedframeoffset = input.tag.get_property("ADDTRACKEDFRAMEOFFSET", config.addtrackedframeoffset);
373 input.tag.get_property("TRACKING_FILE", config.tracking_file);
374 config.tracking_type = input.tag.get_property("TRACKING_TYPE", config.tracking_type);
375 config.draw_vectors = input.tag.get_property("DRAW_VECTORS", config.draw_vectors);
376 config.tracking_object = input.tag.get_property("TRACKING_OBJECT", config.tracking_object);
377 config.track_frame = input.tag.get_property("TRACK_FRAME", config.track_frame);
378 config.bottom_is_master = input.tag.get_property("BOTTOM_IS_MASTER", config.bottom_is_master);
379 config.horizontal_only = input.tag.get_property("HORIZONTAL_ONLY", config.horizontal_only);
380 config.vertical_only = input.tag.get_property("VERTICAL_ONLY", config.vertical_only);
386 void MotionMain::allocate_temp(int w, int h, int color_model)
389 ( temp_frame->get_w() != w || temp_frame->get_h() != h ) ) {
394 temp_frame = new VFrame(w, h, color_model, 0);
397 void MotionMain::process_global()
400 if( !engine ) engine = new MotionScan(this,
401 PluginClient::get_project_smp() + 1,
402 PluginClient::get_project_smp() + 1);
404 // Determine if frames changed, either single pass or pass 1
405 // Attention, prev_global_ref and current_global_ref are interchanged
406 engine->scan_frame(current_global_ref, prev_global_ref,
407 config.global_range_w, config.global_range_h,
408 config.global_block_w, config.global_block_h,
409 config.block_x, config.block_y,
410 config.tracking_object, config.tracking_type,
411 config.action_type, config.horizontal_only,
412 config.vertical_only, get_source_position(),
413 config.global_positions, total_dx, total_dy,
414 0, 0, config.twopass, load_ok, load_dx, load_dy);
415 current_dx = (engine->dx_result += dx_offset);
416 current_dy = (engine->dy_result += dy_offset);
419 if( config.tracking_type == MotionScan::SAVE ) {
420 save_dx = current_dx;
421 save_dy = current_dy;
424 // Add current motion vector to accumulation vector.
425 if( config.tracking_object != MotionScan::TRACK_SINGLE ) {
427 total_dx = (int64_t)total_dx * (100 - config.return_speed) / 100;
428 total_dy = (int64_t)total_dy * (100 - config.return_speed) / 100;
429 total_dx += engine->dx_result;
430 total_dy += engine->dy_result;
431 // printf("MotionMain::process_global total_dx=%d engine->dx_result=%d\n",
432 // total_dx, engine->dx_result);
435 // Make accumulation vector current
436 total_dx = engine->dx_result;
437 total_dy = engine->dy_result;
440 // Clamp accumulation vector
441 if( config.magnitude < 100 ) {
442 int block_x_orig = lrint(config.block_x * prev_global_ref->get_w() / 100);
443 int block_y_orig = lrint(config.block_y * prev_global_ref->get_h() / 100);
444 int max_block_x = (int64_t)(prev_global_ref->get_w() - block_x_orig)
445 * OVERSAMPLE * config.magnitude / 100;
446 int max_block_y = (int64_t)(prev_global_ref->get_h() - block_y_orig)
447 * OVERSAMPLE * config.magnitude / 100;
448 int min_block_x = (int64_t)-block_x_orig
449 * OVERSAMPLE * config.magnitude / 100;
450 int min_block_y = (int64_t)-block_y_orig
451 * OVERSAMPLE * config.magnitude / 100;
453 CLAMP(total_dx, min_block_x, max_block_x);
454 CLAMP(total_dy, min_block_y, max_block_y);
458 printf("MotionMain::process_global 2 total_dx=%.02f total_dy=%.02f\n",
459 (float)total_dx / OVERSAMPLE, (float)total_dy / OVERSAMPLE);
462 // If there will be 2nd pass, target will be transformed then
463 if(!config.twopass || load_ok)
465 if( config.tracking_object != MotionScan::TRACK_SINGLE && !config.rotate ) {
466 // Transfer current reference frame to previous reference frame and update
467 // counter. Must wait for rotate to compare.
468 prev_global_ref->copy_from(current_global_ref);
469 previous_frame_number = get_source_position();
472 // No 2nd pass, decide here what to do with target based on requested operation
473 int interpolation = NEAREST_NEIGHBOR;
474 float dx = 0., dy = 0.;
475 switch(config.action_type) {
476 case MotionScan::NOTHING:
477 global_target_dst->copy_from(global_target_src);
479 case MotionScan::TRACK_PIXEL:
480 interpolation = NEAREST_NEIGHBOR;
481 dx = rint((float)total_dx / OVERSAMPLE);
482 dy = rint((float)total_dy / OVERSAMPLE);
484 case MotionScan::STABILIZE_PIXEL:
485 interpolation = NEAREST_NEIGHBOR;
486 dx = -rint((float)total_dx / OVERSAMPLE);
487 dy = -rint((float)total_dy / OVERSAMPLE);
489 case MotionScan::TRACK:
490 interpolation = CUBIC_LINEAR;
491 dx = (float)total_dx / OVERSAMPLE;
492 dy = (float)total_dy / OVERSAMPLE;
494 case MotionScan::STABILIZE:
495 interpolation = CUBIC_LINEAR;
496 dx = -(float)total_dx / OVERSAMPLE;
497 dy = -(float)total_dy / OVERSAMPLE;
502 if( config.action_type != MotionScan::NOTHING ) {
504 overlayer = new OverlayFrame(PluginClient::get_project_smp() + 1);
505 global_target_dst->clear_frame();
506 overlayer->overlay(global_target_dst, global_target_src,
507 0, 0, global_target_src->get_w(), global_target_src->get_h(),
509 (float)global_target_src->get_w() + dx,
510 (float)global_target_src->get_h() + dy,
511 1, TRANSFER_REPLACE, interpolation);
516 void MotionMain::refine_global()
518 int block_x, block_y;
520 float dx = 0., dy = 0.;
522 // Use temp_frame instead of current_global_ref for refined translation search
523 allocate_temp(w, h, current_global_ref->get_color_model());
524 temp_frame->clear_frame();
528 // Here we have to rotate current_rotate_ref into temp_frame
529 // backwards because prev_global_ref and current_global_ref are interchanged
531 rotate_engine = new AffineEngine(
532 PluginClient::get_project_smp() + 1,
533 PluginClient::get_project_smp() + 1);
536 if(config.tracking_object == MotionScan::TRACK_SINGLE)
542 angle = current_angle;
545 // Pivot need not be very accurate, it is attached to the previous frame
546 // while current frame is moved and rotated
547 // Nevertheless compute it in floating point and round to int afterwards
548 tmp_x = current_rotate_ref->get_w() * config.block_x / 100;
549 tmp_y = current_rotate_ref->get_h() * config.block_y / 100;
550 if(config.tracking_object == MotionScan::TRACK_PREVIOUS)
552 // Pivot is moved along the previous frame
553 tmp_x += (double)(total_dx-current_dx) / OVERSAMPLE;
554 tmp_y += (double)(total_dy-current_dy) / OVERSAMPLE;
556 block_x = lrint (tmp_x);
557 block_y = lrint (tmp_y);
558 rotate_engine->set_in_pivot(block_x, block_y);
559 rotate_engine->set_out_pivot(block_x, block_y);
561 rotate_engine->rotate(temp_frame, current_rotate_ref, -angle);
565 // Here we have to translate current_global_ref into temp_frame
566 // backwards because prev_global_ref and current_global_ref are interchanged
568 overlayer = new OverlayFrame(PluginClient::get_project_smp() + 1);
569 if(config.tracking_object == MotionScan::TRACK_SINGLE)
571 dx = (float)total_dx / OVERSAMPLE;
572 dy = (float)total_dy / OVERSAMPLE;
576 dx = (float)current_dx / OVERSAMPLE;
577 dy = (float)current_dy / OVERSAMPLE;
580 overlayer->overlay(temp_frame,
584 current_global_ref->get_w(),
585 current_global_ref->get_h(),
588 (float)current_global_ref->get_w() - dx,
589 (float)current_global_ref->get_h() - dy,
595 // Determine additional translation, pass 2
596 // Attention, prev_global_ref and current_global_ref are interchanged
597 // Engine must have been created already by process_global()
598 engine->scan_frame(temp_frame, prev_global_ref,
599 config.global_range_w, config.global_range_h,
600 config.global_block_w, config.global_block_h,
601 config.block_x, config.block_y,
602 config.tracking_object, config.tracking_type,
603 config.action_type, config.horizontal_only,
604 config.vertical_only, get_source_position(),
605 config.global_positions, total_dx, total_dy,
606 0, 0, 2, load_ok, load_dx, load_dy);
608 // Translation correction is to be added to motion vector
609 current_dx += engine->dx_result;
610 current_dy += engine->dy_result;
611 total_dx += engine->dx_result;
612 total_dy += engine->dy_result;
614 // Refine saved results
615 if( config.tracking_type == MotionScan::SAVE ) {
616 save_dx = current_dx;
617 save_dy = current_dy;
620 // Clamp accumulation vector
621 if( config.magnitude < 100 ) {
622 int block_x_orig = lrint(config.block_x * prev_global_ref->get_w() / 100);
623 int block_y_orig = lrint(config.block_y * prev_global_ref->get_h() / 100);
624 int max_block_x = (int64_t)(prev_global_ref->get_w() - block_x_orig)
625 * OVERSAMPLE * config.magnitude / 100;
626 int max_block_y = (int64_t)(prev_global_ref->get_h() - block_y_orig)
627 * OVERSAMPLE * config.magnitude / 100;
628 int min_block_x = (int64_t)-block_x_orig
629 * OVERSAMPLE * config.magnitude / 100;
630 int min_block_y = (int64_t)-block_y_orig
631 * OVERSAMPLE * config.magnitude / 100;
633 CLAMP(total_dx, min_block_x, max_block_x);
634 CLAMP(total_dy, min_block_y, max_block_y);
638 printf("MotionMain::refine_global 2 total_dx=%.02f total_dy=%.02f\n",
639 (float)total_dx / OVERSAMPLE, (float)total_dy / OVERSAMPLE);
642 if( config.tracking_object != MotionScan::TRACK_SINGLE && !config.rotate ) {
643 // Transfer current reference frame to previous reference frame and update
644 // counter. Must wait for rotate to compare.
645 prev_global_ref->copy_from(current_global_ref);
646 previous_frame_number = get_source_position();
649 // Decide what to do with target based on requested operation
650 int interpolation = NEAREST_NEIGHBOR;
652 switch(config.action_type) {
653 case MotionScan::NOTHING:
654 global_target_dst->copy_from(global_target_src);
656 case MotionScan::TRACK_PIXEL:
657 interpolation = NEAREST_NEIGHBOR;
658 dx = rint((float)total_dx / OVERSAMPLE);
659 dy = rint((float)total_dy / OVERSAMPLE);
661 case MotionScan::STABILIZE_PIXEL:
662 interpolation = NEAREST_NEIGHBOR;
663 dx = -rint((float)total_dx / OVERSAMPLE);
664 dy = -rint((float)total_dy / OVERSAMPLE);
666 case MotionScan::TRACK:
667 interpolation = CUBIC_LINEAR;
668 dx = (float)total_dx / OVERSAMPLE;
669 dy = (float)total_dy / OVERSAMPLE;
671 case MotionScan::STABILIZE:
672 interpolation = CUBIC_LINEAR;
673 dx = -(float)total_dx / OVERSAMPLE;
674 dy = -(float)total_dy / OVERSAMPLE;
679 if( config.action_type != MotionScan::NOTHING ) {
680 // Should be already created elsewhere but try it here just for safety
682 overlayer = new OverlayFrame(PluginClient::get_project_smp() + 1);
683 global_target_dst->clear_frame();
684 overlayer->overlay(global_target_dst, global_target_src,
685 0, 0, global_target_src->get_w(), global_target_src->get_h(),
687 (float)global_target_src->get_w() + dx,
688 (float)global_target_src->get_h() + dy,
689 1, TRANSFER_REPLACE, interpolation);
695 void MotionMain::process_rotation()
697 int block_x, block_y;
700 // Here we have to translate current_global_ref into current_rotate_ref
701 // backwards because prev_rotate_ref and current_rotate_ref are interchanged.
702 // Also copy prev_global_ref into prev_rotate_ref for comparing.
703 // Convert global target destination into rotation target source.
704 if( config.global ) {
706 overlayer = new OverlayFrame(PluginClient::get_project_smp() + 1);
708 if( config.tracking_object == MotionScan::TRACK_SINGLE ) {
709 dx = (float)total_dx / OVERSAMPLE;
710 dy = (float)total_dy / OVERSAMPLE;
713 dx = (float)current_dx / OVERSAMPLE;
714 dy = (float)current_dy / OVERSAMPLE;
717 prev_rotate_ref->copy_from(prev_global_ref);
718 current_rotate_ref->clear_frame();
719 overlayer->overlay(current_rotate_ref, current_global_ref,
720 0, 0, current_global_ref->get_w(), current_global_ref->get_h(),
722 (float)current_global_ref->get_w() - dx,
723 (float)current_global_ref->get_h() - dy,
724 1, TRANSFER_REPLACE, CUBIC_LINEAR);
725 // Pivot need not be very accurate, it is attached to the previous frame
726 // while current frame is moved and rotated
727 // Nevertheless compute it in floating point and round to int afterwards
728 tmp_x = prev_rotate_ref->get_w() * config.block_x / 100;
729 tmp_y = prev_rotate_ref->get_h() * config.block_y / 100;
730 if(config.tracking_object == MotionScan::TRACK_PREVIOUS)
732 // Pivot is moved along the previous frame
733 tmp_x += (double)(total_dx-current_dx) / OVERSAMPLE;
734 tmp_y += (double)(total_dy-current_dy) / OVERSAMPLE;
736 // Use the global target output as the rotation target input
737 rotate_target_src->copy_from(global_target_dst);
738 // Transfer current reference frame to previous reference frame for global.
739 if(config.tracking_object != MotionScan::TRACK_SINGLE &&
740 (!config.twopass || load_ok))
742 prev_global_ref->copy_from(current_global_ref);
743 previous_frame_number = get_source_position();
747 // Pivot is fixed as translation switched off
748 tmp_x = prev_rotate_ref->get_w() * config.block_x / 100;
749 tmp_y = prev_rotate_ref->get_h() * config.block_y / 100;
751 block_x = lrint (tmp_x);
752 block_y = lrint (tmp_y);
754 // Get rotation, either single pass or pass 1
756 motion_rotate = new RotateScan(this,
757 get_project_smp() + 1, get_project_smp() + 1);
759 // Attention, prev_rotate_ref and current_rotate_ref are interchanged
760 current_angle = motion_rotate->
761 scan_frame(current_rotate_ref, prev_rotate_ref, block_x, block_y, config.twopass);
762 current_angle += dt_offset;
765 if( config.tracking_type == MotionScan::SAVE ) {
766 save_dt = current_angle;
769 // Add current rotation to accumulation
770 if( config.tracking_object != MotionScan::TRACK_SINGLE ) {
772 total_angle = total_angle * (100 - config.rotate_return_speed) / 100;
773 // Accumulate current rotation
774 total_angle += current_angle;
776 // Clamp rotation accumulation
777 if( config.rotate_magnitude < 90 ) {
778 CLAMP(total_angle, -config.rotate_magnitude, config.rotate_magnitude);
782 total_angle = current_angle;
786 printf("MotionMain::process_rotation total_angle=%f\n", total_angle);
789 // If there will be 2nd pass, target will be transformed then
790 if(!config.twopass || load_ok)
792 if( config.tracking_object != MotionScan::TRACK_SINGLE && !config.global ) {
793 // Transfer current reference frame to previous reference frame and update counter.
794 prev_rotate_ref->copy_from(current_rotate_ref);
795 previous_frame_number = get_source_position();
798 // No 2nd pass, calculate rotation parameters based on requested operation
799 // Use origin of global stabilize operation for pivot by default
800 // Compute it in floating point for accuracy and round to int afterwards
801 tmp_x = rotate_target_src->get_w() * config.block_x / 100;
802 tmp_y = rotate_target_src->get_h() * config.block_y / 100;
805 switch(config.action_type) {
806 case MotionScan::NOTHING:
807 rotate_target_dst->copy_from(rotate_target_src);
809 case MotionScan::TRACK:
810 case MotionScan::TRACK_PIXEL:
813 // Use destination of global tracking for pivot.
814 tmp_x += (double)total_dx / OVERSAMPLE;
815 tmp_y += (double)total_dy / OVERSAMPLE;
819 case MotionScan::STABILIZE:
820 case MotionScan::STABILIZE_PIXEL:
821 angle = -total_angle;
824 block_x = lrint (tmp_x);
825 block_y = lrint (tmp_y);
827 if( config.action_type != MotionScan::NOTHING ) {
829 rotate_engine = new AffineEngine(
830 PluginClient::get_project_smp() + 1,
831 PluginClient::get_project_smp() + 1);
833 rotate_target_dst->clear_frame();
835 rotate_engine->set_in_pivot(block_x, block_y);
836 rotate_engine->set_out_pivot(block_x, block_y);
838 rotate_engine->rotate(rotate_target_dst, rotate_target_src, angle);
843 void MotionMain::refine_rotation()
845 int block_x, block_y;
849 // Use temp_frame instead of current_rotate_ref for refined rotation search
850 allocate_temp(w, h, current_rotate_ref->get_color_model());
851 temp_frame->clear_frame();
853 if( config.global ) {
854 // Here we have to translate current_global_ref into current_rotate_ref
855 // backwards because prev_rotate_ref and current_rotate_ref are interchanged
856 // prev_rotate_ref must have been copied already by process_rotation()
858 overlayer = new OverlayFrame(PluginClient::get_project_smp() + 1);
860 if( config.tracking_object == MotionScan::TRACK_SINGLE ) {
861 dx = (float)total_dx / OVERSAMPLE;
862 dy = (float)total_dy / OVERSAMPLE;
865 dx = (float)current_dx / OVERSAMPLE;
866 dy = (float)current_dy / OVERSAMPLE;
869 current_rotate_ref->clear_frame();
870 overlayer->overlay(current_rotate_ref, current_global_ref,
871 0, 0, current_global_ref->get_w(), current_global_ref->get_h(),
873 (float)current_global_ref->get_w() - dx,
874 (float)current_global_ref->get_h() - dy,
875 1, TRANSFER_REPLACE, CUBIC_LINEAR);
877 // Pivot need not be very accurate, it is attached to the previous frame
878 // while current frame is moved and rotated
879 // Nevertheless compute it in floating point and round to int afterwards
880 tmp_x = current_rotate_ref->get_w() * config.block_x / 100;
881 tmp_y = current_rotate_ref->get_h() * config.block_y / 100;
882 if(config.tracking_object == MotionScan::TRACK_PREVIOUS)
884 // Pivot is moved along the previous frame
885 tmp_x += (double)(total_dx-current_dx) / OVERSAMPLE;
886 tmp_y += (double)(total_dy-current_dy) / OVERSAMPLE;
890 // Pivot is fixed as translation switched off
891 tmp_x = current_rotate_ref->get_w() * config.block_x / 100;
892 tmp_y = current_rotate_ref->get_h() * config.block_y / 100;
894 block_x = lrint (tmp_x);
895 block_y = lrint (tmp_y);
897 // Now rotate current_rotate_ref into temp_frame
898 // backwards because prev_global_ref and current_global_ref are interchanged
900 rotate_engine = new AffineEngine(
901 PluginClient::get_project_smp() + 1,
902 PluginClient::get_project_smp() + 1);
904 if(config.tracking_object == MotionScan::TRACK_SINGLE)
910 angle = current_angle;
913 rotate_engine->set_in_pivot(block_x, block_y);
914 rotate_engine->set_out_pivot(block_x, block_y);
916 rotate_engine->rotate(temp_frame, current_rotate_ref, -angle);
918 // Determine additional rotation, pass 2
919 // Attention, prev_rotate_ref and current_rotate_ref are interchanged
920 // Engine must have been created already by process_rotation()
921 angle = motion_rotate->
922 scan_frame(temp_frame, prev_rotate_ref, block_x, block_y, 2);
924 // Rotation correction is to be added to accumulated angle
925 current_angle += angle;
926 total_angle += angle;
928 // Refine saved result
929 if( config.tracking_type == MotionScan::SAVE ) {
930 save_dt = current_angle;
933 // Clamp rotation accumulation
934 if( config.rotate_magnitude < 90 ) {
935 CLAMP(total_angle, -config.rotate_magnitude, config.rotate_magnitude);
939 printf("MotionMain::process_rotation total_angle=%f\n", total_angle);
942 if(config.tracking_object != MotionScan::TRACK_SINGLE)
944 // Transfer current reference frame to previous reference frame and update
948 prev_global_ref->copy_from(current_global_ref);
952 prev_rotate_ref->copy_from(current_rotate_ref);
954 previous_frame_number = get_source_position();
957 // Calculate rotation parameters based on requested operation
958 // Use origin of global stabilize operation for pivot by default
959 // Compute it in floating point for accuracy and round to int afterwards
960 tmp_x = rotate_target_src->get_w() * config.block_x / 100;
961 tmp_y = rotate_target_src->get_h() * config.block_y / 100;
963 switch(config.action_type) {
964 case MotionScan::NOTHING:
965 rotate_target_dst->copy_from(rotate_target_src);
967 case MotionScan::TRACK:
968 case MotionScan::TRACK_PIXEL:
971 // Use destination of global tracking for pivot.
972 tmp_x += (double)total_dx / OVERSAMPLE;
973 tmp_y += (double)total_dy / OVERSAMPLE;
977 case MotionScan::STABILIZE:
978 case MotionScan::STABILIZE_PIXEL:
979 angle = -total_angle;
982 block_x = lrint (tmp_x);
983 block_y = lrint (tmp_y);
985 if( config.action_type != MotionScan::NOTHING ) {
986 // Should be already created elsewhere but try it here just for safety
988 rotate_engine = new AffineEngine(
989 PluginClient::get_project_smp() + 1,
990 PluginClient::get_project_smp() + 1);
992 rotate_target_dst->clear_frame();
994 rotate_engine->set_in_pivot(block_x, block_y);
995 rotate_engine->set_out_pivot(block_x, block_y);
997 rotate_engine->rotate(rotate_target_dst, rotate_target_src, angle);
1002 int MotionMain::process_buffer(VFrame **frame, int64_t start_position, double frame_rate)
1004 int need_reconfigure = load_configuration();
1005 int color_model = frame[0]->get_color_model();
1006 w = frame[0]->get_w();
1007 h = frame[0]->get_h();
1010 printf("MotionMain::process_buffer %d start_position=%jd\n", __LINE__, start_position);
1013 // Calculate the source and destination pointers for each of the operations.
1014 // Get the layer to track motion in.
1015 // Get the layer to apply motion in.
1016 reference_layer = config.bottom_is_master ?
1017 PluginClient::total_in_buffers - 1 : 0;
1018 target_layer = config.bottom_is_master ?
1019 0 : PluginClient::total_in_buffers - 1;
1021 output_frame = frame[target_layer];
1022 // Get the position of previous reference frame.
1023 int64_t actual_previous_number;
1024 // Skip if match frame not available
1025 int skip_current = 0;
1027 if( config.tracking_object == MotionScan::TRACK_SINGLE ) {
1028 actual_previous_number = config.track_frame;
1029 if( get_direction() == PLAY_REVERSE )
1030 actual_previous_number++;
1031 if( actual_previous_number == start_position )
1035 actual_previous_number = start_position;
1036 if( get_direction() == PLAY_FORWARD ) {
1037 actual_previous_number--;
1038 if( actual_previous_number < get_source_start() )
1041 KeyFrame *keyframe = get_prev_keyframe(start_position, 1);
1042 if( keyframe->position > 0 &&
1043 actual_previous_number < keyframe->position )
1048 actual_previous_number++;
1049 if( actual_previous_number >= get_source_start() + get_total_len() )
1052 KeyFrame *keyframe = get_next_keyframe(start_position, 1);
1053 if( keyframe->position > 0 &&
1054 actual_previous_number >= keyframe->position )
1058 // Only count motion since last keyframe
1061 if( !config.global && !config.rotate )
1064 //printf("process_realtime: %jd %d %jd %jd\n", start_position,
1065 // skip_current, previous_frame_number, actual_previous_number);
1066 if( ((config.tracking_type != MotionScan::LOAD &&
1067 config.tracking_type != MotionScan::SAVE) && cache_fp) ||
1068 ((config.tracking_type == MotionScan::LOAD ||
1069 config.tracking_type == MotionScan::SAVE) && !cache_fp) ||
1070 !cache_file[0] || (active_fp && active_key > start_position) )
1073 // Load match frame and reset vectors
1074 int need_reload = !skip_current &&
1075 (previous_frame_number != actual_previous_number ||
1078 total_dx = total_dy = 0; total_angle = 0;
1079 previous_frame_number = actual_previous_number;
1082 if( skip_current ) {
1083 total_dx = total_dy = 0;
1084 current_dx = current_dy = 0;
1085 total_angle = current_angle = 0;
1088 // Get the global pointers. Here we walk through the sequence of events.
1089 if( config.global ) {
1090 // Assume global only. Global reads previous frame and compares
1091 // with current frame to get the current translation.
1092 // The center of the search area is fixed in compensate mode or
1093 // the user value + the accumulation vector in track mode.
1094 if( !prev_global_ref )
1095 prev_global_ref = new VFrame(w, h, color_model, 0);
1096 if( !current_global_ref )
1097 current_global_ref = new VFrame(w, h, color_model, 0);
1099 // Global loads the current target frame into the src and
1100 // writes it to the dst frame with desired translation.
1101 if( !global_target_src )
1102 global_target_src = new VFrame(w, h, color_model, 0);
1103 if( !global_target_dst )
1104 global_target_dst = new VFrame(w, h, color_model, 0);
1106 // Load the global frames
1108 read_frame(prev_global_ref, reference_layer,
1109 previous_frame_number, frame_rate, 0);
1112 read_frame(current_global_ref, reference_layer,
1113 start_position, frame_rate, 0);
1114 read_frame(global_target_src, target_layer,
1115 start_position, frame_rate, 0);
1117 // Global followed by rotate
1118 if( config.rotate ) {
1119 // Must translate the previous global reference by the current global
1120 // accumulation vector to match the current global reference.
1121 // The center of the search area is always the user value + the accumulation
1123 if( !prev_rotate_ref )
1124 prev_rotate_ref = new VFrame(w, h, color_model, 0);
1125 // The current global reference is the current rotation reference.
1126 if( !current_rotate_ref )
1127 current_rotate_ref = new VFrame(w, h, color_model, 0);
1128 current_rotate_ref->copy_from(current_global_ref);
1130 // The global target destination is copied to the rotation target source
1131 // then written to the rotation output with rotation.
1132 // The pivot for the rotation is the center of the search area
1133 // if we're tracking.
1134 // The pivot is fixed to the user position if we're compensating.
1135 if( !rotate_target_src )
1136 rotate_target_src = new VFrame(w, h, color_model, 0);
1137 if( !rotate_target_dst )
1138 rotate_target_dst = new VFrame(w, h, color_model, 0);
1142 else if( config.rotate ) {
1143 // Rotation reads the previous reference frame and compares it with current
1145 if( !prev_rotate_ref )
1146 prev_rotate_ref = new VFrame(w, h, color_model, 0);
1147 if( !current_rotate_ref )
1148 current_rotate_ref = new VFrame(w, h, color_model, 0);
1150 // Rotation loads target frame to temporary, rotates it, and writes it to the
1151 // target frame. The pivot is always fixed.
1152 if( !rotate_target_src )
1153 rotate_target_src = new VFrame(w, h, color_model, 0);
1154 if( !rotate_target_dst )
1155 rotate_target_dst = new VFrame(w, h, color_model, 0);
1158 // Load the rotate frames
1160 read_frame(prev_rotate_ref, reference_layer,
1161 previous_frame_number, frame_rate, 0);
1163 read_frame(current_rotate_ref, reference_layer,
1164 start_position, frame_rate, 0);
1165 read_frame(rotate_target_src, target_layer,
1166 start_position, frame_rate, 0);
1169 if( config.tracking_type == MotionScan::LOAD ) {
1170 if( config.addtrackedframeoffset ) {
1171 if( config.track_frame != tracking_frame ) {
1172 tracking_frame = config.track_frame;
1173 int64_t no; int dx, dy; float dt;
1174 if( !get_cache_line(tracking_frame) &&
1175 sscanf(cache_line, "%jd %d %d %f", &no, &dx, &dy, &dt) == 4 ) {
1176 dx_offset += dx; dy_offset += dy;
1180 eprintf("no offset data frame %jd\n", tracking_frame);
1189 tracking_frame = -1;
1197 tracking_frame = -1;
1200 if( !skip_current ) {
1202 if( config.tracking_type == MotionScan::LOAD ||
1203 config.tracking_type == MotionScan::SAVE ) {
1204 int64_t no; int dx, dy; float dt;
1205 int64_t frame_no = get_source_position();
1206 // Load result from disk
1207 if( !get_cache_line(frame_no) &&
1208 sscanf(cache_line, "%jd %d %d %f", &no, &dx, &dy, &dt) == 4 ) {
1209 load_ok = 1; load_dx = dx; load_dy = dy; load_dt = dt;
1213 printf("MotionMain::process_buffer: no tracking data frame %jd\n", frame_no);
1218 // Get position change from previous frame to current frame
1221 // Get rotation change from previous frame to current frame
1224 //frame[target_layer]->copy_from(prev_rotate_ref);
1225 //frame[target_layer]->copy_from(current_rotate_ref);
1226 if(config.twopass && !load_ok)
1227 // Second pass not needed if coords loaded from cache
1229 if(config.global) refine_global();
1230 if(config.rotate) refine_rotation();
1233 // write results to disk
1234 if( config.tracking_type == MotionScan::SAVE ) {
1235 char line[BCSTRLEN];
1236 int64_t frame_no = get_source_position();
1237 snprintf(line, sizeof(line), "%jd %d %d %f\n",
1238 frame_no, save_dx, save_dy, save_dt);
1239 put_cache_line(line);
1241 // Transfer the relevant target frame to the output
1242 if( config.rotate ) {
1243 frame[target_layer]->copy_from(rotate_target_dst);
1246 frame[target_layer]->copy_from(global_target_dst);
1249 // Read the target destination directly
1251 read_frame(frame[target_layer],
1252 target_layer, start_position, frame_rate, 0);
1255 if( config.draw_vectors ) {
1256 draw_vectors(frame[target_layer]);
1260 printf("MotionMain::process_buffer %d\n", __LINE__);
1267 void MotionMain::draw_vectors(VFrame *frame)
1269 int w = frame->get_w(), h = frame->get_h();
1270 int global_x1, global_y1, global_x2, global_y2;
1271 int block_x, block_y, block_w, block_h;
1272 int block_x1, block_y1, block_x2, block_y2;
1273 int block_x3, block_y3, block_x4, block_y4;
1274 int search_x1, search_y1, search_x2, search_y2;
1275 int search_w, search_h;
1276 double tmp_x1, tmp_y1;
1277 double tmp_x2, tmp_y2;
1280 if( config.global ) {
1281 // Get vector as double and round the result for more regular behavior
1282 if( config.tracking_object == MotionScan::TRACK_SINGLE ) {
1283 // Start of vector is center of original block.
1284 // Length of vector is total accumulation.
1285 tmp_x1 = config.block_x * w / 100;
1286 tmp_y1 = config.block_y * h / 100;
1287 tmp_x2 = tmp_x1 + (double)total_dx / OVERSAMPLE;
1288 tmp_y2 = tmp_y1 + (double)total_dy / OVERSAMPLE;
1290 else if( config.tracking_object == MotionScan::PREVIOUS_SAME_BLOCK ) {
1291 // Start of vector is center of original block.
1292 // Length of vector is current change.
1293 tmp_x1 = config.block_x * w / 100;
1294 tmp_y1 = config.block_y * h / 100;
1295 tmp_x2 = tmp_x1 + (double)current_dx / OVERSAMPLE;
1296 tmp_y2 = tmp_y1 + (double)current_dy / OVERSAMPLE;
1299 // Start of vector is center of current block.
1300 // Length of vector is current change.
1301 tmp_x1 = config.block_x * w / 100 +
1302 (double)(total_dx - current_dx) / OVERSAMPLE;
1303 tmp_y1 = config.block_y * h / 100 +
1304 (double)(total_dy - current_dy) / OVERSAMPLE;
1305 tmp_x2 = config.block_x * w / 100 +
1306 (double)total_dx / OVERSAMPLE;
1307 tmp_y2 = config.block_y * h / 100 +
1308 (double)total_dy / OVERSAMPLE;
1310 global_x1 = lrint (tmp_x1);
1311 global_y1 = lrint (tmp_y1);
1312 global_x2 = lrint (tmp_x2);
1313 global_y2 = lrint (tmp_y2);
1314 //printf("MotionMain::draw_vectors %d %d %d %d %d %d\n", total_dx, total_dy, global_x1, global_y1, global_x2, global_y2);
1316 block_x = global_x1;
1317 block_y = global_y1;
1318 if((config.tracking_object == MotionScan::TRACK_SINGLE ||
1319 config.tracking_object == MotionScan::TRACK_PREVIOUS) &&
1322 // Show block at endpoint of motion if no rotation shown
1323 block_x = global_x2;
1324 block_y = global_y2;
1326 block_w = config.global_block_w * w / 100;
1327 block_h = config.global_block_h * h / 100;
1328 block_x1 = block_x - block_w / 2;
1329 block_y1 = block_y - block_h / 2;
1330 block_x2 = block_x + block_w / 2;
1331 block_y2 = block_y + block_h / 2;
1332 search_w = config.global_range_w * w / 100;
1333 search_h = config.global_range_h * h / 100;
1334 search_x1 = block_x1 - search_w / 2;
1335 search_y1 = block_y1 - search_h / 2;
1336 search_x2 = block_x2 + search_w / 2;
1337 search_y2 = block_y2 + search_h / 2;
1339 //printf("MotionMain::draw_vectors %d %d %d %d %d %d %d %d %d %d %d %d\n",
1340 // global_x1, global_y1, block_w, block_h, block_x1, block_y1,
1341 // block_x2, block_y2, search_x1, search_y1, search_x2, search_y2);
1343 MotionScan::clamp_scan(w, h,
1344 &block_x1, &block_y1, &block_x2, &block_y2,
1345 &search_x1, &search_y1, &search_x2, &search_y2, 1);
1348 draw_arrow(frame, global_x1, global_y1, global_x2, global_y2);
1351 draw_line(frame, block_x1, block_y1, block_x2, block_y1);
1352 draw_line(frame, block_x2, block_y1, block_x2, block_y2);
1353 draw_line(frame, block_x2, block_y2, block_x1, block_y2);
1354 draw_line(frame, block_x1, block_y2, block_x1, block_y1);
1357 draw_line(frame, search_x1, search_y1, search_x2, search_y1);
1358 draw_line(frame, search_x2, search_y1, search_x2, search_y2);
1359 draw_line(frame, search_x2, search_y2, search_x1, search_y2);
1360 draw_line(frame, search_x1, search_y2, search_x1, search_y1);
1362 // Block should be endpoint of motion
1363 if( config.rotate ) {
1364 block_x = global_x2;
1365 block_y = global_y2;
1369 block_x = lrint (config.block_x * w / 100);
1370 block_y = lrint (config.block_y * h / 100);
1373 block_w = config.global_block_w * w / 100;
1374 block_h = config.global_block_h * h / 100;
1375 if( config.rotate ) {
1376 float angle = total_angle * 2 * M_PI / 360;
1377 double base_angle1 = atan((float)block_h / block_w);
1378 double base_angle2 = atan((float)block_w / block_h);
1379 double target_angle1 = base_angle1 + angle;
1380 double target_angle2 = base_angle2 + angle;
1381 double radius = sqrt(block_w * block_w + block_h * block_h) / 2;
1382 block_x1 = lrint(block_x - cos(target_angle1) * radius);
1383 block_y1 = lrint(block_y - sin(target_angle1) * radius);
1384 block_x2 = lrint(block_x + sin(target_angle2) * radius);
1385 block_y2 = lrint(block_y - cos(target_angle2) * radius);
1386 block_x3 = lrint(block_x - sin(target_angle2) * radius);
1387 block_y3 = lrint(block_y + cos(target_angle2) * radius);
1388 block_x4 = lrint(block_x + cos(target_angle1) * radius);
1389 block_y4 = lrint(block_y + sin(target_angle1) * radius);
1391 draw_line(frame, block_x1, block_y1, block_x2, block_y2);
1392 draw_line(frame, block_x2, block_y2, block_x4, block_y4);
1393 draw_line(frame, block_x4, block_y4, block_x3, block_y3);
1394 draw_line(frame, block_x3, block_y3, block_x1, block_y1);
1398 if( !config.global ) {
1399 draw_line(frame, block_x, block_y - 5, block_x, block_y + 6);
1400 draw_line(frame, block_x - 5, block_y, block_x + 6, block_y);
1405 MotionVVFrame::MotionVVFrame(VFrame *vfrm, int n)
1406 : VFrame(vfrm->get_data(), -1, vfrm->get_y()-vfrm->get_data(),
1407 vfrm->get_u()-vfrm->get_data(), vfrm->get_v()-vfrm->get_data(),
1408 vfrm->get_w(), vfrm->get_h(), vfrm->get_color_model(),
1409 vfrm->get_bytes_per_line())
1414 int MotionVVFrame::draw_pixel(int x, int y)
1416 VFrame::draw_pixel(x+0, y+0);
1417 for( int i=1; i<n; ++i ) {
1418 VFrame::draw_pixel(x-i, y-i);
1419 VFrame::draw_pixel(x+i, y+i);
1424 void MotionMain::draw_line(VFrame *frame, int x1, int y1, int x2, int y2)
1426 int iw = frame->get_w(), ih = frame->get_h();
1427 int mx = iw > ih ? iw : ih;
1429 MotionVVFrame vfrm(frame, n);
1430 vfrm.set_pixel_color(WHITE);
1431 int m = 2; while( m < n ) m <<= 1;
1432 vfrm.set_stiple(2*m);
1433 vfrm.draw_line(x1,y1, x2,y2);
1436 #define ARROW_SIZE 10
1437 void MotionMain::draw_arrow(VFrame *frame, int x1, int y1, int x2, int y2)
1439 double angle = atan2((double)(y2 - y1), (double)(x2 - x1));
1440 double angle1 = angle + (float)145 / 360 * 2 * M_PI;
1441 double angle2 = angle - (float)145 / 360 * 2 * M_PI;
1442 int x3 = x2 + (int)(ARROW_SIZE * cos(angle1));
1443 int y3 = y2 + (int)(ARROW_SIZE * sin(angle1));
1444 int x4 = x2 + (int)(ARROW_SIZE * cos(angle2));
1445 int y4 = y2 + (int)(ARROW_SIZE * sin(angle2));
1448 draw_line(frame, x1, y1, x2, y2);
1449 // draw_line(frame, x1, y1 + 1, x2, y2 + 1);
1452 if( abs(y2 - y1) || abs(x2 - x1) ) draw_line(frame, x2, y2, x3, y3);
1453 // draw_line(frame, x2, y2 + 1, x3, y3 + 1);
1455 if( abs(y2 - y1) || abs(x2 - x1) ) draw_line(frame, x2, y2, x4, y4);
1456 // draw_line(frame, x2, y2 + 1, x4, y4 + 1);
1459 int MotionMain::open_cache_file()
1461 if( cache_fp ) return 0;
1462 if( !cache_file[0] ) return 1;
1463 if( !(cache_fp = fopen(cache_file, "r")) ) return 1;
1467 void MotionMain::close_cache_file()
1469 if( !cache_fp ) return;
1471 cache_fp = 0; cache_key = -1; tracking_frame = -1;
1474 int MotionMain::load_cache_line()
1477 if( open_cache_file() ) return 1;
1478 if( !fgets(cache_line, sizeof(cache_line), cache_fp) ) return 1;
1479 cache_key = strtol(cache_line, 0, 0);
1483 int MotionMain::get_cache_line(int64_t key)
1485 if( cache_key == key ) return 0;
1486 if( open_cache_file() ) return 1;
1487 if( cache_key >= 0 && key > cache_key ) {
1488 if( load_cache_line() ) return 1;
1489 if( cache_key == key ) return 0;
1490 if( cache_key > key ) return 1;
1492 // binary search file
1493 fseek(cache_fp, 0, SEEK_END);
1494 int64_t l = -1, r = ftell(cache_fp);
1495 while( (r - l) > 1 ) {
1496 int64_t m = (l + r) / 2;
1497 fseek(cache_fp, m, SEEK_SET);
1498 if( m > 0 && !fgets(cache_line, sizeof(cache_line), cache_fp) )
1500 if( !load_cache_line() ) {
1501 if( cache_key == key )
1503 if( cache_key < key ) { l = m; continue; }
1510 int MotionMain::locate_cache_line(int64_t key)
1513 if( key < 0 || !(ret=get_cache_line(key)) ||
1514 ( cache_key >= 0 && cache_key < key ) )
1515 ret = load_cache_line();
1519 int MotionMain::put_cache_line(const char *line)
1521 int64_t key = strtol(line, 0, 0);
1522 if( key == active_key ) return 1;
1525 snprintf(cache_file, sizeof(cache_file), "%s.bak", config.tracking_file);
1526 ::remove(cache_file);
1527 ::rename(config.tracking_file, cache_file);
1528 if( !(active_fp = fopen(config.tracking_file, "w")) ) {
1529 perror(config.tracking_file);
1530 fprintf(stderr, "err writing key %jd\n", key);
1536 if( active_key < key ) {
1537 locate_cache_line(active_key);
1538 while( cache_key >= 0 && key >= cache_key ) {
1539 if( key > cache_key )
1540 fputs(cache_line, active_fp);
1546 fputs(line, active_fp);
1551 void MotionMain::reset_cache_file()
1554 locate_cache_line(active_key);
1555 while( cache_key >= 0 ) {
1556 fputs(cache_line, active_fp);
1559 close_cache_file(); ::remove(cache_file);
1560 fclose(active_fp); active_fp = 0; active_key = -1;
1564 strcpy(cache_file, config.tracking_file);
1565 if (!cache_file[0]) strcpy(cache_file, TRACKING_FILE);
1569 RotateScanPackage::RotateScanPackage()
1573 RotateScanUnit::RotateScanUnit(RotateScan *server, MotionMain *plugin)
1574 : LoadClient(server)
1576 this->server = server;
1577 this->plugin = plugin;
1582 RotateScanUnit::~RotateScanUnit()
1588 void RotateScanUnit::process_package(LoadPackage *package)
1590 if( server->skip ) return;
1591 RotateScanPackage *pkg = (RotateScanPackage*)package;
1593 if( (pkg->difference = server->get_cache(pkg->angle)) < 0 ) {
1594 //printf("RotateScanUnit::process_package %d\n", __LINE__);
1595 int color_model = server->previous_frame->get_color_model();
1596 int pixel_size = BC_CModels::calculate_pixelsize(color_model);
1597 int row_bytes = server->previous_frame->get_bytes_per_line();
1598 float angle = pkg->angle;
1599 // Ensure a tiny displacement if angle is nearly exact zero
1600 // As angle is in degree and MIN_ANGLE is in radian,
1601 // displacement of 1/57th of the smallest possible angle can be discarded
1602 // This trick is needed to trigger interpolation
1603 if (fabs (angle) < MIN_ANGLE) angle = MIN_ANGLE;
1606 rotater = new AffineEngine(1, 1);
1609 server->previous_frame->get_w(),
1610 server->previous_frame->get_h(),
1612 //printf("RotateScanUnit::process_package %d\n", __LINE__);
1615 // Rotate original block size
1616 // rotater->set_viewport(server->block_x1, server->block_y1,
1617 // server->block_x2 - server->block_x1, server->block_y2 - server->block_y1);
1618 rotater->set_in_viewport(server->block_x1, server->block_y1,
1619 server->block_x2 - server->block_x1, server->block_y2 - server->block_y1);
1620 rotater->set_out_viewport(server->block_x1, server->block_y1,
1621 server->block_x2 - server->block_x1, server->block_y2 - server->block_y1);
1622 // rotater->set_pivot(server->block_x, server->block_y);
1623 rotater->set_in_pivot(server->block_x, server->block_y);
1624 rotater->set_out_pivot(server->block_x, server->block_y);
1625 //printf("RotateScanUnit::process_package %d\n", __LINE__);
1626 rotater->rotate(temp, server->previous_frame, angle);
1628 // Scan reduced block size
1629 //plugin->output_frame->copy_from(server->current_frame);
1630 //plugin->output_frame->copy_from(temp);
1631 //printf("RotateScanUnit::process_package %d %d %d %d %d\n",
1632 // __LINE__, server->scan_x, server->scan_y, server->scan_w, server->scan_h);
1633 // Clamp coordinates
1634 int x1 = server->scan_x;
1635 int y1 = server->scan_y;
1636 int x2 = x1 + server->scan_w;
1637 int y2 = y1 + server->scan_h;
1638 x2 = MIN(temp->get_w(), x2);
1639 y2 = MIN(temp->get_h(), y2);
1640 x2 = MIN(server->current_frame->get_w(), x2);
1641 y2 = MIN(server->current_frame->get_h(), y2);
1642 x1 = MAX(0, x1); y1 = MAX(0, y1);
1644 if( x2 > x1 && y2 > y1 ) {
1645 pkg->difference = MotionScan::abs_diff(
1646 temp->get_rows()[y1] + x1 * pixel_size,
1647 server->current_frame->get_rows()[y1] + x1 * pixel_size,
1648 row_bytes, x2 - x1, y2 - y1, color_model);
1649 //printf("RotateScanUnit::process_package %d\n", __LINE__);
1650 server->put_cache(pkg->angle, pkg->difference);
1651 // Dumping rotated frame for debugging
1652 // temp->write_ppm(temp, "/tmp/a%06ld-a%f.ppm",
1653 // plugin->get_source_position(),
1655 // if (pkg->angle == 0)
1656 // temp->write_ppm(server->previous_frame,
1657 // "/tmp/a%06ld-t.ppm",
1658 // plugin->get_source_position());
1661 VFrame png(x2-x1, y2-y1, BC_RGB888, -1);
1662 png.transfer_from(temp, 0, x1, y1, x2-x1, y2-y1);
1664 sprintf(fn,"%s%f.png","/tmp/temp",pkg->angle); png.write_png(fn);
1665 png.transfer_from(server->current_frame, 0, x1, y1, x2-x1, y2-y1);
1666 sprintf(fn,"%s%f.png","/tmp/curr",pkg->angle); png.write_png(fn);
1667 printf("RotateScanUnit::process_package 10 x=%d y=%d w=%d h=%d block_x=%d block_y=%d angle=%f scan_w=%d scan_h=%d diff=%jd\n",
1668 server->block_x1, server->block_y1, server->block_x2 - server->block_x1, server->block_y2 - server->block_y1,
1669 server->block_x, server->block_y, pkg->angle, server->scan_w, server->scan_h, pkg->difference);
1675 RotateScan::RotateScan(MotionMain *plugin,
1678 : LoadServer( //1, 1)
1679 total_clients, total_packages)
1681 this->plugin = plugin;
1682 cache_lock = new Mutex("RotateScan::cache_lock");
1686 RotateScan::~RotateScan()
1691 void RotateScan::init_packages()
1693 for( int i = 0; i < get_total_packages(); i++ ) {
1694 RotateScanPackage *pkg = (RotateScanPackage*)get_package(i);
1695 pkg->angle = scan_angle1 +
1696 i * (scan_angle2 - scan_angle1) / total_steps;
1700 LoadClient* RotateScan::new_client()
1702 return new RotateScanUnit(this, plugin);
1705 LoadPackage* RotateScan::new_package()
1707 return new RotateScanPackage;
1711 float RotateScan::scan_frame(VFrame *previous_frame, VFrame *current_frame,
1712 int block_x, int block_y, int passno)
1714 // Attention, process_buffer feeds previous_frame and current_frame interchanged
1715 // Preinitialize sane rotation results
1717 this->block_x = block_x;
1718 this->block_y = block_y;
1720 // passno == 0: single pass tracking
1721 // passno == 1: 1st pass of two-pass tracking (reduce accuracy)
1722 // passno == 2: 2nd pass of two-pass tracking (reduce angle range)
1723 // Save may be needed for 2nd pass
1724 // float result_saved = 0;
1727 // result_saved needed for some debug printing only
1728 // result_saved = result;
1733 result = plugin->config.rotation_center;
1736 //printf("RotateScan::scan_frame %d frame=%ld passno=%d\n", __LINE__, plugin->get_source_position(), passno);
1737 switch(plugin->config.tracking_type) {
1738 case MotionScan::NO_CALCULATE:
1739 result = plugin->config.rotation_center;
1740 if (passno == 2) result = 0;
1744 case MotionScan::LOAD:
1745 case MotionScan::SAVE:
1746 if( plugin->load_ok ) {
1747 result = plugin->load_dt;
1748 if (passno == 2) result = 0;
1753 // Scan from scratch with sane rotation results
1755 result = plugin->config.rotation_center;
1756 if (passno == 2) result = 0;
1761 this->previous_frame = previous_frame;
1762 this->current_frame = current_frame;
1763 int w = current_frame->get_w();
1764 int h = current_frame->get_h();
1765 int block_w = w * plugin->config.global_block_w / 100;
1766 int block_h = h * plugin->config.global_block_h / 100;
1768 if( this->block_x - block_w / 2 < 0 ) block_w = this->block_x * 2;
1769 if( this->block_y - block_h / 2 < 0 ) block_h = this->block_y * 2;
1770 if( this->block_x + block_w / 2 > w ) block_w = (w - this->block_x) * 2;
1771 if( this->block_y + block_h / 2 > h ) block_h = (h - this->block_y) * 2;
1773 block_x1 = this->block_x - block_w / 2;
1774 block_x2 = this->block_x + block_w / 2;
1775 block_y1 = this->block_y - block_h / 2;
1776 block_y2 = this->block_y + block_h / 2;
1778 // Calculate the maximum area available to scan after rotation.
1779 // Must be calculated from the starting range because of cache.
1780 // Get coords of rectangle after rotation.
1781 double center_x = this->block_x;
1782 double center_y = this->block_y;
1783 double max_angle = plugin->config.rotation_range;
1784 double base_angle1 = atan((float)block_h / block_w);
1785 double base_angle2 = atan((float)block_w / block_h);
1786 double target_angle1 = base_angle1 + max_angle * 2 * M_PI / 360;
1787 double target_angle2 = base_angle2 + max_angle * 2 * M_PI / 360;
1788 double radius = sqrt(block_w * block_w + block_h * block_h) / 2;
1789 double x1 = center_x - cos(target_angle1) * radius;
1790 double y1 = center_y - sin(target_angle1) * radius;
1791 double x2 = center_x + sin(target_angle2) * radius;
1792 double y2 = center_y - cos(target_angle2) * radius;
1793 double x3 = center_x - sin(target_angle2) * radius;
1794 double y3 = center_y + cos(target_angle2) * radius;
1796 // Track top edge to find greatest area.
1797 double max_area1 = 0;
1798 //double max_x1 = 0;
1800 for( double x = x1; x < x2; x++ ) {
1801 double y = y1 + (y2 - y1) * (x - x1) / (x2 - x1);
1802 if( x >= center_x && x < block_x2 && y >= block_y1 && y < center_y ) {
1803 double area = fabs(x - center_x) * fabs(y - center_y);
1804 if( area > max_area1 ) {
1812 // Track left edge to find greatest area.
1813 double max_area2 = 0;
1815 //double max_y2 = 0;
1816 for( double y = y1; y < y3; y++ ) {
1817 double x = x1 + (x3 - x1) * (y - y1) / (y3 - y1);
1818 if( x >= block_x1 && x < center_x && y >= block_y1 && y < center_y ) {
1819 double area = fabs(x - center_x) * fabs(y - center_y);
1820 if( area > max_area2 ) {
1828 double max_x, max_y;
1832 // Get reduced scan coords
1833 scan_w = (int)(fabs(max_x - center_x) * 2);
1834 scan_h = (int)(fabs(max_y - center_y) * 2);
1835 scan_x = (int)(center_x - scan_w / 2);
1836 scan_y = (int)(center_y - scan_h / 2);
1837 // printf("RotateScan::scan_frame center=%d,%d scan=%d,%d %dx%d\n",
1838 // this->block_x, this->block_y, scan_x, scan_y, scan_w, scan_h);
1839 // printf(" angle_range=%f block= %d,%d,%d,%d\n", max_angle, block_x1, block_y1, block_x2, block_y2);
1841 // Determine min angle from size of block
1842 double angle1 = atan((double)block_h / block_w);
1843 double angle2 = atan((double)(block_h - 1) / (block_w + 1));
1844 // Attention we get min_angle and MIN_ANGLE in radian, but elsewhere use degree
1845 double min_angle = fabs(angle2 - angle1) / OVERSAMPLE;
1846 min_angle = MAX(min_angle, MIN_ANGLE);
1847 // Convert min_angle to degree for convenience
1848 min_angle *= 180 / M_PI;
1850 //printf("RotateScan::scan_frame %d min_angle=%f\n", __LINE__, min_angle);
1852 cache.remove_all_objects();
1856 if( previous_frame->data_matches(current_frame) ) {
1857 //printf("RotateScan::scan_frame: frames match. Skipping.\n");
1858 result = plugin->config.rotation_center;
1859 if (passno == 2) result = 0;
1865 // Initial search range
1866 float angle_range = max_angle;
1867 result = plugin->config.rotation_center;
1868 if (passno == 2) result = 0;
1872 // Evtl stop search earlier for 1st pass to gain speed
1873 if (angle_range > 16 && min_angle < 1) min_angle = 1;
1874 else if (angle_range > 4 && min_angle < 0.25) min_angle = angle_range/16;
1875 else if (angle_range > min_angle*4) min_angle *= 4;
1880 // Evtl reduce angle_range for refinement pass to gain speed
1881 if (angle_range > 16) angle_range /= 4;
1882 else if (angle_range > 4) angle_range = 4;
1883 if (angle_range < min_angle*4) angle_range = min_angle*4;
1884 if (angle_range > max_angle) angle_range = max_angle;
1887 // Pre-negate result as previous_frame and current_frame have been interchanged
1890 while( angle_range >= min_angle ) {
1891 scan_angle1 = result - angle_range;
1892 scan_angle2 = result + angle_range;
1893 // Find number of required steps, even and no more than configured at once
1894 total_steps = (int)ceil(angle_range*2/min_angle);
1895 if (total_steps & 1) total_steps ++;
1896 if (total_steps > plugin->config.rotate_positions) total_steps = plugin->config.rotate_positions;
1898 //printf("RotateScan::scan_frame angle_range=%f from=%f to=%f steps=%d\n", angle_range, scan_angle1, scan_angle2, total_steps);
1900 // Use odd number of samples to ensure that rotation center be always included
1901 set_package_count(total_steps+1);
1902 //set_package_count(1);
1905 int64_t min_difference = -1, max_difference = -1, noiselev = -1;
1906 for( int i = 0; i < get_total_packages(); i++ ) {
1907 RotateScanPackage *pkg = (RotateScanPackage*)get_package(i);
1908 if( pkg->difference < min_difference || min_difference == -1 ) {
1909 min_difference = pkg->difference;
1910 result = pkg->angle;
1912 if( pkg->difference > max_difference || max_difference == -1 ) {
1913 max_difference = pkg->difference;
1915 //printf("RotateScan::scan_frame pkg=%d angle=%f diff=%ld min_diff=%ld max_diff=%ld\n", i, pkg->angle, pkg->difference, min_difference, max_difference);
1918 // Determine noise level (not active on pass 2)
1919 noiselev = min_difference+(max_difference-min_difference)*plugin->config.noise_rotation/100;
1920 if (passno == 2) noiselev = min_difference;
1921 //printf("RotateScan::scan_frame min_diff=%ld max_diff=%ld noiselev=%ld\n", min_difference, max_difference, noiselev);
1922 for(int i = 0; i < get_total_packages(); i++)
1924 RotateScanPackage *pkg = (RotateScanPackage*)get_package(i);
1925 // Already found as the best sample, not necessary to memorize
1926 if(result == pkg->angle) continue;
1927 // Above noise level - a definitely bad sample, skip
1928 if(pkg->difference > noiselev) continue;
1929 // Below noise level but farther from rotation center, skip
1930 if(fabs(pkg->angle-plugin->config.rotation_center) > fabs(result-plugin->config.rotation_center)) continue;
1931 // Below noise level and nearer to rotation center, memorize
1932 if(fabs(pkg->angle-plugin->config.rotation_center) < fabs(result-plugin->config.rotation_center))
1934 min_difference = pkg->difference;
1935 result = pkg->angle;
1936 //printf("RotateScan::scan_frame angle override=%d angle=%f diff=%ld min_diff=%ld\n", i, pkg->angle, pkg->difference, min_difference);
1939 // Equal distances to rotation center, memorize sample with min difference
1940 if(pkg->difference < min_difference)
1942 min_difference = pkg->difference;
1943 result = pkg->angle;
1944 //printf("RotateScan::scan_frame difference override=%d angle=%f diff=%ld min_diff=%ld\n", i, pkg->angle, pkg->difference, min_difference);
1948 float new_range = 0, angle_diff = 0;
1949 for(int i = 0; i < get_total_packages(); i++)
1951 RotateScanPackage *pkg = (RotateScanPackage*)get_package(i);
1952 // Above noise level - skip this angle
1953 if(pkg->difference > noiselev) continue;
1954 // Below noise level - measure max difference from the best angle
1955 if(angle_diff < fabs(result-pkg->angle))
1957 angle_diff = fabs(result-pkg->angle);
1958 //printf("RotateScan::scan_frame angle diff override=%d angle=%f diff=%f\n", i, pkg->angle, angle_diff);
1961 // Optimum new angle range might be +/- one search step from the best angle
1962 new_range = angle_range * 2 / total_steps;
1963 // Evtl expand angle range to +/- two search steps if some samples below noise
1964 if (angle_diff > 0) new_range = angle_range * 4 / total_steps;
1965 // Evtl expand angle range to include samples below noise level
1966 if (new_range < angle_diff) new_range = angle_diff;
1967 // But always reduce angle range at least twice
1968 if (new_range > angle_range / 2) new_range = angle_range / 2;
1969 angle_range = new_range;
1972 // Negate result as previous_frame and current_frame have been interchanged
1973 // and get rid of negative zeros in coord files
1975 if (fabs (result) < MIN_ANGLE) result = 0;
1978 // Dumping compared frames for debugging
1979 // current_frame->write_ppm(previous_frame, "/tmp/a%06ld-p.ppm",
1980 // plugin->get_source_position());
1981 // current_frame->write_ppm(current_frame, "/tmp/a%06ld-c.ppm",
1982 // plugin->get_source_position());
1984 //printf("RotateScan::scan_frame %d passno=%d saved angle=%f measured angle=%f twopass angle=%f\n", __LINE__, passno, result_saved, result, result_saved+result);
1988 int64_t RotateScan::get_cache(float angle)
1990 int64_t result = -1;
1991 cache_lock->lock("RotateScan::get_cache");
1992 for( int i = 0; i < cache.total; i++ ) {
1993 RotateScanCache *ptr = cache.values[i];
1994 // Attention, MIN_ANGLE in radian, while angle and ptr->angle in degree !
1995 if( fabs(ptr->angle - angle) <= MIN_ANGLE * 90 / M_PI ) {
1996 result = ptr->difference;
2000 cache_lock->unlock();
2004 void RotateScan::put_cache(float angle, int64_t difference)
2006 RotateScanCache *ptr = new RotateScanCache(angle, difference);
2007 cache_lock->lock("RotateScan::put_cache");
2009 cache_lock->unlock();
2013 RotateScanCache::RotateScanCache(float angle, int64_t difference)
2015 this->angle = angle;
2016 this->difference = difference;