void handle_keypress_event(XEvent * e)
{
XEvent event;
XGrabKey(display, AnyKey, AnyModifier, root, True, GrabModeAsync, GrabModeAsync);
XMaskEvent (display, KeyPressMask, &event);
XDefineCursor(display, selected, (XCreateFontCursor(display, CURSOR)));
unsigned int key = XLookupKeysym((XKeyEvent *) &event, 0);
if (key >= '0' && key <= '9')
{
XUngrabKey(display, AnyKey, AnyModifier, root);
grab_keyboard();
select_window(key - '0');
return;
}
switch (key)
{
case KEY_TERMINAL:
spawn(TERMINAL);
break;
case KEY_MENU:
spawn(MENU);
break;
case KEY_STATUS:
echo_output(STATUS);
break;
case KEY_WINLIST:
if(TIMEOUT > 0)
{
list_windows();
}
break;
case KEY_KILL:
XDestroyWindow(display, selected);
selected = root;
break;
case KEY_PREV:
if(get_prev_window() != -1){
select_window(get_prev_window());
} else {
message("Can't access previous window!");
}
break;
case KEY_NEXT:
if(get_next_window() != -1)
{
select_window(get_next_window());
} else {
message("Can't access next window!");
}
break;
default:
message("Key \"%c\" is unbound!", (char)key);
}
XUngrabKey(display, AnyKey, AnyModifier, root);
grab_keyboard();
XSetInputFocus (display, selected, RevertToParent, CurrentTime);
}
int handle_knowledge_book(void)
{
open_book(knowledge_book_id + 10000);
// Bring the new window to the front <----- Doesn't work. Is in front for the first usage, but not after that
select_window(book_win);
return 1;
}
void start_recording(GtkWidget *widget, gpointer data) {
GdkNativeWindow native;
GdkDisplay *display;
GdkRectangle rect;
if(is_recording)
return;
screen = gtk_widget_get_screen(widget);
if (screen == NULL) {
screen = gdk_screen_get_default ();
}
native = select_window(screen);
display = gdk_screen_get_display (screen);
window = gdk_window_foreign_new_for_display (display, native);
gdk_drawable_get_size (GDK_DRAWABLE (window), &rect.width, &rect.height);
/* creating flv und screenVideo instances */
flv = newFLVStream(FLVVERSION_1, FLVFLAG_VIDEO);
video = newScreenVideo(rect.width, rect.height, 64);
printf("video width: %i, height: %i\n", rect.width, rect.height);
/* capture timer */
g_timeout_add ( 1000 / FRAMERATE, next_capture, NULL);
is_recording = 1;
}
void chozeni2(EVENT_MSG *msg,OBJREC *o)
{
word s2,s1;
char ok=1;
if (msg->msg==E_INIT) return ;
if (msg->msg==E_DONE) return ;
if (msg->msg==E_KEYBOARD)
{
if (o_aktual==NULL || o_aktual->events[3]!=chozeni2) return;
if (waktual->id==map_win || waktual->id==tool_bar)
select_window(sektor_win);
if (waktual->id!=sektor_win) return;
s2=vals(5);s1=s2;
if (s2>maplen) return;
if (!(*(char *)msg->data))
switch (*(int *)msg->data>>8)
{
case 'H':s1=mapa.sectordef[s2].step_next[0];break;
case 'P':s1=mapa.sectordef[s2].step_next[2];break;
case 'M':s1=mapa.sectordef[s2].step_next[1];break;
case 'K':s1=mapa.sectordef[s2].step_next[3];break;
default:ok=0;
}
else if (*(char *)msg->data!=13) ok=0;
if (ok)
{
if (s1>maplen) return;
jdi_na_sektor(s1);
while (_bios_keybrd(_KEYBRD_READY)) _bios_keybrd(_KEYBRD_READ);
msg->msg=-1;
}
}
//CLICK HANDLERS
int recipe_dropdown_click_handler(window_info *win, int mx, int my, Uint32 flags){
static int last_clicked=0;
static int last_recipe=0;
if (flags & ELW_WHEEL_UP) {
cur_recipe=(cur_recipe-1+SHOW_MAX_RECIPE)%SHOW_MAX_RECIPE;
} else
if (flags & ELW_WHEEL_DOWN) {
cur_recipe=(cur_recipe+1)%SHOW_MAX_RECIPE;
} else {
//normal click
select_window(recipe_win);
cur_recipe=my/(33+1);
if ( ((SDL_GetTicks() - last_clicked) < 400)&& last_recipe==cur_recipe){
//double click on the same recipe to select it and close the dropdown
use_recipe(cur_recipe);
recipes_shown=0;
hide_window(recipe_win);
}
last_clicked = SDL_GetTicks();
}
build_manufacture_list();
last_recipe = cur_recipe;
do_click_sound();
return 1;
}
void draw_pick_up_menu()
{
if(ground_items_win < 0){
int our_root_win = -1;
if (!windows_on_top) {
our_root_win = game_root_win;
}
if (ground_items_menu_x_len < (min_grid_cols+1)*GRIDSIZE || ground_items_menu_x_len >= window_width ||
ground_items_menu_y_len < min_grid_rows*GRIDSIZE || ground_items_menu_y_len >= window_height)
{
ground_items_menu_x_len=6*GRIDSIZE;
ground_items_menu_y_len=10*GRIDSIZE;
}
ground_items_win= create_window(win_bag, our_root_win, 0, ground_items_menu_x, ground_items_menu_y,
ground_items_menu_x_len, ground_items_menu_y_len, ELW_SCROLLABLE|ELW_RESIZEABLE|ELW_WIN_DEFAULT);
set_window_handler(ground_items_win, ELW_HANDLER_DISPLAY, &display_ground_items_handler );
set_window_handler(ground_items_win, ELW_HANDLER_CLICK, &click_ground_items_handler );
set_window_handler(ground_items_win, ELW_HANDLER_MOUSEOVER, &mouseover_ground_items_handler );
set_window_handler(ground_items_win, ELW_HANDLER_RESIZE, &resize_ground_items_handler );
set_window_handler(ground_items_win, ELW_HANDLER_CLOSE, &clear_groundlist );
set_window_min_size(ground_items_win, (min_grid_cols+1)*GRIDSIZE, min_grid_rows*GRIDSIZE);
set_window_scroll_inc(ground_items_win, GRIDSIZE/3);
set_window_scroll_yoffset(ground_items_win, GRIDSIZE);
resize_ground_items_handler(&windows_list.window[ground_items_win]);
} else {
show_window(ground_items_win);
select_window(ground_items_win);
}
set_window_scroll_pos(ground_items_win, 0);
}
void winmng::select_next_window(int _next)
{
if (m_win == nullptr || m_winList->count <= 1) {
return;
}
int i = 0;
while ((i < m_winList->count) && (m_winList->list[i] != m_win)) {
i++;
}
if (m_winList->list[i] != m_win) {
return;
}
do {
i += _next;
if (i >= m_winList->count) {
i = 0;
}
else if (i < 0) {
i = m_winList->count-1;
}
if (m_winList->list[i] == m_win) {
break;
}
} while (!IsWindowVisible(m_winList->list[i]));
select_window(i);
}
void about()
{
FC_TABLE c = {0,RGB555(31,31,0),RGB555(28,28,28),RGB555(24,24,24),RGB555(20,20,20)};
FC_TABLE c2= {0,RGB555(31,16,0),RGB555(28,16,0),RGB555(24,16,0),RGB555(20,16,0)};
FC_TABLE c3= {0,RGB555(0,24,0),RGB555(0,20,0),RGB555(0,16,0),RGB555(0,10,0)};
static about_win = -1;
if (find_window(about_win) == NULL)
{
about_win = def_window(300,200,"About");
waktual->x = 320-150;
waktual->y = 140;
memcpy(f_default,flat_color(0x0),sizeof(FC_TABLE));
waktual->modal = 1;
default_font = vga_font;
define(-1,5,25,29,29,0,dtext,"\x8");property(NULL,icones,&c,WINCOLOR);
define(-1,75,25,100,29,0,dtext,"MAPEDIT");property(NULL,NULL,&c2,WINCOLOR);
define(-1,200,35,60,29,0,label,"verze 2.0");property(NULL,NULL,&c3,WINCOLOR);
define(-1,20,80,200,10,0,label,"Naps no pro hru \"Br ny Skeldalu\"");
define(-1,20,92,200,10,0,label,"(C) 1997 Napoleon gameS ");
define(-1,20,104,200,10,0,label,"Naprogamoval: Ond©ej Nov k ");
define(-1,20,116,200,10,0,label,"Tento software sm¡ b˜t pou‘it jen");
define(-1,20,128,200,10,0,label,"ve spojen¡ s v˜vojem hry \"Br ny");
define(-1,20,140,200,10,0,label,"Skeldalu\" (a p©¡padn‚ dal¨¡ verze)");
define(-1,20,152,200,10,0,label,"a to pouze ‡leny v˜vojov‚ho t˜mu.");
define(10,110,170,80,20,0,button,"Ok");on_change(close_test);
}
else select_window(about_win);
redraw_window();
}
void show_window(int win_id)
{
if(win_id <=0 || win_id >= windows_list.num_windows) return;
if(windows_list.window[win_id].window_id != win_id) return;
// pull to the top if not currently displayed
if(!windows_list.window[win_id].displayed) select_window(win_id);
windows_list.window[win_id].displayed= 1;
}
void display_popup_win (INPUT_POPUP *ipu, const char* label)
{
widget_list *wok;
widget_list *wno;
if(ipu->popup_win < 0)
{
Uint32 flags = ELW_WIN_DEFAULT & ~ELW_CLOSE_BOX;
ipu->popup_win = create_window (win_prompt, ipu->parent, 0, ipu->x, ipu->y, ipu->popup_x_len, ipu->popup_y_len, flags);
// clear the buffer
init_text_message (&ipu->popup_text, ipu->maxlen);
set_text_message_color (&ipu->popup_text, 0.77f, 0.57f, 0.39f);
// Label
ipu->popup_label = label_add (ipu->popup_win, NULL, label, 5, 5);
widget_set_color (ipu->popup_win, ipu->popup_label, 0.77f, 0.57f, 0.39f);
// Input
ipu->popup_field = text_field_add_extended (ipu->popup_win, 101, NULL, 5, 28, ipu->popup_x_len - 10, 28*ipu->rows, ipu->text_flags, 1.0f, 0.77f, 0.57f, 0.39f, &ipu->popup_text, 1, FILTER_ALL, 5, 5);
widget_set_color (ipu->popup_win, ipu->popup_field, 0.77f, 0.57f, 0.39f);
// Accept
ipu->popup_ok = button_add (ipu->popup_win, NULL, button_okay, 0, 0);
widget_set_OnClick (ipu->popup_win, ipu->popup_ok, popup_ok_button_handler);
widget_set_color (ipu->popup_win, ipu->popup_ok, 0.77f, 0.57f, 0.39f);
// Reject
ipu->popup_no = button_add (ipu->popup_win, NULL, button_cancel, 0, 0);
widget_set_OnClick (ipu->popup_win, ipu->popup_no, popup_cancel_button_handler);
widget_set_color (ipu->popup_win, ipu->popup_no, 0.77f, 0.57f, 0.39f);
// align the buttons
wok = widget_find(ipu->popup_win, ipu->popup_ok);
wno = widget_find(ipu->popup_win, ipu->popup_no);
widget_move(ipu->popup_win, ipu->popup_ok, (ipu->popup_x_len - wok->len_x - wno->len_x)/3, ipu->popup_y_len - (wok->len_y + 5));
widget_move(ipu->popup_win, ipu->popup_no, wok->len_x + 2*(ipu->popup_x_len - wok->len_x - wno->len_x)/3, ipu->popup_y_len - (wno->len_y + 5));
set_window_handler (ipu->popup_win, ELW_HANDLER_KEYPRESS, popup_keypress_handler);
if ((ipu->popup_win > -1) && (ipu->popup_win < windows_list.num_windows))
windows_list.window[ipu->popup_win].data = ipu;
}
else
{
if ((ipu->parent > -1) && (ipu->parent < windows_list.num_windows))
{
window_info *win = &windows_list.window[ipu->parent];
move_window(ipu->popup_win, ipu->parent, 0, win->pos_x+ipu->x, win->pos_y+ipu->y);
}
text_field_clear(ipu->popup_win, ipu->popup_field);
label_set_text (ipu->popup_win, ipu->popup_label, label);
show_window (ipu->popup_win);
select_window (ipu->popup_win);
}
}
void display_book_window(book *b)
{
int *p;
if(!b)
return;
if(b->type==1){
p=&paper_win;
if(book_win!=-1)
hide_window(book_win);
} else {
p=&book_win;
if(paper_win!=-1)
hide_window(paper_win);
}
book_opened = b->id;
if(*p<0){
if(b->type==1)
*p=create_window(b->title, -1, 0, book_win_x, book_win_y, 320, 400, ELW_WIN_DEFAULT^ELW_CLOSE_BOX);
else if(b->type==2)
*p=create_window(b->title, -1, 0, book_win_x, book_win_y, 528, 320, ELW_WIN_DEFAULT^ELW_CLOSE_BOX); //width/height are different
set_window_handler(*p, ELW_HANDLER_DISPLAY, &display_book_handler);
set_window_handler(*p, ELW_HANDLER_MOUSEOVER, &mouseover_book_handler);
set_window_handler(*p, ELW_HANDLER_CLICK, &click_book_handler);
windows_list.window[*p].data=b;
} else {
if((point)windows_list.window[*p].data!=(point)b) {
safe_snprintf(windows_list.window[*p].window_name, sizeof(windows_list.window[*p].window_name), "%s", b->title);
windows_list.window[*p].data=b;
if(!get_show_window(*p))
show_window(*p);
select_window(*p);
} else if(!get_show_window(*p)) {
show_window(*p);
select_window(*p);
}
}
}
void display_storage_menu()
{
int i;
/* Entropy suggested hack to determine if this is the view only "#sto" opened storage */
view_only_storage = 0;
for (i = 0; i < no_storage_categories; i++)
{
if ((storage_categories[i].id != -1) && (strcmp(&storage_categories[i].name[1], "Quest") == 0))
{
view_only_storage = 1;
break;
}
}
if(storage_win<=0){
int our_root_win = -1;
if (!windows_on_top) {
our_root_win = game_root_win;
}
storage_win=create_window(win_storage, our_root_win, 0, storage_win_x, storage_win_y, storage_win_x_len, storage_win_y_len, ELW_WIN_DEFAULT|ELW_TITLE_NAME);
set_window_handler(storage_win, ELW_HANDLER_DISPLAY, &display_storage_handler);
set_window_handler(storage_win, ELW_HANDLER_CLICK, &click_storage_handler);
set_window_handler(storage_win, ELW_HANDLER_MOUSEOVER, &mouseover_storage_handler);
set_window_handler(storage_win, ELW_HANDLER_KEYPRESS, &keypress_storage_handler );
vscrollbar_add_extended(storage_win, STORAGE_SCROLLBAR_CATEGORIES, NULL, 130, 10, 20, 192, 0, 1.0, newcol_r, newcol_g, newcol_b, 0, 1,
max2i(no_storage_categories - STORAGE_CATEGORIES_DISPLAY, 0));
vscrollbar_add_extended(storage_win, STORAGE_SCROLLBAR_ITEMS, NULL, 352, 10, 20, 192, 0, 1.0, newcol_r, newcol_g, newcol_b, 0, 1, 28);
cm_add(windows_list.window[storage_win].cm_id, cm_storage_menu_str, context_storage_handler);
cm_add(windows_list.window[storage_win].cm_id, cm_dialog_options_str, context_storage_handler);
cm_bool_line(windows_list.window[storage_win].cm_id, ELW_CM_MENU_LEN+2, &sort_storage_categories, NULL);
cm_bool_line(windows_list.window[storage_win].cm_id, ELW_CM_MENU_LEN+3, &disable_storage_filter, NULL);
cm_bool_line(windows_list.window[storage_win].cm_id, ELW_CM_MENU_LEN+4, &autoclose_storage_dialogue, NULL);
cm_bool_line(windows_list.window[storage_win].cm_id, ELW_CM_MENU_LEN+5, &auto_select_storage_option, NULL);
} else {
no_storage=0;
for(i = 0; i < no_storage_categories; i++)
storage_categories[i].name[0] = to_color_char (c_orange1);
show_window(storage_win);
select_window(storage_win);
vscrollbar_set_pos(storage_win, STORAGE_SCROLLBAR_CATEGORIES, 0);
vscrollbar_set_pos(storage_win, STORAGE_SCROLLBAR_ITEMS, 0);
}
storage_text[0] = '\0';
set_window_name("", "");
}
void display_browser()
{
if(browser_win <= 0){
browser_win= create_window("browser", 0, 0, browser_menu_x, browser_menu_y, browser_menu_x_len, browser_menu_y_len, ELW_WIN_DEFAULT);
set_window_handler(browser_win, ELW_HANDLER_DISPLAY, &display_browser_handler );
set_window_handler(browser_win, ELW_HANDLER_CLICK, &check_browser_interface );
} else {
show_window(browser_win);
select_window(browser_win);
}
display_window(browser_win);
}
void display_o3dow()
{
if(o3dow_win <= 0){
o3dow_win= create_window("o3dow", 0, 0, o3dow_x, o3dow_y, o3dow_x_len, o3dow_y_len, ELW_WIN_DEFAULT);
set_window_handler(o3dow_win, ELW_HANDLER_DISPLAY, &display_o3dow_handler );
set_window_handler(o3dow_win, ELW_HANDLER_CLICK, &check_o3dow_interface );
} else {
show_window(o3dow_win);
select_window(o3dow_win);
}
display_window(o3dow_win);
}
void display_options_menu()
{
if(options_win <= 0){
options_win= create_window("Options", 0, 0, options_menu_x, options_menu_y, options_menu_x_len, options_menu_y_len, ELW_WIN_DEFAULT);
set_window_color(options_win, ELW_COLOR_BORDER, 0.0f, 1.0f, 0.0f, 0.0f);
set_window_handler(options_win, ELW_HANDLER_DISPLAY, &display_options_handler );
set_window_handler(options_win, ELW_HANDLER_CLICK, &click_options_handler );
set_window_handler(options_win, ELW_HANDLER_MOUSEOVER, &mouseover_options_handler );
init_display_options_menu();
} else {
show_window(options_win);
select_window(options_win);
}
display_window(options_win);
}
static gboolean
darea_button_release_event (GtkWidget *widget,
GdkEventButton *event)
{
if ((event->state & GDK_CONTROL_MASK) != 0)
{
toggle_selection_window (event->window);
}
else
{
unselect_windows ();
select_window (event->window);
}
return TRUE;
}
void open_editor_win()
{
if (find_window(editor_win) == NULL)
{
editor_win = def_window(100,150,"Editory");
define(10,10,25,80,20,0,button,"map script");on_change(edit_script_file);
define(20,10,50,80,20,0,button,"map texty");on_change(edit_script_file);
define(30,10,75,80,20,0,button,"items.scr");on_change(edit_script_file);
define(40,10,100,80,20,0,button,"items.pic");on_change(edit_script_file);
define(50,10,125,80,20,0,button,"animator");on_change(call_animator);
redraw_window();
}
else
{
select_window(editor_win);
redraw_window();
}
}
void display_manufacture_menu()
{
if(manufacture_win < 0){
static int clear_button_id=100;
static int mixone_button_id=101;
static int mixall_button_id=102;
int our_root_win = -1;
if (!windows_on_top) {
our_root_win = game_root_win;
}
manufacture_win= create_window(win_manufacture, our_root_win, 0, manufacture_menu_x, manufacture_menu_y, manufacture_menu_x_len, manufacture_menu_y_len, ELW_WIN_DEFAULT);
set_window_handler(manufacture_win, ELW_HANDLER_DISPLAY, &display_manufacture_handler );
set_window_handler(manufacture_win, ELW_HANDLER_CLICK, &click_manufacture_handler );
set_window_handler(manufacture_win, ELW_HANDLER_MOUSEOVER, &mouseover_manufacture_slot_handler );
mixone_button_id=button_add_extended(manufacture_win, mixone_button_id,
NULL, 33*6+15+10, manufacture_menu_y_len-36, 43, 0, 0, 1.0f, 0.77f, 0.57f, 0.39f, ">");
widget_set_OnClick(manufacture_win, mixone_button_id, mixone_handler);
widget_set_OnMouseover(manufacture_win, mixone_button_id, mouseover_mixone_handler);
mixall_button_id=button_add_extended(manufacture_win, mixall_button_id,
NULL, 33*8+10, manufacture_menu_y_len-36, 43, 0, 0, 1.0f, 0.77f, 0.57f, 0.39f, ">>");
widget_set_OnClick(manufacture_win, mixall_button_id, mixall_handler);
widget_set_OnMouseover(manufacture_win, mixall_button_id, mouseover_mixall_handler);
clear_button_id=button_add_extended(manufacture_win, clear_button_id, NULL, 33*9+18+10, manufacture_menu_y_len-36, 70, 0, 0, 1.0f, 0.77f, 0.57f, 0.39f, clear_str);
widget_set_OnClick(manufacture_win, clear_button_id, clear_handler);
//Create a child window to show recipes in a dropdown panel
recipe_win= create_window("w_recipe", manufacture_win, 0, 2, manufacture_menu_y_len-2, 33*6, SHOW_MAX_RECIPE*33,
ELW_TITLE_NONE|ELW_SHOW|ELW_USE_BACKGROUND|ELW_ALPHA_BORDER|ELW_SWITCHABLE_OPAQUE|ELW_USE_BORDER);
set_window_handler(recipe_win, ELW_HANDLER_DISPLAY, &recipe_dropdown_draw);
set_window_handler(recipe_win, ELW_HANDLER_CLICK, &recipe_dropdown_click_handler );
set_window_handler(recipe_win, ELW_HANDLER_MOUSEOVER, &mouseover_recipe_handler );
hide_window(recipe_win); //start hidden
} else {
show_window(manufacture_win);
if (!recipes_shown) hide_window(recipe_win);
else show_window(recipe_win);
select_window(manufacture_win);
}
}
void display_small_text_window()
{
int x=mouse_x-(small_text_win_x_len>>1);
int y=mouse_y-(small_text_win_y_len>>1);
if(x<0)x=200;
if(y<0)y=200;
if(x>window_width-small_text_win_x_len)x=200;
if(y>window_height-small_text_win_y_len)y=200;
if(small_text_win < 0){
small_text_win= create_window("Small text window", 0, 0, x, y, small_text_win_x_len, small_text_win_y_len, ELW_CLOSE_BOX|ELW_DRAGGABLE|ELW_USE_BACKGROUND|ELW_USE_BORDER|ELW_SHOW);
set_window_handler(small_text_win, ELW_HANDLER_DISPLAY, &display_small_text_window_handler );
} else {
move_window(small_text_win, 0, 0, x, y);
show_window(small_text_win);
select_window(small_text_win);
}
}
void display_minimap()
{
window_info *win;
minimap_size = 256 * minimap_size_coefficient;
float_minimap_size = 256.0 * minimap_size_coefficient;
if(minimap_tiles_distance < 48)
minimap_tiles_distance = 48;
if(minimap_tiles_distance > 144)
minimap_tiles_distance = 144;
if(minimap_win < 0)
{
//init minimap
minimap_win = create_window(win_minimap, windows_on_top?-1:game_root_win, 0, minimap_win_x, minimap_win_y,
minimap_size, minimap_size+ELW_TITLE_HEIGHT, ELW_CLICK_TRANSPARENT|ELW_SHOW|ELW_TITLE_NAME|ELW_ALPHA_BORDER|ELW_SWITCHABLE_OPAQUE|ELW_DRAGGABLE);
set_window_handler(minimap_win, ELW_HANDLER_DISPLAY, &display_minimap_handler);
set_window_handler(minimap_win, ELW_HANDLER_CLICK, &click_minimap_handler);
set_window_handler(minimap_win, ELW_HANDLER_MOUSEOVER, &mouseover_minimap_handler);
set_window_handler(minimap_win, ELW_HANDLER_KEYPRESS, &keypress_minimap_handler );
win = &(windows_list.window[minimap_win]);
win->owner_drawn_title_bar = 1;
change_minimap();
if (!cm_valid(win->cm_id))
{
win->cm_id = cm_create(cm_title_menu_str, cm_minimap_title_handler);
cm_grey_line(win->cm_id, 1, 1);
cm_bool_line(win->cm_id, 2, &windows_on_top, "windows_on_top");
}
cm_add(win->cm_id, cm_minimap_menu_str, NULL);
cm_add_region(win->cm_id, minimap_win, win->len_x/2-32, 0, 64, ELW_TITLE_HEIGHT );
cm_bool_line(win->cm_id, ELW_CM_MENU_LEN+1, &rotate_minimap, "rotate_minimap");
cm_bool_line(win->cm_id, ELW_CM_MENU_LEN+2, &pin_minimap, "pin_minimap");
cm_bool_line(win->cm_id, ELW_CM_MENU_LEN+3, &open_minimap_on_start, NULL);
} else {
show_window(minimap_win);
select_window(minimap_win);
}
}
void
cycle_selection(int direction, int wn, xcb_window_t *windows, int select)
{
system("clear");
wsel += direction;
if (select) {
select_window(windows[wsel]);
}
if (wsel >= wn) {
wsel = 0;
}
if (wsel < 0) {
wsel = wn-1;
}
print_selection(wn, windows, wsel);
}
void display_emotes_menu()
{
if(emotes_win < 0){
//static int do_button_id=100;
int our_root_win = -1;
if (!windows_on_top) {
our_root_win = game_root_win;
}
emotes_win= create_window("Emotes", our_root_win, 0, emotes_menu_x, emotes_menu_y, emotes_menu_x_len, emotes_menu_y_len, ELW_WIN_DEFAULT);
set_window_handler(emotes_win, ELW_HANDLER_DISPLAY, &display_emotes_handler );
set_window_handler(emotes_win, ELW_HANDLER_CLICK, &click_emotes_handler );
vscrollbar_add_extended(emotes_win, EMOTES_SCROLLBAR_ITEMS, NULL, emotes_rect_x2+20, 30+emotes_rect_y+20, 20, emotes_rect_y2, 0, 1.0, 0.77f, 0.57f, 0.39f, 0, 1, 20);
//do_button_id=button_add_extended(emotes_win, do_button_id, NULL, 33*9+18+10, emotes_menu_y_len-36, 70, 0, 0, 1.0f, 0.77f, 0.57f, 0.39f, "Do!");
//widget_set_OnClick(emotes_win, do_button_id, do_handler);
update_selectables();
} else {
show_window(emotes_win);
select_window(emotes_win);
}
}
/*
int clika(widget_list *w){
w->pos_x+=10;
return 0;
}
int clikaa(widget_list *w){
progressbar *b = (progressbar *)w->widget_info;
b->progress++;
return 0;
}
*/
void display_buddy()
{
if(buddy_win <= 0)
{
//buddy_win = AddXMLWindow("buddy.xml");
buddy_win = create_window("Buddy", 0, 0, buddy_menu_x, buddy_menu_y, buddy_menu_x_len, buddy_menu_y_len, ELW_WIN_DEFAULT);
set_window_handler(buddy_win, ELW_HANDLER_DISPLAY, &display_buddy_handler );
set_window_handler(buddy_win, ELW_HANDLER_CLICK, &click_buddy_handler );
set_window_handler(buddy_win, ELW_HANDLER_DRAG, &drag_buddy_handler );
/*
label_add(buddy_win,NULL,"Hello!",0,0);
widget_set_size(buddy_win,0,2.0);
widget_set_color(buddy_win,0,0.5,0.5,0.5);
widget_move(buddy_win,0,20,20);
label_set_text(buddy_win,0,"Bye!");
widget_set_OnClick(buddy_win,0,clika);
widget_set_OnMouseover(buddy_win,0,clika);
image_add(buddy_win,NULL,load_texture_cache("./textures/sky.bmp",70),0,30,64,64,0.0,0.0,1.0,1.0);
widget_set_OnClick(buddy_win,1,clika);
widget_set_OnMouseover(buddy_win,1,clika);
widget_resize(buddy_win,1,128,128);
checkbox_add(buddy_win, NULL, 2, 100,20,20,0);
button_add(buddy_win,NULL,"Hello!",0,150);
widget_set_color(buddy_win,3,1.5,0.0,0.5);
widget_set_OnClick(buddy_win,3,clika);
progressbar_add(buddy_win,NULL,50,50,20,200);
progressbar_set_progress(buddy_win,4,25);
widget_set_OnClick(buddy_win,4,clikaa);
*/ vscrollbar_add_extended(buddy_win,12,NULL,130,20,20,180,0,1.0,0.77f,0.57f,0.39f,0,1,130);
}
else
{
show_window(buddy_win);
select_window(buddy_win);
}
}
//CLICK HANDLERS
static int recipe_dropdown_click_handler(window_info *win, int mx, int my, Uint32 flags){
static int last_clicked=0;
static int last_recipe=0;
int first_displayed_recipe = vscrollbar_get_pos (win->window_id, recipe_win_scroll_id);
int rel_curr;
if (flags & ELW_WHEEL_UP) {
cur_recipe=(cur_recipe-1+num_recipe_entries)%num_recipe_entries;
rel_curr = cur_recipe - first_displayed_recipe;
if ((rel_curr < 0) || (rel_curr >= num_displayed_recipes))
vscrollbar_set_pos(win->window_id, recipe_win_scroll_id, cur_recipe);
} else
if (flags & ELW_WHEEL_DOWN) {
cur_recipe=(cur_recipe+1)%num_recipe_entries;
rel_curr = cur_recipe - first_displayed_recipe;
if ((rel_curr < 0) || (rel_curr >= num_displayed_recipes))
{
first_displayed_recipe = cur_recipe;
if (cur_recipe > 0)
first_displayed_recipe -= num_displayed_recipes - 1;
vscrollbar_set_pos(win->window_id, recipe_win_scroll_id, first_displayed_recipe);
}
} else {
//normal click
select_window(recipe_win);
cur_recipe=first_displayed_recipe + my/(SLOT_SIZE+1);
//double click on the same recipe to select it and close the dropdown
if ( ((SDL_GetTicks() - last_clicked) < 400)&& last_recipe==cur_recipe)
select_recipe(cur_recipe);
last_clicked = SDL_GetTicks();
do_click_sound();
}
last_recipe = cur_recipe;
return 1;
}
void scrollback(void)
{
int window = 0;
if (nfd > 1)
{
window = select_window(HELP_SCROLLBACK_SELECT_WINDOW, NULL);
}
if (window != -1)
{
if (lb[window].bufferwhat == 0)
error_popup("Scrollback", HELP_SCROLLBACK_NO_MARK, "Cannot scrollback: buffering is disabled.");
}
if (window != -1 && lb[window].bufferwhat != 0)
{
int header_size = strlen(pi[window].filename) + 4;
char *header = (char *)mymalloc(header_size + 1);
snprintf(header, header_size, "%02d] %s", window, pi[window].filename);
scrollback_do(window, &lb[window], NULL, header);
myfree(header);
}
}
MAIN_QTHREAD(int, argc, char **, argv) { // macro to enable multithreaded gui
#else
int main(int argc, char **argv) { // regular main without gui
#endif
try {
// check input parameters
if ((argc != 2) && (argc != 3) ) {
cerr << "wrong number of parameters." << endl;
cerr << "usage: objdetect <config file> [directory or file]" << endl;
return -1;
}
#ifdef __LINUX__
feenableexcept(FE_DIVBYZERO | FE_INVALID); // enable float exceptions
#endif
ipp_init(1); // limit IPP (if available) to 1 core
// load configuration
configuration conf(argv[1], true, true, false);
if (!conf.exists("root2")) {
string dir;
dir << dirname(argv[1]) << "/";
cout << "Looking for trained files in: " << dir << endl;
conf.set("root2", dir.c_str());
conf.set("current_dir", dir.c_str());
}
conf.resolve();
if (conf.exists_true("show_conf")) conf.pretty();
bool color = conf.exists_bool("color");
uint norm_size = conf.get_uint("normalization_size");
Tnet threshold = (Tnet) conf.get_double("threshold");
bool display = false;
bool display_states= false;
bool mindisplay = false;
uint display_sleep = 0;
bool save_video = false;
string cam_type = conf.get_string("camera");
int height = -1;
int width = -1;
if (conf.exists("input_height")) height = conf.get_int("input_height");
if (conf.exists("input_width")) width = conf.get_int("input_width");
bool input_random = conf.exists_true("input_random");
uint npasses = 1;
char next_on_key = 0;
uint wid = 0; // window id
uint wid_states = 0; // window id
string outdir = "out_";
if (conf.exists("next_on_key")) {
next_on_key = conf.get_char("next_on_key");
cout << "Press " << next_on_key << " to process next frame." << endl;
}
outdir += tstamp();
outdir += "/";
cout << "Saving outputs to " << outdir << endl;
// load network and weights
parameter<fs(Tnet)> theparam;
idx<ubyte> classes(1,1);
try {
load_matrix<ubyte>(classes, conf.get_cstring("classes"));
} catch(string &err) { cerr << "warning: " << err << endl; }
vector<string> sclasses = ubyteidx_to_stringvector(classes);
answer_module<SFUNC2(Tnet)> *ans =
create_answer<SFUNC2(Tnet)>(conf, classes.dim(0));
uint noutputs = ans->get_nfeatures();
module_1_1<SFUNC(Tnet)> *net =
create_network<SFUNC(Tnet)>(theparam, conf, noutputs);
// loading weights
if (!conf.exists("weights")) { // manual weights
cerr << "warning: \"weights\" variable not defined, loading manually "
<< "if manual_load defined" << endl;
if (conf.exists_true("manual_load"))
manually_load_network(*((layers<SFUNC(Tnet)>*)net), conf);
} else { // multiple-file weights
// concatenate weights if multiple ones
vector<string> w =
string_to_stringvector(conf.get_string("weights"));
cout << "Loading weights from: " << w << endl;
theparam.load_x(w);
}
// detector
detector<fs(Tnet)> detect(*net, sclasses, *ans, NULL, NULL);
// multi-scaling parameters
double maxs = conf.exists("max_scale")?conf.get_double("max_scale") : 1.0;
double mins = conf.exists("min_scale")?conf.get_double("min_scale") : 1.0;
t_scaling scaling_type = SCALES_STEP;
vector<idxdim> scales;
if (conf.exists("scaling_type"))
scaling_type = (t_scaling) conf.get_uint("scaling_type");
switch (scaling_type) {
case MANUAL:
if (!conf.exists("scales"))
eblerror("expected \"scales\" variable to be defined in manual mode");
scales = string_to_idxdimvector(conf.get_cstring("scales"));
detect.set_resolutions(scales);
break ;
case ORIGINAL: detect.set_scaling_original(); break ;
case SCALES_STEP:
detect.set_resolutions(conf.get_double("scaling"), maxs, mins);
break ;
case SCALES_STEP_UP:
detect.set_resolutions(conf.get_double("scaling"), maxs, mins);
detect.set_scaling_type(scaling_type);
break ;
default:
detect.set_scaling_type(scaling_type);
}
// optimize memory usage by using only 2 buffers for entire flow
SBUF<Tnet> input(1, 1, 1), output(1, 1, 1);
if (!conf.exists_false("mem_optimization"))
detect.set_mem_optimization(input, output, true);
// zero padding
float hzpad = 0, wzpad = 0;
if (conf.exists("hzpad")) hzpad = conf.get_float("hzpad");
if (conf.exists("wzpad")) wzpad = conf.get_float("wzpad");
detect.set_zpads(hzpad, wzpad);
bool bmask_class = false;
if (conf.exists("mask_class"))
bmask_class = detect.set_mask_class(conf.get_cstring("mask_class"));
if (conf.exists("input_min")) // limit inputs size
detect.set_min_resolution(conf.get_uint("input_min"));
if (conf.exists("input_max")) // limit inputs size
detect.set_max_resolution(conf.get_uint("input_max"));
detect.set_silent();
if (conf.exists_bool("save_detections")) {
string detdir = outdir;
detdir += "detections";
detdir = detect.set_save(detdir);
if (conf.exists("save_max_per_frame"))
detect.set_save_max_per_frame(conf.get_uint("save_max_per_frame"));
}
// nms
detect.set_cluster_nms(conf.exists_true("cluster_nms"));
detect.set_scaler_mode(conf.exists_true("scaler_mode"));
if (conf.exists("nms"))
detect.set_pruning((t_pruning)conf.get_uint("nms"),
conf.exists("min_hcenter_dist") ?
conf.get_float("min_hcenter_dist") : 0.0,
conf.exists("min_wcenter_dist") ?
conf.get_float("min_wcenter_dist") : 0.0,
conf.exists("bbox_max_overlap") ?
conf.get_float("bbox_max_overlap") : 1.0,
conf.exists_true("share_parts"),
conf.exists("threshold2") ?
(Tnet) conf.get_float("threshold2") : 0.0,
conf.exists("bbox_max_center_dist") ?
conf.get_float("bbox_max_center_dist") : 0.0,
conf.exists("bbox_max_center_dist2") ?
conf.get_float("bbox_max_center_dist2") : 0.0,
conf.exists("bbox_max_wcenter_dist") ?
conf.get_float("bbox_max_wcenter_dist") : 0.0,
conf.exists("bbox_max_wcenter_dist2") ?
conf.get_float("bbox_max_wcenter_dist2") : 0.0,
conf.exists("min_wcenter_dist2") ?
conf.get_float("min_wcenter_dist2") : 0.0,
conf.exists("bbox_max_overlap2") ?
conf.get_float("bbox_max_overlap2") : 0.0,
conf.exists_true("mean_bb"),
conf.exists("same_scale_mhd") ?
conf.get_float("same_scale_mhd") : 0.0,
conf.exists("same_scale_mwd") ?
conf.get_float("same_scale_mwd") : 0.0,
conf.exists("min_scale_pred") ?
conf.get_float("min_scale_pred") : 0.0,
conf.exists("max_scale_pred") ?
conf.get_float("max_scale_pred") : 0.0
);
if (conf.exists("bbox_hfactor") && conf.exists("bbox_wfactor"))
detect.set_bbox_factors(conf.get_float("bbox_hfactor"),
conf.get_float("bbox_wfactor"),
conf.exists("bbox_woverh") ?
conf.get_float("bbox_woverh") : 1.0,
conf.exists("bbox_hfactor2") ?
conf.get_float("bbox_hfactor2") : 1.0,
conf.exists("bbox_wfactor2") ?
conf.get_float("bbox_wfactor2") : 1.0);
if (conf.exists("max_object_hratio"))
detect.set_max_object_hratio(conf.get_double("max_object_hratio"));
if (conf.exists("net_min_height") && conf.exists("net_min_width"))
detect.set_min_input(conf.get_int("net_min_height"),
conf.get_int("net_min_width"));
if (conf.exists("smoothing"))
detect.set_smoothing(conf.get_uint("smoothing"));
if (conf.exists("background_name"))
detect.set_bgclass(conf.get_cstring("background_name"));
// image search can be configured with a search pattern
const char *fpattern = IMAGE_PATTERN_MAT;
if (conf.exists("file_pattern"))
fpattern = conf.get_cstring("file_pattern");
// initialize camera (opencv, directory, shmem or video)
idx<ubyte> frame;
camera<ubyte> *cam = NULL, *cam2 = NULL;
if (!strcmp(cam_type.c_str(), "directory")) {
string dir;
if (argc >= 3) // read input dir from command line
dir = argv[2];
else if (conf.exists("input_dir"))
dir = conf.get_string("input_dir");
// given list
list<string> files;
if (conf.exists("input_list")) {
files = string_to_stringlist(conf.get_string("input_list"));
cam = new camera_directory<ubyte>(dir.c_str(), height, width,
input_random, npasses,
std::cout, std::cerr,
fpattern, &files);
} else // given directory only
cam = new camera_directory<ubyte>(dir.c_str(), height, width,
input_random, npasses,
std::cout, std::cerr,
fpattern, &files);
} else if (!strcmp(cam_type.c_str(), "opencv"))
cam = new camera_opencv<ubyte>(-1, height, width);
#ifdef __LINUX__
else if (!strcmp(cam_type.c_str(), "v4l2"))
cam = new camera_v4l2<ubyte>(conf.get_cstring("device"),
height, width,
conf.exists_true("camera_grayscale"));
#endif
else if (!strcmp(cam_type.c_str(), "shmem"))
cam = new camera_shmem<ubyte>("shared-mem", height, width);
else if (!strcmp(cam_type.c_str(), "video")) {
if (argc >= 3)
cam = new camera_video<ubyte>
(argv[2], height, width, conf.get_uint("input_video_sstep"),
conf.get_uint("input_video_max_duration"));
else eblerror("expected 2nd argument");
} else eblerror("unknown camera type");
// a camera directory may be used first, then switching to regular cam
if (conf.exists_bool("precamera"))
cam2 = new camera_directory<ubyte>(conf.get_cstring("precamdir"),
height, width);
// answer variables & initializations
vector<bbox*> bboxes;
vector<bbox*>::iterator ibboxes;
ostringstream answer_fname;
mkdir_full(outdir);
answer_fname << outdir << "bbox.txt";
// open file
ofstream fp(answer_fname.str().c_str());
if (!fp) {
cerr << "failed to open " << answer_fname.str() << endl;
eblerror("open failed");
}
// gui
#ifdef __GUI__
display = conf.exists_bool("display");
mindisplay = conf.exists_bool("minimal_display");
display_sleep = conf.get_uint("display_sleep");
display_states = conf.exists_bool("display_states");
save_video = conf.exists_bool("save_video");
uint qstep1 = 0, qheight1 = 0, qwidth1 = 0,
qheight2 = 0, qwidth2 = 0, qstep2 = 0;
if (conf.exists_bool("queue1")) {
qstep1 = conf.get_uint("qstep1");
qheight1 = conf.get_uint("qheight1");
qwidth1 = conf.get_uint("qwidth1"); }
if (conf.exists_bool("queue2")) {
qstep2 = conf.get_uint("qstep2");
qheight2 = conf.get_uint("qheight2");
qwidth2 = conf.get_uint("qwidth2"); }
module_1_1_gui netgui;
wid_states = display_states ? new_window("network states"):0;
night_mode();
wid = display ? new_window("eblearn object recognition") : 0;
night_mode();
float zoom = 1;
detector_gui<fs(Tnet)> dgui(conf.exists_bool("queue1"), qstep1, qheight1,
qwidth1, conf.exists_bool("queue2"), qstep2,
qheight2, qwidth2);
if (bmask_class)
dgui.set_mask_class(conf.get_cstring("mask_class"),
(Tnet) conf.get_double("mask_threshold"));
if (save_video) {
string viddir = outdir;
viddir += "video";
cam->start_recording(wid, viddir.c_str());
}
#endif
// timing variables
timer tpass, toverall;
long ms;
// loop
toverall.start();
while(!cam->empty()) {
// get a new frame
tpass.restart();
// if the pre-camera is defined use it until empty
if (cam2 && !cam2->empty())
frame = cam2->grab();
else // empty pre-camera, use regular camera
frame = cam->grab();
string frame_name = cam->frame_name();
// run detector
if (!display) { // fprop without display
bboxes = detect.fprop(frame, threshold, frame_name.c_str());
}
#ifdef __GUI__
else { // fprop and display
disable_window_updates();
clear_window();
if (mindisplay)
bboxes = dgui.display(detect, frame, threshold, frame_name.c_str(),
0, 0, zoom, (Tnet)0, (Tnet)255, wid);
else
bboxes =
dgui.display_inputs_outputs(detect, frame, threshold,
frame_name.c_str(), 0, 0, zoom,
(Tnet)-1.1, (Tnet)1.1, wid);
enable_window_updates();
if (display_states) {
dgui.display_current(detect, frame, wid_states);
select_window(wid);
}
if (save_video)
cam->record_frame();
}
#endif
ms = tpass.elapsed_milliseconds();
cout << "processing: " << ms << " ms." << endl;
cout << "fps: " << cam->fps() << endl;
// save bounding boxes
for (ibboxes = bboxes.begin(); ibboxes != bboxes.end(); ++ibboxes) {
fp << cam->frame_name() << " " << (*ibboxes)->class_id << " "
<< (*ibboxes)->confidence << " ";
fp << (*ibboxes)->w0 << " " << (*ibboxes)->h0 << " ";
fp << (*ibboxes)->w0 + (*ibboxes)->width << " ";
fp << (*ibboxes)->h0 + (*ibboxes)->height << endl;
}
// sleep display
if (display_sleep > 0) {
cout << "sleeping for " << display_sleep << "ms." << endl;
millisleep(display_sleep);
}
if (conf.exists("save_max") &&
detect.get_total_saved() > conf.get_uint("save_max")) {
cout << "Reached max number of detections, exiting." << endl;
break ; // limit number of detection saves
}
}
cout << "Execution time: " << toverall.elapsed_minutes() <<" mins" <<endl;
if (save_video)
cam->stop_recording(conf.exists_bool("use_original_fps") ?
cam->fps() : conf.get_uint("save_video_fps"));
// free variables
if (net) delete net;
if (cam) delete cam;
// close files
fp.close();
#ifdef __GUI__
if (!conf.exists_true("no_gui_quit")) {
cout << "Closing windows..." << endl;
quit_gui(); // close all windows
cout << "Windows closed." << endl;
}
#endif
} eblcatcherror();
return 0;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
GimpRunMode run_mode = param[0].data.d_int32;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GdkScreen *screen = NULL;
gint32 image_ID;
static GimpParam values[2];
/* initialize the return of the status */
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
*nreturn_vals = 1;
*return_vals = values;
INIT_I18N ();
/* how are we running today? */
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data from a previous run */
gimp_get_data (PLUG_IN_PROC, &shootvals);
shootvals.window_id = 0;
/* Get information from the dialog */
if (! shoot_dialog (&screen))
status = GIMP_PDB_CANCEL;
break;
case GIMP_RUN_NONINTERACTIVE:
if (nparams == 3)
{
gboolean do_root = param[1].data.d_int32;
shootvals.shoot_type = do_root ? SHOOT_ROOT : SHOOT_WINDOW;
shootvals.window_id = param[2].data.d_int32;
shootvals.select_delay = 0;
}
else if (nparams == 7)
{
shootvals.shoot_type = SHOOT_REGION;
shootvals.window_id = param[2].data.d_int32;
shootvals.select_delay = 0;
shootvals.x1 = param[3].data.d_int32;
shootvals.y1 = param[4].data.d_int32;
shootvals.x2 = param[5].data.d_int32;
shootvals.y2 = param[6].data.d_int32;
}
else
{
status = GIMP_PDB_CALLING_ERROR;
}
if (! gdk_init_check (NULL, NULL))
status = GIMP_PDB_CALLING_ERROR;
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data from a previous run */
gimp_get_data (PLUG_IN_PROC, &shootvals);
break;
default:
break;
}
if (status == GIMP_PDB_SUCCESS)
{
if (shootvals.select_delay > 0)
shoot_delay (shootvals.select_delay);
if (shootvals.shoot_type != SHOOT_ROOT && ! shootvals.window_id)
{
shootvals.window_id = select_window (screen);
if (! shootvals.window_id)
status = GIMP_PDB_CANCEL;
}
}
if (status == GIMP_PDB_SUCCESS)
{
image_ID = shoot (screen);
if (image_ID == -1)
status = GIMP_PDB_EXECUTION_ERROR;
}
if (status == GIMP_PDB_SUCCESS)
{
if (run_mode == GIMP_RUN_INTERACTIVE)
{
/* Store variable states for next run */
gimp_set_data (PLUG_IN_PROC, &shootvals, sizeof (ScreenshotValues));
gimp_display_new (image_ID);
}
/* set return values */
*nreturn_vals = 2;
values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image_ID;
}
values[0].data.d_status = status;
}
void detection_thread<T>::execute() {
try {
bool display = false;
#ifdef __GUI__
display = conf.exists_true("display")
&& conf.exists_true("display_threads");
bool mindisplay = conf.exists_true("minimal_display");
bool save_video = conf.exists_true("save_video");
bool display_states = conf.exists_true("display_states");
uint wid = 0; // window id
uint wid_states = 0; // window id
#endif
uint display_sleep = conf.try_get_uint("display_sleep", 0);
// if (!display && save_video) {
// // we still want to output images but not show them
// display = true;
// #ifdef __GUI__
// set_gui_silent();
// #endif
// }
// load network and weights in a forward-only parameter
parameter<T> theparam;
theparam.set_forward_only();
idx<ubyte> classes(1,1);
//try { // try loading classes names but do not stop upon failure
load_matrix<ubyte>(classes, conf.get_cstring("classes"));
// } catch(std::string &err) {
// merr << "warning: " << err;
// merr << std::endl;
// }
std::vector<std::string> sclasses = ubyteidx_to_stringvector(classes);
answer_module<T> *ans = create_answer<T,T,T>(conf, classes.dim(0));
uint noutputs = ans->get_nfeatures();
intg thick = -1;
module_1_1<T> *net = create_network<T>(theparam, conf, thick, noutputs,
"arch", this->_id);
// loading weights
if (conf.exists("weights")) { // manual weights
// concatenate weights if multiple ones
std::vector<std::string> w =
string_to_stringvector(conf.get_string("weights"));
mout << "Loading weights from: " << w << std::endl;
theparam.load_x(w);
// permute weights by blocks
if (conf.exists("weights_permutation")) {
std::string sblocks = conf.get_string("weights_blocks");
std::string spermut = conf.get_string("weights_permutation");
std::vector<intg> blocks = string_to_intgvector(sblocks.c_str());
std::vector<uint> permut = string_to_uintvector(spermut.c_str());
theparam.permute_x(blocks, permut);
}
} else {
if (conf.exists_true("manual_load")) { // manual load
eblwarn("\"weights\" variable not defined, loading manually "
<< "if manual_load defined");
manually_load_network(*((layers<T>*)net), conf);
} else { // random weights
int seed = dynamic_init_drand();
eblwarn("No weights to load, randomizing weights with seed " << seed);
forget_param_linear fgp(1, 0.5, seed);
net->forget(fgp);
}
}
DEBUGMEM_PRETTY("before detection");
// detector
detector<T> detect(*net, sclasses, ans, NULL, NULL, mout, merr);
init_detector(detect, conf, outdir, silent);
// keep pointer to detector
pdetect = &detect;
bootstrapping<T> boot(conf);
// when a bbox file is given, ignore the processing, load the pre-computed
// bboxes and feed them to the nms (non-maximum suppression).
bboxes boxes(bbox_all, NULL, mout, merr);
boxes.print_saving_type(); // inform user how we save boxes
bool precomputed_boxes = false;
if (conf.exists("bbox_file")) {
precomputed_boxes = true;
std::string bbfile = conf.get_string("bbox_file");
boxes.load_eblearn(bbfile);
}
bool bmask_class = false;
if (conf.exists("mask_class"))
bmask_class = detect.set_mask_class(conf.get_cstring("mask_class"));
std::string viddir = outdir;
viddir += "video/";
mkdir_full(viddir);
// gui
#ifdef __GUI__
uint display_wmax = conf.try_get_uint("display_max_width", 3000);
T display_min = (T) conf.try_get_double("display_min", -1.7);
T display_max = (T) conf.try_get_double("display_max", 1.7);
T display_in_max = (T) conf.try_get_double("display_in_max", 255);
T display_in_min = (T) conf.try_get_double("display_in_min", 0);
float display_transp = conf.try_get_float("display_bb_transparency", 0);
uint qstep1 = conf.try_get_uint("qstep1", 0);
uint qheight1 = conf.try_get_uint("qheight1", 0);
uint qwidth1 = conf.try_get_uint("qwidth1", 0);
uint qstep2 = conf.try_get_uint("qstep2", 0);
uint qheight2 = conf.try_get_uint("qheight2", 0);
uint qwidth2 = conf.try_get_uint("qwidth2", 0);
module_1_1_gui netgui;
wid_states = display_states ? new_window("network states"):0;
night_mode();
std::string title = "EBLearn detector: ";
title += _name;
if (display) {
wid = new_window(title.c_str());
mout << "displaying in window " << wid << std::endl;
night_mode();
}
float zoom = conf.try_get_float("display_zoom", 1);
bool bbox_show_conf = !conf.exists_false("bbox_show_conf");
bool bbox_show_class = !conf.exists_false("bbox_show_class");
detector_gui<T>
dgui(conf.try_get_uint("show_extracted", 0),
conf.exists_bool("queue1"), qstep1, qheight1,
qwidth1, conf.exists_bool("queue2"), qstep2, qheight2, qwidth2,
bbox_show_class, bbox_show_conf);
if (bmask_class)
dgui.set_mask_class(conf.get_cstring("mask_class"),
(T) conf.try_get_double("mask_threshold", 0));
#endif
// timing variables
timer tpass, toverall;
long ms;
// loop
toverall.start();
// we're ready
bavailable = true;
while(!this->_stop) {
// wait until a new image is made available
while (!in_updated && !_stop) {
millisleep(1);
}
tpass.restart();
if (_stop) break ;
// we got a new frame, reset new frame flag
in_updated = false; // no need to lock mutex
// check if this frame should be skipped
if (boot.skip_frame(frame_name)) {
skip_frame();
continue ;
} else if (!frame_loaded) {
uframe = load_image<ubyte>(frame_fullname);
mout << "loaded image " << frame_fullname << std::endl;
}
if (!silent) mout << "processing " << frame_name << std::endl;
// check frame is correctly allocated, if not, allocate.
if (frame.order() != uframe.order())
frame = idx<T>(uframe.get_idxdim());
else if (frame.get_idxdim() != uframe.get_idxdim())
frame.resize(uframe.get_idxdim());
// copy frame
idx_copy(uframe, frame);
// run detector
if (!display) { // fprop without display
if (precomputed_boxes) {
try {
bboxes *bb = boxes.get_group(frame_name);
idxdim d = boxes.get_group_dims(frame_name);
d.insert_dim(0, 1);
bboxes pruned;
detect.init(d);
detect.fprop_nms(*bb, pruned);
copy_bboxes(pruned); // make a copy of bounding boxes
// resize frame so that caller knows the size of the frame
idxdim framedim = frame.get_idxdim();
if (d.dim(1) == -1 || d.dim(2) == -1)
eblerror("pre-computed boxes must contain full image size, "
<< "but found: " << d);
framedim.setdim(0, d.dim(1));
framedim.setdim(1, d.dim(2));
frame.resize(framedim);
} catch(eblexception &e) {
#ifdef __NOEXCEPTIONS__
merr << "exception" << std::endl;
#else
merr << e << std::endl;
#endif
}
} else {
try {
mout << "starting processing of frame " << frame_name << std::endl;
bboxes &bb = detect.fprop(frame, frame_name.c_str(), frame_id);
copy_bboxes(bb); // make a copy of bounding boxes
} catch(ebl::eblexception &e) { // detection failed
#ifdef __NOEXCEPTIONS__
eblwarn("detection failed");
#else
eblwarn("detection failed: " << e);
#endif
clear_bboxes();
}
}
}
#ifdef __GUI__
else { // fprop and display
if (precomputed_boxes) eblerror("not implemented for nms only (TODO)");
disable_window_updates();
select_window(wid);
clear_window();
std::string title = _name;
title << ": " << frame_name;
set_window_title(title.c_str());
// clear_resize_window();
try {
if (mindisplay) {
bboxes &bb =
dgui.display(detect, frame, frame_name.c_str(), frame_id,
0, 0, zoom, display_min, display_max,
wid, _name.c_str(), display_transp);
copy_bboxes(bb); // make a copy of bounding boxes
} else {
// extract & display boxes
bboxes &bb =
dgui.display_inputs_outputs(detect, frame, frame_name.c_str(),
frame_id, 0, 0, zoom,
display_min, display_max, wid,
_name.c_str(),
display_in_min, display_in_max,
display_transp, display_wmax);
// make a copy of bounding boxes
copy_bboxes(bb);
}
} catch(ebl::eblexception &e) { // detection failed
eblwarn("detection failed: " << e);
clear_bboxes();
}
enable_window_updates();
}
if (display_states) {
dgui.display_current(detect, frame, wid_states, NULL, zoom);
select_window(wid);
}
if (save_video && display) {
std::string fname = viddir;
fname += frame_name;
save_window(fname.c_str());
if (!silent) mout << "saved " << fname << std::endl;
}
#endif
if (!silent)
mout << "processing done for frame " << frame_name << std::endl;
// bootstrapping
if (conf.exists_true("bootstrapping")) {
boot.fprop(detect, frame_name);
// add multiple scales if positives and scales are defined
if (conf.exists("gt_scales") && boot.extract_positives()) {
std::vector<double> scales =
string_to_doublevector(conf.get_cstring("gt_scales"));
for (uint s = 0; s < scales.size(); ++s) {
double f = scales[s];
// downsample input by f
detect.set_resolution(f);
detect.init(frame.get_idxdim(), frame_name.c_str());
detect.fprop(frame, frame_name.c_str(), frame_id);
boot.fprop(detect, frame_name, false, f);
}
detect.set_scaling_original();
detect.init(frame.get_idxdim(), frame_name.c_str());
}
copy_bootstrapping(boot.get_all(), boot.get_bball());
#ifdef __GUI__
// display groundtruth
if (conf.exists_true("display_bootstrapping"))
dgui.display_groundtruth(detect, frame, boot.get_gtall(),
boot.get_gtclean(), boot.get_gtrest(),
boot.get_bbpos(), boot.get_bbneg(),
boot.get_pos(), boot.get_neg(), 0, 0, zoom,
display_min, display_max);
#endif
}
total_saved = detect.get_total_saved();
ms = tpass.elapsed_milliseconds();
if (!silent) {
mout << bbs.pretty_short(detect.get_labels());
mout << "processing=" << ms << " ms ("
<< tpass.elapsed() << ")" << std::endl;
}
DEBUGMEM_PRETTY("after detection");
// switch 'updated' flag on to warn we just added new data
set_out_updated();
// display sleep
if (display_sleep > 0) {
mout << "sleeping for " << display_sleep << "ms." << std::endl;
millisleep(display_sleep);
}
if (conf.exists("save_max") &&
detect.get_total_saved() > conf.get_uint("save_max"))
break ; // limit number of detection saves
}
mout << "detection finished. Execution time: " << toverall.elapsed()<<std::endl;
// free variables
if (net) delete net;
if (ans) delete ans;
} eblcatcherror();
}
void display_manufacture_menu()
{
if(manufacture_win < 0){
int our_root_win = -1;
if (!windows_on_top) {
our_root_win = game_root_win;
}
manufacture_win= create_window(win_manufacture, our_root_win, 0, manufacture_menu_x,
manufacture_menu_y, 0, 0, ELW_USE_UISCALE|ELW_WIN_DEFAULT);
set_window_handler(manufacture_win, ELW_HANDLER_DISPLAY, &display_manufacture_handler );
set_window_handler(manufacture_win, ELW_HANDLER_CLICK, &click_manufacture_handler );
set_window_handler(manufacture_win, ELW_HANDLER_MOUSEOVER, &mouseover_manufacture_slot_handler );
set_window_handler(manufacture_win, ELW_HANDLER_KEYPRESS, &keypress_manufacture_handler );
set_window_handler(manufacture_win, ELW_HANDLER_UI_SCALE, &ui_scale_manufacture_handler );
mixone_button_id=button_add_extended(manufacture_win, mixone_button_id, NULL,
0, 0, 0, 0, 0, 1.0f, 0.77f, 0.57f, 0.39f, ">");
widget_set_OnClick(manufacture_win, mixone_button_id, mixone_handler);
widget_set_OnMouseover(manufacture_win, mixone_button_id, mouseover_mixone_handler);
mixall_button_id=button_add_extended(manufacture_win, mixall_button_id, NULL,
0, 0, 0, 0, 0, 1.0f, 0.77f, 0.57f, 0.39f, ">>");
widget_set_OnClick(manufacture_win, mixall_button_id, mixall_handler);
widget_set_OnMouseover(manufacture_win, mixall_button_id, mouseover_mixall_handler);
clear_button_id=button_add_extended(manufacture_win, clear_button_id, NULL,
0, 0, 0, 0, 0, 1.0f, 0.77f, 0.57f, 0.39f, clear_str);
widget_set_OnClick(manufacture_win, clear_button_id, clear_handler);
if ((manufacture_win > -1) && (manufacture_win < windows_list.num_windows))
{
cm_add(windows_list.window[manufacture_win].cm_id, cm_manuwin_menu_str, NULL);
cm_bool_line(windows_list.window[manufacture_win].cm_id, ELW_CM_MENU_LEN+1, &disable_manuwin_keypress, NULL);
}
//Create a child window to show recipes in a dropdown panel
recipe_win= create_window("w_recipe", manufacture_win, 0, 0, 0, 0, 0,
ELW_USE_UISCALE|ELW_TITLE_NONE|ELW_SHOW|ELW_USE_BACKGROUND|ELW_ALPHA_BORDER|ELW_SWITCHABLE_OPAQUE|ELW_USE_BORDER|ELW_RESIZEABLE);
set_window_handler(recipe_win, ELW_HANDLER_DISPLAY, &recipe_dropdown_draw);
set_window_handler(recipe_win, ELW_HANDLER_CLICK, &recipe_dropdown_click_handler );
set_window_handler(recipe_win, ELW_HANDLER_MOUSEOVER, &mouseover_recipe_handler );
set_window_handler(recipe_win, ELW_HANDLER_RESIZE, &resize_recipe_handler );
set_window_handler(recipe_win, ELW_HANDLER_KEYPRESS, keypress_recipe_handler );
recipe_win_scroll_id = vscrollbar_add_extended(recipe_win, 1, NULL, 0,
0, 0, 0, 0, 1.0, 0.77f, 0.57f, 0.39f, 0, 1, num_recipe_entries-num_displayed_recipes);
if ((manufacture_win > -1) && (manufacture_win < windows_list.num_windows))
ui_scale_manufacture_handler(&windows_list.window[manufacture_win]);
// context menu
cm_recipewin = cm_create(cm_recipe_menu_str, context_recipe_handler);
cm_add_window(cm_recipewin, recipe_win);
cm_set_pre_show_handler(cm_recipewin, context_recipe_pre_show_handler);
hide_window(recipe_win); //start hidden
build_manufacture_list();
} else {
show_window(manufacture_win);
if (!recipes_shown) hide_window(recipe_win);
else show_window(recipe_win);
select_window(manufacture_win);
}
}
int click_in_windows(int _x, int _y, Uint32 flags)
{
int done= 0;
int id;
int next_id;
int first_win= 0;
int i;
// watch for needing to convert the globals into the flags
if(!flags){
if(shift_on) flags |= ELW_SHIFT;
if(ctrl_on) flags |= ELW_CTRL;
if(alt_on) flags |= ELW_ALT;
if(right_click) flags |= ELW_RIGHT_MOUSE;
if(middle_click) flags |= ELW_MID_MOUSE;
if(left_click) flags |= ELW_LEFT_MOUSE;
// TODO: centralized double click handling
// TODO: consider other ways of triggering double clieck, like middle click or shift click
//if(double_click) flags |= ELW_DBL_CLICK;
}
// check each window in the proper order
if(windows_list.display_level > 0)
{
id= 9999;
while(done <= 0)
{
next_id= 0;
for(i=1; i<windows_list.num_windows; i++){
// only look at displayed windows
if(windows_list.window[i].displayed > 0){
// at this level?
if(windows_list.window[i].order == id){
done= click_in_window(i, _x, _y, flags);
if(done > 0){
if(windows_list.window[i].displayed > 0) select_window(i); // select this window to the front
return i;
}
if(first_win == 0 && mouse_in_window(i, _x, _y)) first_win= i;
} else if(windows_list.window[i].order < id && windows_list.window[i].order > next_id){
// try to find the next level
next_id= windows_list.window[i].order;
}
}
}
if(next_id <= 0)
{
break;
}
else
{
id= next_id;
}
}
}
// now check the background windows in the proper order
id= -9999;
while(done <= 0)
{
next_id= 0;
for(i=1; i<windows_list.num_windows; i++){
// only look at displayed windows
if(windows_list.window[i].displayed > 0){
// at this level?
if(windows_list.window[i].order == id){
done= click_in_window(i, _x, _y, flags);
if(done > 0){
//select_window(i); // these never get selected
return i;
}
} else if(windows_list.window[i].order > id && windows_list.window[i].order < next_id){
// try to find the next level
next_id= windows_list.window[i].order;
}
}
}
if(next_id >= 0)
{
break;
}
else
{
id= next_id;
}
}
// nothing to click on, do a select instead
if(first_win > 0)
{
select_window(first_win);
return 1;
}
return 0; // no click in a window
}
