void HoughDetector::DetectPyramid(const cv::Mat img, std::vector<std::vector<cv::Mat> >& hough_maps, std::vector<std::vector<cv::MatND> >& hough_pose_maps, std::vector<std::vector<std::vector<std::vector<Vote> > > >& vBackprojections, cv::Rect ROI, int index)
{
if (img.channels() == 1)
throw std::logic_error("Gray color images are not supported");
else
{
// iterate the scales
for (size_t i = 0; i < hough_maps.size(); i++)
{
cv::Mat cLevel;
cv::Size scale_size(int(img.cols*m_apphp->test_scales[i]+0.5), int(img.rows*m_apphp->test_scales[i]+0.5));
cv::resize(img, cLevel, scale_size, 0.0, 0.0, cv::INTER_LINEAR);
this->DetectImage(cLevel, hough_maps[i], hough_pose_maps[i], vBackprojections[i], ROI, index);
}
}
}
void DenseGaussKernel(float sigma, const Mat &x,const Mat &y, Mat &k){
Mat xf, yf;
dft(x, xf, DFT_COMPLEX_OUTPUT);
dft(y, yf, DFT_COMPLEX_OUTPUT);
double xx = norm(x);
xx = xx*xx;
double yy = norm(y);
yy = yy*yy;
Mat xyf;
mulSpectrums(xf, yf, xyf, 0, true);
Mat xy;
cv::idft(xyf, xy, cv::DFT_SCALE | cv::DFT_REAL_OUTPUT); // Applying IDFT
CircShift(xy, scale_size(x.size(),0.5));
double numelx1 = x.cols*x.rows;
//exp((-1 / (sigma*sigma)) * abs((xx + yy - 2 * xy) / numelx1), k); //thsi setting is fixed by version 2(KCF)
exp((-1 / (sigma*sigma)) * max(0,(xx + yy - 2 * xy) / numelx1), k);
}
void create_mounts(char *user, char *group, char *base, mode_t mode)
{
struct hpage_pool pools[MAX_POOLS];
char path[PATH_MAX];
char options[OPT_MAX];
char limits[OPT_MAX];
char scaled[OPT_MAX];
int cnt, pos;
struct passwd *pwd;
struct group *grp;
uid_t uid = 0;
gid_t gid = 0;
if (geteuid() != 0) {
ERROR("Mounts can only be created by root\n");
exit(EXIT_FAILURE);
}
if (user) {
pwd = getpwnam(user);
if (!pwd) {
ERROR("Could not find specified user %s\n", user);
exit(EXIT_FAILURE);
}
uid = pwd->pw_uid;
} else if (group) {
grp = getgrnam(group);
if (!grp) {
ERROR("Could not find specified group %s\n", group);
exit(EXIT_FAILURE);
}
gid = grp->gr_gid;
}
if (ensure_dir(base,
S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH, 0, 0))
exit(EXIT_FAILURE);
cnt = hpool_sizes(pools, MAX_POOLS);
if (cnt < 0) {
ERROR("Unable to obtain pools list\n");
exit(EXIT_FAILURE);
}
for (pos=0; cnt--; pos++) {
scaled[0] = 0;
scale_size(scaled, pools[pos].pagesize);
if (user)
snprintf(path, PATH_MAX, "%s/%s/pagesize-%s",
base, user, scaled);
else if (group)
snprintf(path, PATH_MAX, "%s/%s/pagesize-%s",
base, group, scaled);
else
snprintf(path, PATH_MAX, "%s/pagesize-%s",
base, scaled);
snprintf(options, OPT_MAX, "pagesize=%ld",
pools[pos].pagesize);
/* Yes, this could be cleverer */
if (opt_limit_mount_size && opt_limit_mount_inodes)
snprintf(limits, OPT_MAX, ",size=%lu,nr_inodes=%d",
opt_limit_mount_size, opt_limit_mount_inodes);
else {
if (opt_limit_mount_size)
snprintf(limits, OPT_MAX, ",size=%lu",
opt_limit_mount_size);
if (opt_limit_mount_inodes)
snprintf(limits, OPT_MAX, ",nr_inodes=%d",
opt_limit_mount_inodes);
}
/* Append limits if specified */
if (limits[0] != 0) {
size_t maxlen = OPT_MAX - strlen(options);
if (maxlen > strlen(limits))
strcat(options, limits);
else
WARNING("String limitations met, cannot append limitations onto mount options string. Increase OPT_MAX");
}
if (ensure_dir(path, mode, uid, gid))
exit(EXIT_FAILURE);
if (mount_dir(path, options, mode, uid, gid))
exit(EXIT_FAILURE);
}
}
int main(int argc, char **argv)
{
int exit_status = 0;
char header[HEADER_BUFFER_SIZE];
size_t header_length =
snprintf(
header,
sizeof(header),
"%-*s %-*s %-*s %-*s %-*s %-*s %*s %*s %*s "
"%*s %*s %*s %*s %*s %*s\n",
PID_Column_Width, PID_Column_Name,
PPID_Column_Width, PPID_Column_Name,
Name_Column_Width, Name_Column_Name,
UID_Column_Width, UID_Column_Name,
GID_Column_Width, GID_Column_Name,
State_Column_Width, State_Column_Name,
Nice_Column_Width, Nice_Column_Name,
UTime_Column_Width, UTime_Column_Name,
KTime_Column_Width, KTime_Column_Name,
RSS_Column_Width, RSS_Column_Name,
VM_Column_Width, VM_Column_Name,
Reads_Column_Width, Reads_Column_Name,
Writes_Column_Width, Writes_Column_Name,
Read_Column_Width, Read_Column_Name,
Written_Column_Width, Written_Column_Name
);
pid_t *pid_list = NULL;
char total_ram_scaled[FIELD_BUFFER_SIZE];
char used_ram_scaled[FIELD_BUFFER_SIZE];
char free_ram_scaled[FIELD_BUFFER_SIZE];
char total_swap_scaled[FIELD_BUFFER_SIZE];
char used_swap_scaled[FIELD_BUFFER_SIZE];
char free_swap_scaled[FIELD_BUFFER_SIZE];
char user_cpu_time_scaled[FIELD_BUFFER_SIZE];
char kernel_cpu_time_scaled[FIELD_BUFFER_SIZE];
char core_memory_usage_scaled[FIELD_BUFFER_SIZE];
char virtual_memory_usage_scaled[FIELD_BUFFER_SIZE];
char data_read_scaled[FIELD_BUFFER_SIZE];
char data_written_scaled[FIELD_BUFFER_SIZE];
bool show_kernel_threads = false;
if (!initscr()) {
fprintf(
stderr,
"Failed to create the program's UI.\n"
);
exit_status =
EXIT_FAILURE;
goto cleanup;
}
if (has_colors()) {
start_color();
use_default_colors();
init_pair(1, COLOR_BLACK, COLOR_WHITE);
}
noecho();
halfdelay(Input_Delay);
WINDOW *header_pad = newpad(1, header_length);
if (!header_pad) {
fprintf(
stderr,
"Failed to create a UI pad for a header.\n"
);
exit_status =
EXIT_FAILURE;
goto cleanup;
}
bool has_attribute = false;
if (has_colors()) {
wattron(header_pad, COLOR_PAIR(1));
has_attribute =
!has_attribute;
}
waddstr(header_pad, header);
if (has_attribute) {
wattroff(header_pad, COLOR_PAIR(1));
}
WINDOW *pad = NULL;
int pad_height = -1;
int pad_shift_y = 0;
int pad_shift_x = 0;
WINDOW *footer_pad = newpad(1, header_length);
if (!footer_pad) {
fprintf(
stderr,
"Failed to create a UI pad for a footer.\n"
);
exit_status =
EXIT_FAILURE;
goto cleanup;
}
wprintw(
footer_pad,
"Press 't' to %s kernel threads. Press 'q' to exit.",
show_kernel_threads ?
"hide" : "show"
);
for (;;) {
pid_t current_pid =
getpid();
struct sysinfo system;
if (sysinfo(&system)) {
fprintf(
stderr,
"Failed to perform the 'sysinfo' system call.\n"
);
exit_status =
EXIT_FAILURE;
goto cleanup;
}
long pid_list_length = syscall(__NR_get_pids, 0, NULL);
if (pid_list_length <= 0) {
fprintf(
stderr,
"Failed to perform the 'get_pids' system call. "
"Ensure that the 'task_info' subsystem was compiled "
"into the kernel.\n"
);
exit_status =
EXIT_FAILURE;
goto cleanup;
}
size_t pid_list_size = pid_list_length * sizeof(*pid_list);
if (!(pid_list = realloc(pid_list, pid_list_size))) {
fprintf(stderr, "Failed to reserve memory.\n");
exit_status =
EXIT_FAILURE;
goto cleanup;
}
memset(pid_list, 0, pid_list_size);
if (syscall(__NR_get_pids, pid_list_length, pid_list) <= 0) {
fprintf(
stderr,
"Failed to perform the 'get_pids' system call. "
"Ensure that the 'task_info' subsystem was compiled "
"into the kernel.\n"
);
exit_status =
EXIT_FAILURE;
goto cleanup;
}
if (pad_height != pid_list_length + 1) {
pad_height =
pid_list_length + 1;
if (pad) {
delwin(pad);
}
pad = newpad(pad_height, header_length);
if (!pad) {
fprintf(
stderr,
"Failed to create a scrollable UI pad.\n"
);
exit_status =
EXIT_FAILURE;
goto cleanup;
}
keypad(pad, true);
}
size_t header_height =
Header_Height;
unsigned long uptime_days =
system.uptime / 86400;
unsigned long uptime_hours =
system.uptime / 3600 -
uptime_days * 24;
unsigned long uptime_minutes =
system.uptime / 60 -
uptime_days * 1440 -
uptime_hours * 60;
unsigned long uptime_seconds =
system.uptime % 60;
float load_average_scale =
1 << SI_LOAD_SHIFT;
float load_average_for_1_minute =
system.loads[0] / load_average_scale;
float load_average_for_5_minutes =
system.loads[1] / load_average_scale;
float load_average_for_15_minutes =
system.loads[1] / load_average_scale;
uint64_t total_ram =
system.totalram * system.mem_unit;
uint64_t used_ram =
(system.totalram - system.freeram) * system.mem_unit;
uint64_t free_ram =
system.freeram * system.mem_unit;
uint64_t total_swap =
system.totalswap * system.mem_unit;
uint64_t used_swap =
(system.totalswap - system.freeswap) * system.mem_unit;
uint64_t free_swap =
system.freeswap * system.mem_unit;
scale_size(
total_ram,
total_ram_scaled,
sizeof(total_ram_scaled)
);
scale_size(
used_ram,
used_ram_scaled,
sizeof(used_ram_scaled)
);
scale_size(
free_ram,
free_ram_scaled,
sizeof(free_ram_scaled)
);
scale_size(
total_swap,
total_swap_scaled,
sizeof(total_swap_scaled)
);
scale_size(
used_swap,
used_swap_scaled,
sizeof(used_swap_scaled)
);
scale_size(
free_swap,
free_swap_scaled,
sizeof(free_swap_scaled)
);
wredrawln(stdscr, 0, header_height);
mvprintw(
0, 0,
"up for %lu %s %lu:%lu:%lu, tasks: %zu\n"
"load average: %.2f, %.2f, %.2f\n"
"\n"
"total ram: %*s, used ram: %*s, free ram: %*s\n"
"total swap: %*s, used swap: %*s, free swap: %*s\n",
uptime_days,
uptime_days == 1 ?
"day" : "days",
uptime_hours,
uptime_minutes,
uptime_seconds,
pid_list_length,
load_average_for_1_minute,
load_average_for_5_minutes,
load_average_for_15_minutes,
Memory_Column_Width,
total_ram_scaled,
Memory_Column_Width,
used_ram_scaled,
Memory_Column_Width,
free_ram_scaled,
Memory_Column_Width,
total_swap_scaled,
Memory_Column_Width,
used_swap_scaled,
Memory_Column_Width,
free_swap_scaled
);
werase(pad);
int real_pad_height = 0;
for (size_t i = 0; i < pid_list_length; ++i) {
struct task_info task;
pid_t pid = pid_list[i];
if (syscall(__NR_get_task_info, pid, &task) == 0) {
if (!show_kernel_threads &&
(task.pid == Kernel_Thread_Daemon_PID ||
task.ppid == Kernel_Thread_Daemon_PID)) {
continue;
}
const char *task_state =
task.state < Task_States_Count - 1 ?
Task_States[task.state + 1] :
Task_States[0];
scale_time(
task.user_cpu_time,
user_cpu_time_scaled,
sizeof(user_cpu_time_scaled)
);
scale_time(
task.system_cpu_time,
kernel_cpu_time_scaled,
sizeof(kernel_cpu_time_scaled)
);
scale_size(
task.core_memory_bytes_used,
core_memory_usage_scaled,
sizeof(core_memory_usage_scaled)
);
scale_size(
task.virtual_memory_bytes_used,
virtual_memory_usage_scaled,
sizeof(virtual_memory_usage_scaled)
);
scale_size(
task.bytes_read,
data_read_scaled,
sizeof(data_read_scaled)
);
scale_size(
task.bytes_written,
data_written_scaled,
sizeof(data_written_scaled)
);
has_attribute = false;
if (has_colors()) {
if (task.state == 0 &&
task.pid != current_pid) {
wattron(pad, COLOR_PAIR(1));
has_attribute =
!has_attribute;
}
}
wprintw(
pad,
"%-*d %-*d %-*s %-*d %-*d %-*s %*d "
"%*s %*s %*s %*s "
"%*"PRIu64" %*"PRIu64" "
"%*s %*s\n",
PID_Column_Width, (int) pid,
PPID_Column_Width, task.ppid,
Name_Column_Width, task.name,
UID_Column_Width, task.uid,
GID_Column_Width, task.gid,
State_Column_Width, task_state,
Nice_Column_Width, task.nice_level,
UTime_Column_Width, user_cpu_time_scaled,
KTime_Column_Width, kernel_cpu_time_scaled,
RSS_Column_Width, core_memory_usage_scaled,
VM_Column_Width, virtual_memory_usage_scaled,
Reads_Column_Width, task.read_syscalls_count,
Writes_Column_Width, task.write_syscalls_count,
Read_Column_Width, data_read_scaled,
Written_Column_Width, data_written_scaled
);
if (has_attribute) {
wattroff(pad, COLOR_PAIR(1));
}
++real_pad_height;
}
}
int window_height, window_width;
getmaxyx(stdscr, window_height, window_width);
wnoutrefresh(stdscr);
prefresh(
header_pad,
0, pad_shift_x,
header_height, 0,
header_height + 1, window_width - 1
);
prefresh(
pad,
pad_shift_y, pad_shift_x,
header_height + 1, 0,
window_height - 2, window_width - 1
);
prefresh(
footer_pad,
0, 0,
window_height - 1, 0,
window_height, window_width - 1
);
doupdate();
int key = wgetch(pad);
if (key != ERR) {
switch (key) {
case 'h':
case KEY_LEFT:
--pad_shift_x;
break;
case 'j':
case KEY_DOWN:
++pad_shift_y;
break;
case 'k':
case KEY_UP:
--pad_shift_y;
break;
case 'l':
case KEY_RIGHT:
++pad_shift_x;
break;
case 't':
show_kernel_threads =
!show_kernel_threads;
werase(footer_pad);
wprintw(
footer_pad,
"Press 't' to %s kernel threads. "
"Press 'q' to exit.",
show_kernel_threads ?
"hide" : "show"
);
break;
case 'q':
goto cleanup;
}
int pad_height_limit =
real_pad_height - 2;
if (pad_shift_y < 0) {
pad_shift_y = 0;
} else if (pad_shift_y >
pad_height_limit) {
pad_shift_y =
pad_height_limit;
}
int pad_width_limit =
header_length - 5;
if (pad_shift_x < 0) {
pad_shift_x = 0;
} else if (pad_shift_x >
pad_width_limit) {
pad_shift_x =
pad_width_limit;
}
}
}
cleanup:
if (header_pad) {
delwin(header_pad);
}
if (pad) {
delwin(pad);
}
if (footer_pad) {
delwin(footer_pad);
}
endwin();
return exit_status;
}
