Exemplo n.º 1
0
int main(int argc, char** argv) {

    CreateAllInterfaces();

    signal(SIGTERM, catch_signal);
    signal(SIGINT, catch_signal);
    signal(SIGHUP, catch_signal);

    print_menu();

    char last_command = '?';
    while (!quit) {

        char command [200];
        std::cin.getline(command, sizeof(command));


#if 0
        if (command == NULL) {
            print_menu();
            continue;
        }
#endif

        collect_messages();

        switch((command[0] == 0) ? last_command : command[0]) {
        case 'l':
            list_devices();
            break;
        case 's':
            print_status();
            break;
        case 'c':
            send_command(command+1);
            break;
        case 'q':
            quit = true;
            break;
        case '?':
        default:
            print_menu();
            break;
        }

        assert(command!=NULL);

        if(command[0] != 0)
            last_command = command[0];

    }

    CloseAllDevices();
    CloseAllInterfaces();

    return 0;

}
Exemplo n.º 2
0
// multiscale belief propagation for image restoration
cv::Mat interp_ms(
    cv::Mat seed, int values, int iters, int levels, int min_level, float smooth,
    float seed_weight, float seed_max, float disc_max)
{
    volume<float> *u[levels];
    volume<float> *d[levels];
    volume<float> *l[levels];
    volume<float> *r[levels];
    volume<float> *data[levels];

    // data costs
    data[0] = comp_data(seed, values, seed_weight, seed_max, smooth);

    // data pyramid
    for (int i = 1; i < levels; i++) {
        int old_width = data[i-1]->width();
        int old_height = data[i-1]->height();
        int new_width = (int)ceil(old_width/2.0);
        int new_height = (int)ceil(old_height/2.0);

        assert(new_width >= 1);
        assert(new_height >= 1);

        data[i] = new volume<float>(new_width, new_height, values);
        for (int y = 0; y < old_height; y++) {
            for (int x = 0; x < old_width; x++) {
                for (int value = 0; value < values; value++) {
                    (*data[i])(x/2, y/2, value) += (*data[i-1])(x, y, value);
                }
            }
        }
    }

    // run bp from coarse to fine
    for (int i = levels-1; i >= 0; i--) {
        int width = data[i]->width();
        int height = data[i]->height();

        // allocate & init memory for messages
        if (i == levels-1) {
            // in the coarsest level messages are initialized to zero
            u[i] = new volume<float>(width, height, values);
            d[i] = new volume<float>(width, height, values);
            l[i] = new volume<float>(width, height, values);
            r[i] = new volume<float>(width, height, values);
        } else {
            // initialize messages from values of previous level
            u[i] = new volume<float>(width, height, values, false);
            d[i] = new volume<float>(width, height, values, false);
            l[i] = new volume<float>(width, height, values, false);
            r[i] = new volume<float>(width, height, values, false);

            for (int y = 0; y < height; y++) {
                for (int x = 0; x < width; x++) {
                    for (int value = 0; value < values; value++) {
                        (*u[i])(x, y, value) = (*u[i+1])(x/2, y/2, value);
                        (*d[i])(x, y, value) = (*d[i+1])(x/2, y/2, value);
                        (*l[i])(x, y, value) = (*l[i+1])(x/2, y/2, value);
                        (*r[i])(x, y, value) = (*r[i+1])(x/2, y/2, value);
                    }
                }
            }
            // delete old messages and data
            delete u[i+1];
            delete d[i+1];
            delete l[i+1];
            delete r[i+1];
            delete data[i+1];
        }

        if (i >= min_level) {
            // BP
            bp_cb(*u[i], *d[i], *l[i], *r[i], *data[i], iters, disc_max);
        }
    }

    collect_messages(*u[0], *d[0], *l[0], *r[0], *data[0]);

    delete u[0];
    delete d[0];
    delete l[0];
    delete r[0];

    cv::Mat out = max_value(*data[0]);

    delete data[0];
    return out;
}