int main(int argc, char** argv) {
int i, ret;
int nerrors[NUMBER_OF_DIFFERENT_SYNTAXES + 1];
/* argtable setup */
/* SYNTAX 1: [--info] */
info1 = arg_lit1(NULL, "info", "Show information about the FLI filterwheel");
end1 = arg_end(20);
void * argtable1[] = {info1, end1};
argtable[1] = argtable1;
/* SYNTAX 2: [--set-filter] */
setfilter2 = arg_int1(NULL, "set-filter", "N", "Set the filter N");
end2 = arg_end(20);
void * argtable2[] = {setfilter2, end2};
argtable[2] = argtable2;
/* SYNTAX 3: [--home] */
home3 = arg_lit1(NULL, "home", "Homes the filterwheel");
end3 = arg_end(20);
void * argtable3[] = {home3, end3};
argtable[3] = argtable3;
/* SYNTAX 4: [--help]*/
help4 = arg_lit1(NULL, "help", "Print this help");
end4 = arg_end(20);
void * argtable4[] = {help4, end4};
argtable[4] = argtable4;
/* verify all argtable[] entries were allocated successfully */
for (i = 1; i <= NUMBER_OF_DIFFERENT_SYNTAXES; i++) {
if (arg_nullcheck(argtable[i]) != 0) {
printf("%s: insufficient memory\n", progname);
return EXIT_FAILURE;
}
}
/* parse all argument possibilities */
for (i = 1; i <= NUMBER_OF_DIFFERENT_SYNTAXES; i++) {
nerrors[i] = arg_parse(argc, argv, argtable[i]);
}
/* select the right command */
/* --info */
if (nerrors[1] == 0) {
if (info1->count > 0) {
ret = filter_info();
if (ret) return ret;
return 0;
}
/* --set-filter */
} else if (nerrors[2] == 0) {
if (setfilter2->count > 0) {
ret = filter_set_filter(setfilter2->ival[0]);
if (ret) return ret;
return 0;
}
/* --home */
} else if (nerrors[3] == 0) {
if (home3->count > 0) {
ret = filter_home(1);
if (ret) return ret;
return 0;
}
/* --help */
} else if (nerrors[4] == 0) {
if (help4) {
ret = argtable_help(progname, NUMBER_OF_DIFFERENT_SYNTAXES, argtable);
if (ret) return ret;
return 0;
}
/* incorrect or partially incorrect argument syntaxes */
} else {
if (setfilter2->count > 0) {
arg_print_errors(stdout, end2, progname);
printf("usage: %s ", progname);
arg_print_syntax(stdout, argtable2, "\n");
} else {
printf("%s: unable to parse arguments, see syntax below:\n", progname);
ret = argtable_help(progname, NUMBER_OF_DIFFERENT_SYNTAXES, argtable);
if (ret) return ret;
return 0;
}
return EXIT_FAILURE;
}
/* no command line options at all */
printf("Try '%s --help' for more information.\n", progname);
return (EXIT_SUCCESS);
}
//' @title Discrete Wavelet Transform
//' @description Calculation of the coefficients for the discrete wavelet transformation.
//' @param x A \code{vector} with dimensions \eqn{N\times 1}{N x 1}.
//' @param filter_name A \code{string} indicating the filter.
//' @param nlevels An \code{integer}, \eqn{J}, indicating the level of the decomposition.
//' @param boundary A \code{string} indicating the type of boundary method to use. Either \code{boundary="periodic"} or \code{"reflection"}.
//' @param brickwall A \code{bool} indicating whether the a brick wall procedure should be applied to the coefficients.
//' @return y A \code{field<vec>} that contains the wavelet coefficients for each decomposition level
//' @details
//' Performs a level J decomposition of the time series using the pyramid algorithm
//' @author JJB
//' @keywords internal
//' @examples
//' set.seed(999)
//' x = rnorm(2^8)
//' dwt_cpp(x, filter_name = "haar", nlevels = 4, boundary = "periodic", brickwall = TRUE)
// [[Rcpp::export]]
arma::field<arma::vec> dwt_cpp(arma::vec x, std::string filter_name,
unsigned int nlevels, std::string boundary, bool brickwall) {
if(boundary == "periodic"){
//
}else if(boundary == "reflection"){
unsigned int temp_N = x.n_elem;
arma::vec rev_vec = reverse_vec(x);
x.resize(2*temp_N);
x.rows(temp_N, 2*temp_N-1) = rev_vec;
}else{
Rcpp::stop("The supplied 'boundary' argument is not supported! Choose either periodic or reflection.");
}
unsigned int N = x.n_elem;
unsigned int J = nlevels;
unsigned int tau = pow(2,J);
if(double(N)/double(tau) != floor(double(N)/double(tau))){
Rcpp::stop("The supplied sample size ('x') must be divisible by 2^(nlevels). Either truncate or expand the number of samples.");
}
if(tau > N){
Rcpp::stop("The number of levels [ 2^(nlevels) ] exceeds sample size ('x'). Supply a lower number of levels.");
}
arma::field<arma::vec> filter_info = select_filter(filter_name);
int L = arma::as_scalar(filter_info(0));
arma::vec h = filter_info(1); //check the pulls
arma::vec g = filter_info(2);
arma::field<arma::vec> y(J);
for(unsigned int j = 1; j <= J; j++) {
unsigned int M = N/pow(2,(j-1));
unsigned int M_over_2 = double(M)/2;
arma::vec Wj(M_over_2);
arma::vec Vj(M_over_2);
for(unsigned t = 0; t < M_over_2; t++) {
int u = 2*t + 1;
double Wjt = h(0)*x(u);
double Vjt = g(0)*x(u);
for(int n = 1; n < L; n++){
u -= 1;
if(u < 0){
u = M - 1;
}
Wjt += h(n)*x(u);
Vjt += g(n)*x(u);
}
Wj[t] = Wjt;
Vj[t] = Vjt;
}
y(j-1) = Wj;
x = Vj;
}
// Apply brickwall
if(brickwall){
y = brick_wall(y, filter_info, "dwt");
}
return y;
}
void
filter_save_options(PANEL *panel)
{
char field_value[30];
char *expr;
int field_id;
char method_expr[256];
// Initialize variables
memset(method_expr, 0, sizeof(method_expr));
// Get panel information
filter_info_t *info = filter_info(panel);
for (field_id = 0; field_id < FLD_FILTER_COUNT; field_id++) {
// Get current field value.
// We trim spaces with sscanf because and empty field is stored as
// space characters
memset(field_value, 0, sizeof(field_value));
strcpy(field_value, field_buffer(info->fields[field_id], 0));
strtrim(field_value);
// Set filter expression
expr = strlen(field_value) ? field_value : NULL;
switch (field_id) {
case FLD_FILTER_SIPFROM:
filter_set(FILTER_SIPFROM, expr);
break;
case FLD_FILTER_SIPTO:
filter_set(FILTER_SIPTO, expr);
break;
case FLD_FILTER_SRC:
filter_set(FILTER_SOURCE, expr);
break;
case FLD_FILTER_DST:
filter_set(FILTER_DESTINATION, expr);
break;
case FLD_FILTER_PAYLOAD:
filter_set(FILTER_PAYLOAD, expr);
break;
case FLD_FILTER_REGISTER:
case FLD_FILTER_INVITE:
case FLD_FILTER_SUBSCRIBE:
case FLD_FILTER_NOTIFY:
case FLD_FILTER_OPTIONS:
case FLD_FILTER_PUBLISH:
case FLD_FILTER_MESSAGE:
if (!strcmp(field_value, "*")) {
if (strlen(method_expr)) {
sprintf(method_expr + strlen(method_expr), ",%s", filter_field_method(field_id));
} else {
strcpy(method_expr, filter_field_method(field_id));
}
}
break;
default:
break;
}
}
// Set Method filter
filter_method_from_setting(method_expr);
// Force filter evaluation
filter_reset_calls();
// TODO FIXME Refresh call list FIXME
call_list_clear(ui_get_panel(ui_find_by_type(PANEL_CALL_LIST)));
}
//' @title Maximum Overlap Discrete Wavelet Transform
//' @description
//' Calculation of the coefficients for the discrete wavelet transformation
//' @inheritParams dwt_cpp
//' @return y A \code{field<vec>} that contains the wavelet coefficients for each decomposition level
//' @keywords internal
//' @details
//' Performs a level J decomposition of the time series using the pyramid algorithm.
//' Use this implementation to supply custom parameters instead of modwt(x),
//' which serves as a wrapper function.
//' @author JJB
//' @keywords internal
//' @examples
//' set.seed(999)
//' x = rnorm(100)
//' modwt_cpp(x, filter_name = "haar", nlevels = 4, boundary = "periodic", brickwall = TRUE)
// [[Rcpp::export]]
arma::field<arma::vec> modwt_cpp(arma::vec x, std::string filter_name,
unsigned int nlevels, std::string boundary, bool brickwall){
if(boundary == "periodic"){
//
}else if(boundary == "reflection"){
unsigned int temp_N = x.n_elem;
arma::vec rev_vec = reverse_vec(x);
x.resize(2*temp_N);
x.rows(temp_N, 2*temp_N-1) = rev_vec;
}else{
Rcpp::stop("The supplied 'boundary' argument is not supported! Choose either periodic or reflection.");
}
unsigned int N = x.n_elem;
unsigned int J = nlevels;
unsigned int tau = pow(2,J);
if(tau > N) Rcpp::stop("The number of levels [ 2^(nlevels) ] exceeds sample size ('x'). Supply a lower number of levels.");
arma::field<arma::vec> filter_info = select_filter(filter_name);
int L = arma::as_scalar(filter_info(0));
arma::vec ht = filter_info(1);
arma::vec gt = filter_info(2);
// modwt transform
double transform_factor = sqrt(2);
ht /= transform_factor;
gt /= transform_factor;
arma::field<arma::vec> y(J);
arma::vec Wj(N);
arma::vec Vj(N);
for(unsigned int j = 1; j <= J; j++) {
for(unsigned t = 0; t < N; t++) {
int k = t;
double Wjt = ht(0)*x(k);
double Vjt = gt(0)*x(k);
for(int n = 1; n < L; n++){
k -= pow(2, j-1);
if(k < 0){
k += N;
}
Wjt += ht(n)*x(k);
Vjt += gt(n)*x(k);
}
Wj[t] = Wjt;
Vj[t] = Vjt;
}
y(j-1) = Wj;
x = Vj;
}
// Apply brickwall
if(brickwall){
y = brick_wall(y, filter_info, "modwt");
}
return y;
}
int
filter_handle_key(PANEL *panel, int key)
{
int field_idx;
char field_value[30];
int action = -1;
// Get panel information
filter_info_t *info = filter_info(panel);
// Get current field id
field_idx = field_index(current_field(info->form));
// Get current field value.
// We trim spaces with sscanf because and empty field is stored as
// space characters
memset(field_value, 0, sizeof(field_value));
strcpy(field_value, field_buffer(current_field(info->form), 0));
strtrim(field_value);
// Check actions for this key
while ((action = key_find_action(key, action)) != ERR) {
// Check if we handle this action
switch (action) {
case ACTION_PRINTABLE:
// If this is a normal character on input field, print it
if (field_idx == FLD_FILTER_SIPFROM || field_idx == FLD_FILTER_SIPTO
|| field_idx == FLD_FILTER_SRC || field_idx == FLD_FILTER_DST
|| field_idx == FLD_FILTER_PAYLOAD) {
form_driver(info->form, key);
break;
}
continue;
case ACTION_NEXT_FIELD:
form_driver(info->form, REQ_NEXT_FIELD);
form_driver(info->form, REQ_END_LINE);
break;
case ACTION_PREV_FIELD:
form_driver(info->form, REQ_PREV_FIELD);
form_driver(info->form, REQ_END_LINE);
break;
case ACTION_RIGHT:
form_driver(info->form, REQ_RIGHT_CHAR);
break;
case ACTION_LEFT:
form_driver(info->form, REQ_LEFT_CHAR);
break;
case ACTION_BEGIN:
form_driver(info->form, REQ_BEG_LINE);
break;
case ACTION_END:
form_driver(info->form, REQ_END_LINE);
break;
case ACTION_CLEAR:
form_driver(info->form, REQ_CLR_FIELD);
break;
case KEY_DC:
form_driver(info->form, REQ_DEL_CHAR);
break;
case ACTION_DELETE:
form_driver(info->form, REQ_DEL_CHAR);
break;
case ACTION_BACKSPACE:
if (strlen(field_value) > 0)
form_driver(info->form, REQ_DEL_PREV);
break;
case ACTION_SELECT:
switch (field_idx) {
case FLD_FILTER_REGISTER:
case FLD_FILTER_INVITE:
case FLD_FILTER_SUBSCRIBE:
case FLD_FILTER_NOTIFY:
case FLD_FILTER_OPTIONS:
case FLD_FILTER_PUBLISH:
case FLD_FILTER_MESSAGE:
if (field_value[0] == '*') {
form_driver(info->form, REQ_DEL_CHAR);
} else {
form_driver(info->form, '*');
}
break;
case FLD_FILTER_CANCEL:
return KEY_ESC;
case FLD_FILTER_FILTER:
filter_save_options(panel);
return KEY_ESC;
}
break;
case ACTION_CONFIRM:
if (field_idx != FLD_FILTER_CANCEL)
filter_save_options(panel);
return KEY_ESC;
default:
// Parse next action
continue;
}
// This panel has handled the key successfully
break;
}
// Validate all input data
form_driver(info->form, REQ_VALIDATION);
// Change background and cursor of "button fields"
set_field_back(info->fields[FLD_FILTER_FILTER], A_NORMAL);
set_field_back(info->fields[FLD_FILTER_CANCEL], A_NORMAL);
curs_set(1);
// Change current field background
field_idx = field_index(current_field(info->form));
if (field_idx == FLD_FILTER_FILTER || field_idx == FLD_FILTER_CANCEL) {
set_field_back(info->fields[field_idx], A_REVERSE);
curs_set(0);
}
// Return if this panel has handled or not the key
return (action == ERR) ? key : 0;
}
