void
name_filters_drop(view_t *view)
{
filter_clear(&view->auto_filter);
replace_matcher(&view->manual_filter, "");
view->invert = 1;
}
void
local_filter_remove(view_t *view)
{
(void)replace_string(&view->local_filter.prev, view->local_filter.filter.raw);
filter_clear(&view->local_filter.filter);
ui_view_schedule_reload(view);
}
int
int_legdwavf
#ifdef _SCILAB6_
(char *fname, void* pvApiCtx)
#else
(char *fname)
#endif
{
static int l1, m1, n1, l2, m2, n2;
static int minlhs = 1, maxlhs = 1, minrhs = 1, maxrhs = 1;
swt_wavelet pWaveStruct;
int errCode, family, member;
int readFlag;
char * input_string1 = NULL;
double *output1;
CheckInputArgument(pvApiCtx,minrhs, maxrhs);
CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
legdwavf_form_validate (pvApiCtx, &errCode);
if (errCode != SUCCESS)
{
validate_print (errCode);
return 0;
}
//GetRhsVar (1, "c", &m1, &n1, &l1);
readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
m1=1;n1=1;
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
legdwavf_content_validate (pvApiCtx, &errCode,input_string1);
if (errCode != SUCCESS)
{
validate_print (errCode);
return 0;
}
wavelet_parser(input_string1,&family,&member);
legendre_synthesis_initialize (member, &pWaveStruct);
m2 = 1;
n2 = pWaveStruct.length;
//CreateVar (2, "d", &m2, &n2, &l2);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
verbatim_copy (pWaveStruct.pLowPass, m2*n2, output1, m2*n2);
filter_clear();
//LhsVar (1) = 2;
return 0;
}
/* Resets filter to empty state (either initializes or clears it). */
static void
reset_filter(filter_t *filter)
{
if(filter->raw == NULL)
{
(void)filter_init(filter, FILTER_DEF_CASE_SENSITIVITY);
}
else
{
filter_clear(filter);
}
}
void no_filter()
{
filter_clear(); //select clear filter
pulse=0; //reset the count to 0
_delay_ms(500); //capture the pulses for 100 ms or 0.1 second
no_ff = (pulse); //store the count in variable called blue
_delay_ms(100);
lcd_cursor(1,1); //set the cursor on row 1, column 1
lcd_string("no filter"); // Display "no filter" on LCD
lcd_print(2,1,no_ff,5); //Print the count on second row
_delay_ms(1000); // Display for 1000ms or 1 second
lcd_wr_command(0x01); //Clear the LCD
}
void main(void) {
long data;
report_line_number = 0;
filter_clear();
while( TRUE ) {
fprintf(PC, " Enter data point: ");
data = get_long();
data = filter_data(data);
report_data_line(data);
}
}
/* Loads full list of files into unfiltered list of the view. Returns position
* of file under cursor in the unfiltered list. */
static int
load_unfiltered_list(view_t *view)
{
int current_file_pos = view->list_pos;
view->local_filter.in_progress = 1;
view->local_filter.saved = strdup(view->local_filter.filter.raw);
if(list_is_incomplete(view))
{
char full_path[PATH_MAX + 1];
dir_entry_t *entry;
get_current_full_path(view, sizeof(full_path), full_path);
filter_clear(&view->local_filter.filter);
(void)populate_dir_list(view, 1);
/* Resolve current file position in updated list. */
entry = entry_from_path(view, view->dir_entry, view->list_rows, full_path);
if(entry != NULL)
{
current_file_pos = entry_to_pos(view, entry);
}
if(current_file_pos >= view->list_rows)
{
current_file_pos = view->list_rows - 1;
}
}
else
{
/* Save unfiltered (by local filter) list for further use. */
replace_dir_entries(view, &view->local_filter.entries,
&view->local_filter.entry_count, view->dir_entry, view->list_rows);
}
view->local_filter.unfiltered = view->dir_entry;
view->local_filter.unfiltered_count = view->list_rows;
view->local_filter.prefiltered_count = view->filtered;
view->dir_entry = NULL;
return current_file_pos;
}
int
filter_set(filter_t *filter, const char value[])
{
if(value[0] == '\0')
{
filter_clear(filter);
return 0;
}
else if(replace_string(&filter->raw, value) == 0)
{
reset_regex(filter, value);
return (filter->is_regex_valid || filter->raw[0] == '\0') ? 0 : 1;
}
else
{
return 1;
}
}
int
filter_assign(filter_t *filter, const filter_t *source)
{
filter_t tmp;
if(filter_init(&tmp, !(source->cflags & REG_ICASE)) != 0)
{
return 1;
}
if(filter_set(&tmp, source->raw) != 0)
{
filter_clear(&tmp);
return 1;
}
filter_dispose(filter);
*filter = tmp;
return 0;
}
void globals_free(void)
{
GBL_FREE(gbls->pcap);
GBL_FREE(gbls->lnet);
GBL_FREE(gbls->iface);
GBL_FREE(gbls->bridge);
GBL_FREE(gbls->sm);
GBL_FREE(gbls->filters);
free_ip_list(gbls->t1);
GBL_FREE(gbls->t1);
free_ip_list(gbls->t2);
GBL_FREE(gbls->t2);
GBL_FREE(gbls->env->name);
GBL_FREE(gbls->env->version);
GBL_FREE(gbls->env->debug_file);
GBL_FREE(gbls->env);
free_plugin_list(gbls->options->plugins);
GBL_FREE(gbls->options->proto);
GBL_FREE(gbls->options->pcapfile_in);
GBL_FREE(gbls->options->pcapfile_out);
GBL_FREE(gbls->options->iface);
GBL_FREE(gbls->options->iface_bridge);
GBL_FREE(gbls->options->target1);
GBL_FREE(gbls->options->target2);
GBL_FREE(gbls->stats);
GBL_FREE(gbls->options);
GBL_FREE(gbls->conf);
/* destroy the list structure */
filter_clear();
GBL_FREE(gbls);
return;
}
void
filters_dir_updated(view_t *view)
{
filter_clear(&view->local_filter.filter);
}
/*
====================================================================
Load/delete background and create and link all menus
====================================================================
*/
void manager_create()
{
int i, j;
Item *keys[7];
Item *item;
int filter[SDLK_LAST]; /* key filter */
/* constant contence of switches */
char *str_fps[] = { _("No Limit"), _("100 FPS") };
char *str_anim[] = { _("Off"), _("Low"), _("Medium"), _("High") };
char *str_diff[] = { _("Kids"), _("Easy"), _("Medium"), _("Hard") };
/*
main:
new game:
start game
quick help
---
levelset
difficulty
---
active players
---
player1
player2
player3
player4
controls
graphics
animations
transparency
shadow
---
display
constant frame rate
audio:
sound
volume
advanced options:
convex paddle
ball level
key speed
editor:
set: (list)
edit
delete
yes
no
---
create empty set
set name: (string)
create set
yes
no
---
quit
*/
Menu *_main = 0;
#ifdef _1
Menu *options = 0;
#endif
#ifdef AUDIO_ENABLED
Menu *audio = 0;
#endif
Menu *gfx = 0;
Menu *game = 0;
Menu *cont = 0;
Menu *adv = 0;
Menu *editor = 0;
Menu *confirm_delete = 0;
Menu *theme = 0;
/* load levelset names */
levelsets_load_names();
cb_update_edit_set();
/* hints will be displayed on menu background */
hint_set_bkgnd( mbkgnd );
/* setup filter */
filter_clear( filter );
filter_set( filter, SDLK_a, SDLK_z, 1 );
filter[SDLK_BACKSPACE] = 1;
filter[SDLK_SPACE] = 1;
filter[SDLK_RSHIFT] = 1;
filter[SDLK_LSHIFT] = 1;
filter[SDLK_LALT] = 1;
filter[SDLK_RALT] = 1;
filter[SDLK_LCTRL] = 1;
filter[SDLK_RCTRL] = 1;
filter[SDLK_UP] = 1;
filter[SDLK_DOWN] = 1;
filter[SDLK_LEFT] = 1;
filter[SDLK_RIGHT] = 1;
filter[SDLK_q] = 0;
filter[SDLK_p] = 0;
filter[SDLK_f] = 0;
filter[SDLK_s] = 0;
filter[SDLK_a] = 0;
filter[SDLK_r] = 0;
filter[SDLK_h] = 0;
filter[SDLK_d] = 0;
/* menus are added to this list for deleting later */
menus = list_create( LIST_AUTO_DELETE, menu_delete );
/* create menus */
_main = menu_create( _("Menu"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
#ifdef _1
options = menu_create( _("Options"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
#endif
gfx = menu_create( _("Graphics"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
game = menu_create( _("Local Game"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
cont = menu_create( _("Controls"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
adv = menu_create( _("Advanced Options"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
#ifdef AUDIO_ENABLED
audio = menu_create( _("Audio"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
#endif
editor = menu_create( _("Editor"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
confirm_delete = menu_create( _("Delete Set"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
theme = menu_create( _("Select Theme"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
/* create items */
/* main menu */
menu_add( _main, item_create_link ( _("Local Game"), HINT_LOCAL, game ) );
#ifdef NETWORK_ENABLED
menu_add( _main, item_create_action ( _("Network Game"), HINT_NETWORK, ACTION_CLIENT ) );
#endif
menu_add( _main, item_create_action ( _("Quick Help"), HINT_, ACTION_QUICK_HELP ) );
// menu_add( _main, item_create_link ( _("Select Theme"), HINT_THEME, theme ) );
menu_add( _main, item_create_separator ( "" ) );
#ifdef _1
menu_add( _main, item_create_link ( _("Options"), options ) );
#endif
menu_add( _main, item_create_link ( _("Controls"), HINT_, cont ) );
menu_add( _main, item_create_link ( _("Graphics"), HINT_, gfx ) );
#ifdef AUDIO_ENABLED
menu_add( _main, item_create_link ( _("Audio"), HINT_,audio ) );
#else
menu_add( _main, item_create_separator ( _("Audio") ) );
#endif
menu_add( _main, item_create_link ( _("Advanced Options"), HINT_, adv ) );
menu_add( _main, item_create_separator ( "" ) );
menu_add( _main, item_create_link ( _("Editor"), HINT_, editor ) );
menu_add( _main, item_create_separator ( "" ) );
menu_add( _main, item_create_action ( _("Quit"), HINT_QUIT, ACTION_QUIT ) );
#ifdef _1
/* options */
menu_add( options, item_create_link( _("Controls"), HINT_, cont ) );
menu_add( options, item_create_link( _("Graphics"), HINT_, gfx ) );
menu_add( options, item_create_link( _("Audio"), HINT_, audio ) );
menu_add( options, item_create_separator( _("Audio") ) );
menu_add( options, item_create_separator( "" ) );
menu_add( options, item_create_link( _("Back"), _main ) );
#endif
/* audio */
#ifdef AUDIO_ENABLED
item = item_create_switch( _("Sound:"), HINT_, &config.sound, _("Off"), _("On") );
item->callback = cb_sound;
menu_add( audio, item );
menu_add( audio, item_create_switch( _("Speech:"), HINT_, &config.speech, _("Off"), _("On") ) );
item = item_create_range( _("Volume:"), HINT_, &config.volume, 1, 8, 1 );
item->callback = cb_volume;
menu_add( audio, item );
menu_add( audio, item_create_separator( "" ) );
menu_add( audio, item_create_link( _("Back"), HINT_, _main ) );
#endif
/* gfx */
menu_add( gfx, item_create_switch_x( _("Animations:"), HINT_ANIM, &config.anim, str_anim, 4 ) );
menu_add( gfx, item_create_switch( _("Bonus Info:"), HINT_BONUS_INFO, &config.bonus_info, _("Off"), _("On") ) );
menu_add( gfx, item_create_separator( "" ) );
item = item_create_switch( _("Display:"), HINT_DISPLAY, &config.fullscreen, _("Window"), _("Fullscreen") );
item->callback = cb_fullscreen;
menu_add( gfx, item );
menu_add( gfx, item_create_switch_x( _("Frame Rate:"), HINT_FPS, &config.fps, str_fps, 2 ) );
menu_add( gfx, item_create_separator( "" ) );
menu_add( gfx, item_create_link( _("Select Theme"), HINT_THEME, theme ) );
menu_add( gfx, item_create_separator( "" ) );
menu_add( gfx, item_create_link( _("Back"), HINT_, _main ) );
/* game */
item_resume_0 = item_create_action( _("Resume Last Game"), "???", ACTION_RESUME_0 );
menu_add( game, item_resume_0 );
slot_update_hint( 0, item_resume_0->hint );
menu_add( game, item_create_action( _("Start Original Set"), HINT_START_LBR, ACTION_PLAY_LBR ) );
menu_add( game, item_create_action( _("Start AddOn"), HINT_START_CUSTOM, ACTION_PLAY_CUSTOM ) );
//menu_add( game, item_create_separator( "" ) );
item_levelset = item_create_switch_x( _("AddOn:"), "", &config.levelset_id_local, levelset_names_local, levelset_count_local );
item_levelset->callback = cb_update_levelset_hint;
cb_update_levelset_hint(); /* initiate first hint */
menu_add( game, item_levelset );
menu_add( game, item_create_switch_x( _("Difficulty:"), HINT_DIFF, &config.diff, str_diff, DIFF_COUNT ) );
menu_add( game, item_create_separator( "" ) );
menu_add( game, item_create_range( _("Players:"), HINT_PLAYERS, &config.player_count, 1, 4, 1 ) );
menu_add( game, item_create_edit( _("1st:"), HINT_PLAYERS, config.player_names[0], 12 ) );
menu_add( game, item_create_edit( _("2nd:"), HINT_PLAYERS, config.player_names[1], 12 ) );
menu_add( game, item_create_edit( _("3rd:"), HINT_PLAYERS, config.player_names[2], 12 ) );
menu_add( game, item_create_edit( _("4th:"), HINT_PLAYERS, config.player_names[3], 12 ) );
menu_add( game, item_create_separator( "" ) );
menu_add( game, item_create_link( _("Back"), HINT_, _main ) );
/* controls */
keys[0] = item_create_key( _("Left:"), HINT_KEYS, &config.k_left, filter );
keys[1] = item_create_key( _("Right:"), HINT_KEYS, &config.k_right, filter );
keys[2] = item_create_key( _("Left Fire:"), HINT_KEYS, &config.k_lfire, filter );
keys[3] = item_create_key( _("Right Fire:"), HINT_KEYS, &config.k_rfire, filter );
keys[4] = item_create_key( _("Paddle Turbo:"), HINT_KEYS, &config.k_turbo, filter );
keys[5] = item_create_key( _("Ball Turbo:"), HINT_KEYS, &config.k_maxballspeed, filter );
keys[6] = item_create_key( _("Return:"), HINT_KEYS, &config.k_return, filter );
// keys[6] = item_create_key( _("Warp:"), HINT_KEYS, &config.k_warp, filter );
for ( i = 0; i < 7; i++ )
menu_add( cont, keys[i] );
/* dynamic restriction */
for ( i = 0; i < 7; i++ )
for ( j = 0; j < 7; j++ )
if ( j != i )
value_add_other_key( keys[i]->value, keys[j]->value );
/* other control stuff */
menu_add( cont, item_create_separator( "" ) );
item = item_create_range( _("Key Speed:"), HINT_KEYSPEED, &config.i_key_speed, 100, 1000, 50 );
item->callback = cb_set_keyspeed;
menu_add( cont, item );
item = item_create_range( _("Motion Modifier:"), HINT_MOD, &config.i_motion_mod, 40, 160, 5 );
item->callback = cb_set_motion_mod;
menu_add( cont, item );
menu_add( cont, item_create_switch( _("Invert Motion:"), HINT_INVERT, &config.invert, _("Off"), _("On") ) );
menu_add( cont, item_create_separator( "" ) );
menu_add( cont, item_create_link( _("Back"), HINT_, _main ) );
/* advanced options */
menu_add( adv, item_create_switch( _("Convex Paddle:"), HINT_CONVEX, &config.convex, _("Off"), _("On") ) );
//menu_add( adv, item_create_switch( _("Corner:"), HINT_CORNER, &config.linear_corner, _("Spherical"), _("Linear") ) );
menu_add( adv,
item_create_switch( _("Ball Fire Angle:"),
HINT_RANDOM_ANGLE, &config.random_angle,
"50", _("Random") ) );
menu_add( adv, item_create_switch( _("Balls:"), HINT_BALLLEVEL, &config.ball_level, _("Below Bonuses"), _("Above Bonuses") ) );
menu_add( adv, item_create_switch( _("Debris:"), HINT_DEBRISLEVEL, &config.debris_level, _("Below Balls"), _("Above Balls") ) );
menu_add( adv, item_create_switch( _("Return Balls:"), HINT_RETURN, &config.return_on_click, _("Auto"), _("By Click") ) );
item = item_create_switch( _("Use Hints:"), HINT_USEHINTS, &config.use_hints, _("Off"), _("On") );
item->callback = cb_hints;
menu_add( adv, item );
menu_add( adv, item_create_range( _("Warp Limit:"), HINT_WARP_LIMIT, &config.rel_warp_limit, 0, 100, 10 ) );
menu_add( adv, item_create_edit( _("Local UDP Port:"), HINT_LOCAL_PORT, config.local_port, 6 ) );
item = item_create_range( _("Acc. Ball Speed:"), HINT_MAXBALLSPEED, &config.maxballspeed_int1000, 600, 900, 20 );
item->callback = cb_maxballspeed;
menu_add( adv, item );
menu_add( adv, item_create_switch( _("Add Bonus Levels:"), HINT_BONUS_LEVELS, &config.addBonusLevels, _("Off"), _("On") ) );
menu_add( adv, item_create_separator( "" ) );
menu_add( adv, item_create_link( _("Back"), HINT_, _main ) );
/* editor */
item_set = item_create_switch_x(
_("Set:"), HINT_EDITOR_SET,
&config.levelset_id_home, levelset_names_home,
levelset_count_home );
item_set->callback = cb_update_edit_set;
menu_add( editor, item_set );
menu_add( editor, item_create_action( _("Edit Set"), HINT_EDITOR_EDIT, ACTION_EDIT ) );
menu_add( editor, item_create_link( _("Delete Set"), HINT_EDITOR_DELETE, confirm_delete ) );
menu_add( editor, item_create_separator( "" ) );
menu_add( editor, item_create_link( _("Back"), HINT_, _main ) );
/* confirm_delete set */
item = item_create_link( _("Yes"), HINT_ ,editor );
item->callback = cb_delete_set;
menu_add( confirm_delete, item );
menu_add( confirm_delete, item_create_link( _("No"), HINT_, editor ) );
/* theme */
item_theme = item_create_switch_x( _("Theme:"), "", &config.theme_id, theme_names, theme_count );
menu_add( theme, item_theme );
item_theme->callback = cb_update_theme_hint;
cb_update_theme_hint();
menu_add( theme, item_create_separator( "" ) );
item = item_create_link( _("Apply"), HINT_APPLY, gfx );
item->callback = cb_change_theme;
menu_add( theme, item );
menu_add( theme, item_create_link( _("Cancel"), HINT_, gfx ) );
/* adjust all menus */
menu_adjust( _main );
#ifdef _1
menu_adjust( options );
#endif
#ifdef AUDIO_ENABLED
menu_adjust( audio );
#endif
menu_adjust( gfx );
menu_adjust( game );
menu_adjust( cont );
menu_adjust( adv );
menu_adjust( editor );
menu_adjust( confirm_delete );
menu_adjust( theme );
/* set main menu as current */
menu_select( _main );
}
int
int_wmaxlev
#ifdef _SCILAB6_
(char *fname, void* pvApiCtx)
#else
(char *fname)
#endif
{
static int l1, m1, n1, l2, m2, n2, l3, m3, n3;
static int minlhs = 1, maxlhs = 1, minrhs = 2, maxrhs = 2;
int ii, stride, val, stride1, stride2, val1, val2;
// int filterLen;
swt_wavelet pWaveStruct;
int errCode, family, member;
Func syn_fun;
int readFlag;
char * input_string1 = NULL;
int *input1;
int *output1;
CheckInputArgument(pvApiCtx,minrhs, maxrhs);
CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
wmaxlev_form_validate (pvApiCtx, &errCode);
if (errCode != SUCCESS)
{
validate_print (errCode);
return 0;
}
//GetRhsVar (1, "i", &m1, &n1, &l1);
readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 1, &m1 , &n1 , &input1 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//GetRhsVar (2, "c", &m2, &n2, &l2);
readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname,2 , &input_string1 );
m2=1;n2=1;
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
wfilters_content_validate (pvApiCtx, &errCode, input_string1);
if (errCode != SUCCESS)
{
validate_print (errCode);
return 0;
}
wavelet_parser(input_string1,&family,&member);
wavelet_fun_parser (input_string1, &ii);
syn_fun = wi[ii].synthesis;
(*syn_fun)(member, &pWaveStruct);
filter_clear();
if (sci_matrix_scalar_real(pvApiCtx,1))
{
if (input1[0] <= 0)
{
sciprint("Input integer must be positive!\n");
return 0;
}
wave_len_validate (input1[0], pWaveStruct.length,
&stride, &val);
if (val == 0)
{
sciprint
("Unrecognized Input Pattern or parameter not valid for the algorithm! Please refer to help pages!\n");
return 0;
}
else
{
m3 = 1;
n3 = 1;
//CreateVar (3, "i", &m3, &n3, &l3);
readFlag = swt_gwsupport_AllocMatrixOfDoublesAsInteger (pvApiCtx, fname, 1, m3 , n3 , &output1 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
output1[0] = stride;
// LhsVar (1) = 3;
}
}
else
{
//sciprint("enter matrix\n");
if (input1[0] <= 0)
{
sciprint("Input integer must be positive!\n");
return 0;
}
if (input1[0] <= 0)
{
sciprint("Input integer must be positive!\n");
return 0;
}
wave_len_validate ( input1[0], pWaveStruct.length,
&stride1, &val1);
if (val1 == 0)
{
sciprint
("The wavelet you select is not appropriate for that row size of the matrix!\n");
return 0;
}
wave_len_validate ( input1[1], pWaveStruct.length,
&stride2, &val2);
if (val2 == 0)
{
sciprint
("The wavelet you select is not appropriate for that column size of the matrix!\n");
return 0;
}
if ((val1 == 0) || (val2 == 0))
return 0;
m3 = 1;
n3 = 1;
//CreateVar (3, "i", &m3, &n3, &l3);
readFlag = swt_gwsupport_AllocMatrixOfDoublesAsInteger (pvApiCtx, fname, 1, m3 , n3 , &output1 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
output1[0] = (stride1 > stride2) ? stride2 : stride1;
//if (stride1>=stride2)
// istk(l3)[0]=stride2;
//else
// istk(l3)[0]=stride1;
// LhsVar (1) = 3;
}
return 0;
}
int
int_wfilters
#ifdef _SCILAB6_
(char *fname, void* pvApiCtx)
#else
(char *fname)
#endif
{
static int l1, m1, n1, l2, m2, n2, l3, m3, n3;
static int l4, m4, n4, l5, m5, n5;
static int minlhs = 2, maxlhs = 4, minrhs = 1, maxrhs = 2;
int errCode, flow, family, member, ii;
Func ana_fun, syn_fun;
swt_wavelet pWaveStruct;
int readFlag;
char * input_string1 = NULL;
char * input_string2 = NULL;
double *output1;
double *output2;
double *output3;
double *output4;
CheckInputArgument(pvApiCtx,minrhs, maxrhs);
CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
errCode = SUCCESS;
if (swt_gwsupport_GetType(pvApiCtx, 1)!=sci_strings)
errCode = UNKNOWN_INPUT_ERR;
if (errCode != SUCCESS)
{
validate_print (errCode);
return 0;
}
//GetRhsVar (1, "c", &m1, &n1, &l1);
readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
m1=1;n1=1;
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
l2 = 0;
if (Rhs==2)
{
if (swt_gwsupport_GetType(pvApiCtx, 2)!=sci_strings)
errCode = UNKNOWN_INPUT_ERR;
if (errCode != SUCCESS)
{
validate_print (errCode);
return 0;
}
//GetRhsVar (2, "c", &m2, &n2, &l2);
readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string2 );
m2=1;n2=1;
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
}
wfilters_form_validate (pvApiCtx, &errCode, &flow, input_string2,Rhs,Lhs);
if (errCode != SUCCESS)
{
validate_print (errCode);
return 0;
}
wfilters_content_validate (pvApiCtx, &errCode, input_string1);
if (errCode != SUCCESS)
{
validate_print (errCode);
return 0;
}
switch (flow) {
case 1:
{
//sciprint("enter flow 1!\n");
wavelet_parser(input_string1,&family,&member);
wavelet_fun_parser (input_string1, &ii);
ana_fun = wi[ii].analysis;
syn_fun = wi[ii].synthesis;
(*ana_fun)(member, &pWaveStruct);
m2 = 1;
m3 = 1;
m4 = 1;
m5 = 1;
n2 = pWaveStruct.length;
n3 = pWaveStruct.length;
n4 = pWaveStruct.length;
n5 = pWaveStruct.length;
//CreateVar (2, "d", &m2, &n2, &l2);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//CreateVar (3, "d", &m3, &n3, &l3);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m3 , n3 , &output2 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//CreateVar (4, "d", &m4, &n4, &l4);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 3, m4 , n4 , &output3 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//CreateVar (5, "d", &m5, &n5, &l5);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 4, m5 , n5 , &output4 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
verbatim_copy (pWaveStruct.pLowPass, m2*n2, output1, m2*n2);
verbatim_copy (pWaveStruct.pHiPass, m3*n3, output2, m3*n3);
(*syn_fun)(member, &pWaveStruct);
verbatim_copy (pWaveStruct.pLowPass, m4*n4, output3, m4*n4);
verbatim_copy (pWaveStruct.pHiPass, m5*n5, output4, m5*n5);
filter_clear();
// AssignOutputVariable(pvApiCtx,1) = 2;
// AssignOutputVariable(pvApiCtx,2) = 3;
// AssignOutputVariable(pvApiCtx,3) = 4;
// AssignOutputVariable(pvApiCtx,4) = 5;
break;
}
case 2:
{
wavelet_parser(input_string1,&family,&member);
wavelet_fun_parser (input_string1, &ii);
ana_fun = wi[ii].analysis;
(*ana_fun)(member, &pWaveStruct);
m3 = 1;
m4 = 1;
n3 = pWaveStruct.length;
n4 = pWaveStruct.length;
//CreateVar (3, "d", &m3, &n3, &l3);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//CreateVar (4, "d", &m4, &n4, &l4);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m4 , n4 , &output2 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
verbatim_copy (pWaveStruct.pLowPass, m3*n3, output1, m3*n3);
verbatim_copy (pWaveStruct.pHiPass, m4*n4, output2, m4*n4);
filter_clear();
// LhsVar (1) = 3;
// LhsVar (2) = 4;
break;
}
case 3:
{
wavelet_parser(input_string1,&family,&member);
wavelet_fun_parser (input_string1, &ii);
syn_fun = wi[ii].synthesis;
(*syn_fun)(member, &pWaveStruct);
m3 = 1;
m4 = 1;
n3 = pWaveStruct.length;
n4 = pWaveStruct.length;
//CreateVar (3, "d", &m3, &n3, &l3);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//CreateVar (4, "d", &m4, &n4, &l4);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m4 , n4 , &output2 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
verbatim_copy (pWaveStruct.pLowPass, m3*n3, output1, m3*n3);
verbatim_copy (pWaveStruct.pHiPass, m4*n4, output2, m4*n4);
filter_clear();
//LhsVar (1) = 3;
//LhsVar (2) = 4;
break;
}
case 4:
{
wavelet_parser(input_string1,&family,&member);
wavelet_fun_parser (input_string1, &ii);
ana_fun = wi[ii].analysis;
(*ana_fun)(member, &pWaveStruct);
m3 = 1;
m4 = 1;
n3 = pWaveStruct.length;
n4 = pWaveStruct.length;
//CreateVar (3, "d", &m3, &n3, &l3);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//CreateVar (4, "d", &m4, &n4, &l4);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m4 , n4 , &output2 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
verbatim_copy (pWaveStruct.pLowPass, m3*n3, output1, m3*n3);
//filter_clear();
syn_fun = wi[ii].synthesis;
(*syn_fun)(member, &pWaveStruct);
verbatim_copy (pWaveStruct.pLowPass, m4*n4, output2, m4*n4);
filter_clear();
//LhsVar (1) = 3;
//LhsVar (2) = 4;
break;
}
case 5:
{
wavelet_parser(input_string1,&family,&member);
wavelet_fun_parser (input_string1, &ii);
ana_fun = wi[ii].analysis;
(*ana_fun)(member, &pWaveStruct);
m3 = 1;
m4 = 1;
n3 = pWaveStruct.length;
n4 = pWaveStruct.length;
//CreateVar (3, "d", &m3, &n3, &l3);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//CreateVar (4, "d", &m4, &n4, &l4);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m4 , n4 , &output2 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
verbatim_copy (pWaveStruct.pHiPass, m3*n3, output1, m3*n3);
syn_fun = wi[ii].synthesis;
(*syn_fun)(member, &pWaveStruct);
verbatim_copy (pWaveStruct.pHiPass, m4*n4, output2, m4*n4);
filter_clear();
//LhsVar (1) = 3;
//LhsVar (2) = 4;
break;
}
default:
break;
}
return 0;
}
