/**
* Slot for 'Restore Optical Flow' menu item activation signal
*/
void OpticalFlowModule::restore_optical_flow()
{
string sequence_folder = _modulable->request_sequence_path();
if (sequence_folder.empty()) {
return;
}
string file_name = sequence_folder;
file_name.append("optical_flow_data");
_forward_optical_flow_list = OpticalFlowIO::read_whole_direction_data(file_name, true);
_backward_optical_flow_list = OpticalFlowIO::read_whole_direction_data(file_name, false);
_max_motion = -1.0f;
bool has_some_data = _forward_optical_flow_list.size() > 0 || _backward_optical_flow_list.size() > 0;
if (has_some_data != _has_optical_flow_data) {
if (_has_optical_flow_data) {
remove_optical_flow_views();
} else {
add_optical_flow_views();
}
_has_optical_flow_data = has_some_data;
notify_changes();
}
fill_task_list(_forward_optical_flow_list, _backward_optical_flow_list, _task_list);
if (_task_list.size() > 0) {
_proceed_menu_item->set_sensitive(true);
} else {
_restore_menu_item->set_sensitive(false);
}
}
void OpticalFlowModule::load_optical_flow()
{
if (_frames_amount < 2) {
return;
}
string flow_folder = _modulable->request_open_dialog_result("Load Optical Flows", true);
vector<Image<float> > fwd_flows = IOUtility::read_all_flows(flow_folder, "fwd");
if (fwd_flows.size() != _frames_amount && fwd_flows.size() != _frames_amount - 1) {
return;
}
vector<Image<float> > bwd_flows = IOUtility::read_all_flows(flow_folder, "bwd");
if (bwd_flows.size() != _frames_amount && bwd_flows.size() != _frames_amount - 1) {
return;
}
_forward_optical_flow_list.swap(fwd_flows);
if (_forward_optical_flow_list.size() == _frames_amount - 1) {
_forward_optical_flow_list.push_back(Image<float>(_forward_optical_flow_list[0].size(), 2, 0.0f));
}
if (bwd_flows.size() == _frames_amount - 1) {
_backward_optical_flow_list.clear();
_backward_optical_flow_list.reserve(_frames_amount);
_backward_optical_flow_list.push_back(Image<float>(bwd_flows[0].size(), 2, 0.0f));
_backward_optical_flow_list.insert(_backward_optical_flow_list.end(), bwd_flows.begin(), bwd_flows.end());
} else {
_backward_optical_flow_list.swap(bwd_flows);
}
if (!_has_optical_flow_data) {
add_optical_flow_views();
_has_optical_flow_data = true;
notify_changes();
}
_max_motion = -1.0f;
_task_list.clear();
_restore_menu_item->set_sensitive(false);
}
void OpticalFlowModule::take_optical_flow_frame(IData *data)
{
// Cast calculated values
OpticalFlowData *optical_flow_data = dynamic_cast<OpticalFlowData*>(data);
if (!optical_flow_data) {
return;
}
int index = optical_flow_data->index;
Image<float> flow(optical_flow_data->size_x, optical_flow_data->size_y, 2, 0.0f);
float* flow_data = flow.raw();
for (int i = 0; i < optical_flow_data->size_x * optical_flow_data->size_y; i++) {
flow_data[2 * i] = optical_flow_data->flow_x[i];
flow_data[2 * i + 1] = optical_flow_data->flow_y[i];
}
// Choose appropriate place to put flow
if (index >= 0) {
_forward_optical_flow_list[index] = flow;
} else {
_backward_optical_flow_list[-index - 1] = flow;
}
// Update progress
_progress_counter++;
Glib::ustring message = Glib::ustring::compose("Optical flow. Frames finished: %1; frames left: %2.", _progress_counter, _progress_total - _progress_counter);
_modulable->alter_background_work_info(_background_work_info, message);
if (!_has_optical_flow_data) {
add_optical_flow_views();
}
_has_optical_flow_data = true;
_max_motion = -1.0f;
notify_changes();
store_optical_flow(flow, index);
_restore_menu_item->set_sensitive(true);
}
void XSettingsClient::read_settings(void) {
E_ASSERT(client_data != NULL);
Atom type;
int format;
unsigned long n_items, bytes_after;
unsigned char *data;
int result;
int (*old_handler)(Display*, XErrorEvent*);
XSettingsList* old_settings = client_data->settings;
client_data->settings = NULL;
if(client_data->manager_win) {
old_handler = XSetErrorHandler(ignore_xerrors);
result = XGetWindowProperty(client_data->display, client_data->manager_win, client_data->xsettings_atom,
0, LONG_MAX, False, client_data->xsettings_atom,
&type, &format, &n_items, &bytes_after, (unsigned char**)&data);
XSetErrorHandler(old_handler);
if(result == Success && type != None) {
if(type != client_data->xsettings_atom)
E_WARNING(E_STRLOC ": Invalid type for XSETTINGS property\n");
else if(format != 8)
E_WARNING(E_STRLOC ": Invalid format for XSETTINGS property %d\n", format);
else {
// parse settings
client_data->settings = xsettings_decode(data, n_items, &client_data->serial);
}
XFree(data);
}
}
notify_changes(client_data, old_settings, settings_cb, settings_cb_data);
xsettings_list_free(old_settings);
}
static void
read_settings (GdkX11Screen *x11_screen,
gboolean do_notify)
{
GdkScreen *screen = GDK_SCREEN (x11_screen);
Atom type;
int format;
unsigned long n_items;
unsigned long bytes_after;
unsigned char *data;
int result;
GHashTable *old_list = x11_screen->xsettings;
GValue value = G_VALUE_INIT;
GValue *setting, *copy;
x11_screen->xsettings = NULL;
if (x11_screen->xsettings_manager_window)
{
GdkDisplay *display = x11_screen->display;
Atom xsettings_atom = gdk_x11_get_xatom_by_name_for_display (display, "_XSETTINGS_SETTINGS");
gdk_x11_display_error_trap_push (display);
result = XGetWindowProperty (gdk_x11_display_get_xdisplay (display),
gdk_x11_window_get_xid (x11_screen->xsettings_manager_window),
xsettings_atom, 0, LONG_MAX,
False, xsettings_atom,
&type, &format, &n_items, &bytes_after, &data);
gdk_x11_display_error_trap_pop_ignored (display);
if (result == Success && type != None)
{
if (type != xsettings_atom)
{
g_warning ("Invalid type for XSETTINGS property: %s", gdk_x11_get_xatom_name_for_display (display, type));
}
else if (format != 8)
{
g_warning ("Invalid format for XSETTINGS property: %d", format);
}
else
x11_screen->xsettings = parse_settings (data, n_items);
XFree (data);
}
}
/* Since we support scaling we look at the specific Gdk/UnscaledDPI
setting if it exists and use that instead of Xft/DPI if it is set */
if (x11_screen->xsettings && !x11_screen->fixed_window_scale)
{
setting = g_hash_table_lookup (x11_screen->xsettings, "gdk-unscaled-dpi");
if (setting)
{
copy = g_new0 (GValue, 1);
g_value_init (copy, G_VALUE_TYPE (setting));
g_value_copy (setting, copy);
g_hash_table_insert (x11_screen->xsettings,
"gtk-xft-dpi", copy);
}
}
if (do_notify)
notify_changes (x11_screen, old_list);
if (old_list)
g_hash_table_unref (old_list);
g_value_init (&value, G_TYPE_INT);
if (!screen->resolution_set)
{
/* This code is duplicated with gtksettings.c:settings_update_resolution().
* The update of the screen resolution needs to happen immediately when
* gdk_x11_display_set_window_scale() is called, and not wait for events
* to be processed, so we can't always handling it in gtksettings.c.
* But we can't always handle it here because the DPI can be set through
* GtkSettings, which we don't have access to.
*/
int dpi_int = 0;
double dpi;
const char *scale_env;
double scale;
if (gdk_screen_get_setting (GDK_SCREEN (x11_screen),
"gtk-xft-dpi", &value))
dpi_int = g_value_get_int (&value);
if (dpi_int > 0)
dpi = dpi_int / 1024.;
else
dpi = -1.;
scale_env = g_getenv ("GDK_DPI_SCALE");
if (scale_env)
{
scale = g_ascii_strtod (scale_env, NULL);
if (scale != 0 && dpi > 0)
dpi *= scale;
}
_gdk_screen_set_resolution (screen, dpi);
}
if (!x11_screen->fixed_window_scale &&
gdk_screen_get_setting (GDK_SCREEN (x11_screen),
"gdk-window-scaling-factor", &value))
_gdk_x11_screen_set_window_scale (x11_screen,
g_value_get_int (&value));
}
