1 /*
2 * -------------------------------------------------------------------------
3 * dwt_int.c -- DWT interface function
4 * SWT - Scilab wavelet toolbox
5 * Copyright (C) 2005-2006 Roger Liu
6 * Copyright (C) 20010-2012 Holger Nahrstaedt
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 * -------------------------------------------------------------------------
22 */
23
24 #include "swt_common.h"
25 //
26 // converted to scilab-api
27
28 /*-------------------------------------------
29 * orthfilt
30 *-----------------------------------------*/
31
32 int
int_orthfilt(char * fname,void * pvApiCtx)33 int_orthfilt
34 #ifdef _SCILAB6_
35 (char *fname, void* pvApiCtx)
36 #else
37 (char *fname)
38 #endif
39 {
40 static int l1, m1, n1, l2, m2, n2, l3, m3, n3;
41 static int l4, m4, n4, l5, m5, n5;
42 static int minlhs = 4, maxlhs = 4, minrhs = 1, maxrhs = 1;
43 int errCode;
44 int readFlag;
45 double *input1;
46 double *output1;
47 double *output2;
48 double *output3;
49 double *output4;
50
51 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
52 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
53
54 // GetRhsVar (1, "d", &m1, &n1, &l1);
55 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
56 if(readFlag==SWT_GWSUPPORT_ERROR)
57 {
58 return 0;
59 }
60
61
62 orthfilt_form_validate (pvApiCtx, &errCode);
63 if (errCode != SUCCESS)
64 {
65 validate_print (errCode);
66 return 0;
67 }
68
69 m2 = 1;
70 m3 = 1;
71 m4 = 1;
72 m5 = 1;
73 n2 = n1 * m1;
74 n3 = n1 * m1;
75 n4 = n1 * m1;
76 n5 = n1 * m1;
77
78 //CreateVar (2, "d", &m2, &n2, &l2);
79 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
80 if(readFlag==SWT_GWSUPPORT_ERROR)
81 {
82 return 0;
83 }
84
85
86 //CreateVar (3, "d", &m3, &n3, &l3);
87 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m3 , n3 , &output2 );
88 if(readFlag==SWT_GWSUPPORT_ERROR)
89 {
90 return 0;
91 }
92
93
94 //CreateVar (4, "d", &m4, &n4, &l4);
95 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 3, m4 , n4 , &output3 );
96 if(readFlag==SWT_GWSUPPORT_ERROR)
97 {
98 return 0;
99 }
100
101
102 //CreateVar (5, "d", &m5, &n5, &l5);
103 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 4, m5 , n5 , &output4 );
104 if(readFlag==SWT_GWSUPPORT_ERROR)
105 {
106 return 0;
107 }
108
109
110 orth_filt_group (input1, n1 * m1, output3, output1, output4, output2);
111
112 //LhsVar (1) = 2;
113 //LhsVar (2) = 3;
114 //LhsVar (3) = 4;
115 //LhsVar (4) = 5;
116 return 0;
117 }
118
119 int
int_biorfilt(char * fname,void * pvApiCtx)120 int_biorfilt
121 #ifdef _SCILAB6_
122 (char *fname, void* pvApiCtx)
123 #else
124 (char *fname)
125 #endif
126 {
127 static int l1, m1, n1, l2, m2, n2, l3, m3, n3;
128 static int l4, m4, n4, l5, m5, n5, l6, m6, n6;
129 static int minlhs = 4, maxlhs = 4, minrhs = 2, maxrhs = 2;
130 int errCode;
131 int readFlag;
132 double *input1;
133 double *input2;
134 double *output1;
135 double *output2;
136 double *output3;
137 double *output4;
138
139 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
140 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
141
142 biorfilt_form_validate (pvApiCtx, &errCode);
143 if (errCode != SUCCESS)
144 {
145 validate_print (errCode);
146 return 0;
147 }
148
149 //GetRhsVar (1, "d", &m1, &n1, &l1);
150 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
151 if(readFlag==SWT_GWSUPPORT_ERROR)
152 {
153 return 0;
154 }
155 //GetRhsVar (2, "d", &m2, &n2, &l2);
156 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 2, &m2, &n2, &input2);
157 if(readFlag==SWT_GWSUPPORT_ERROR)
158 {
159 return 0;
160 }
161
162 m3 = 1;
163 m4 = 1;
164 m5 = 1;
165 m6 = 1;
166 n3 = n1 * m1;
167 n4 = n1 * m1;
168 n5 = n1 * m1;
169 n6 = n1 * m1;
170
171 //CreateVar (3, "d", &m3, &n3, &l3);
172 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
173 if(readFlag==SWT_GWSUPPORT_ERROR)
174 {
175 return 0;
176 }
177 //CreateVar (4, "d", &m4, &n4, &l4);
178 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m4 , n4 , &output2 );
179 if(readFlag==SWT_GWSUPPORT_ERROR)
180 {
181 return 0;
182 }
183 //CreateVar (5, "d", &m5, &n5, &l5);
184 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 3, m5 , n5 , &output3 );
185 if(readFlag==SWT_GWSUPPORT_ERROR)
186 {
187 return 0;
188 }
189 //CreateVar (6, "d", &m6, &n6, &l6);
190 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 4, m6 , n6 , &output4 );
191 if(readFlag==SWT_GWSUPPORT_ERROR)
192 {
193 return 0;
194 }
195
196 bior_filt_group (input1, m1 * n1, input2, m2 * n2,
197 output1, m3 * n3, output2, m4 * n4,
198 output3, m5 * n5, output4, m6 * n6);
199 // LhsVar (1) = 3;
200 // LhsVar (2) = 4;
201 // LhsVar (3) = 5;
202 // LhsVar (4) = 6;
203
204 return 0;
205 }
206
207
208 /*-------------------------------------------
209 * Scale Filter Generation
210 *-----------------------------------------*/
211
212 int
int_dbwavf(char * fname,void * pvApiCtx)213 int_dbwavf
214 #ifdef _SCILAB6_
215 (char *fname, void* pvApiCtx)
216 #else
217 (char *fname)
218 #endif
219 {
220 static int l1, m1, n1, l2, m2, n2;
221 static int minlhs = 1, maxlhs = 1, minrhs = 1, maxrhs = 1;
222 swt_wavelet pWaveStruct;
223 int errCode, family, member;
224 int readFlag;
225 char * input_string1 = NULL;
226 double *output1;
227
228 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
229 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
230
231 dbwavf_form_validate (pvApiCtx, &errCode);
232 if (errCode != SUCCESS)
233 {
234 validate_print (errCode);
235 return 0;
236 }
237
238 //GetRhsVar (1, "c", &m1, &n1, &l1);
239 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
240 m1=1;n1=1;
241 if(readFlag==SWT_GWSUPPORT_ERROR)
242 {
243 return 0;
244 }
245 dbwavf_content_validate (pvApiCtx, &errCode,input_string1);
246 if (errCode != SUCCESS)
247 {
248 validate_print (errCode);
249 return 0;
250 }
251
252 wavelet_parser(input_string1,&family,&member);
253 daubechies_synthesis_initialize (member, &pWaveStruct);
254 m2 = 1;
255 n2 = pWaveStruct.length;
256 //CreateVar (2, "d", &m2, &n2, &l2);
257 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
258 if(readFlag==SWT_GWSUPPORT_ERROR)
259 {
260 return 0;
261 }
262 verbatim_copy (pWaveStruct.pLowPass, m2*n2, output1, m2*n2);
263 filter_clear();
264 //LhsVar (1) = 2;
265 return 0;
266 }
267
268
269
270 int
int_coifwavf(char * fname,void * pvApiCtx)271 int_coifwavf
272 #ifdef _SCILAB6_
273 (char *fname, void* pvApiCtx)
274 #else
275 (char *fname)
276 #endif
277 {
278 static int l1, m1, n1, l2, m2, n2;
279 static int minlhs = 1, maxlhs = 1, minrhs = 1, maxrhs = 1;
280 swt_wavelet pWaveStruct;
281 int errCode, family, member;
282 int readFlag;
283 char * input_string1 = NULL;
284 double *output1;
285
286 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
287 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
288
289 coifwavf_form_validate (pvApiCtx, &errCode);
290 if (errCode != SUCCESS)
291 {
292 validate_print (errCode);
293 return 0;
294 }
295
296 //GetRhsVar (1, "c", &m1, &n1, &l1);
297 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
298 m1=1;n1=1;
299 if(readFlag==SWT_GWSUPPORT_ERROR)
300 {
301 return 0;
302 }
303 coifwavf_content_validate (pvApiCtx, &errCode,input_string1);
304 if (errCode != SUCCESS)
305 {
306 validate_print (errCode);
307 return 0;
308 }
309
310 wavelet_parser(input_string1,&family,&member);
311 coiflets_synthesis_initialize (member, &pWaveStruct);
312 m2 = 1;
313 n2 = pWaveStruct.length;
314 //CreateVar (2, "d", &m2, &n2, &l2);
315 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
316 if(readFlag==SWT_GWSUPPORT_ERROR)
317 {
318 return 0;
319 }
320 verbatim_copy (pWaveStruct.pLowPass, m2*n2, output1, m2*n2);
321 filter_clear();
322 //LhsVar (1) = 2;
323 return 0;
324 }
325
326
327 int
int_symwavf(char * fname,void * pvApiCtx)328 int_symwavf
329 #ifdef _SCILAB6_
330 (char *fname, void* pvApiCtx)
331 #else
332 (char *fname)
333 #endif
334 {
335 static int l1, m1, n1, l2, m2, n2;
336 static int minlhs = 1, maxlhs = 1, minrhs = 1, maxrhs = 1;
337 swt_wavelet pWaveStruct;
338 int errCode, family, member;
339 int readFlag;
340 char * input_string1 = NULL;
341 double *output1;
342
343 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
344 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
345
346 symwavf_form_validate (pvApiCtx, &errCode);
347 if (errCode != SUCCESS)
348 {
349 validate_print (errCode);
350 return 0;
351 }
352
353 //GetRhsVar (1, "c", &m1, &n1, &l1);
354 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
355 m1=1;n1=1;
356 if(readFlag==SWT_GWSUPPORT_ERROR)
357 {
358 return 0;
359 }
360 symwavf_content_validate (pvApiCtx, &errCode,input_string1);
361 if (errCode != SUCCESS)
362 {
363 validate_print (errCode);
364 return 0;
365 }
366
367 wavelet_parser(input_string1,&family,&member);
368 symlets_synthesis_initialize (member, &pWaveStruct);
369 m2 = 1;
370 n2 = pWaveStruct.length;
371 //CreateVar (2, "d", &m2, &n2, &l2);
372 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
373 if(readFlag==SWT_GWSUPPORT_ERROR)
374 {
375 return 0;
376 }
377 verbatim_copy (pWaveStruct.pLowPass, m2*n2, output1, m2*n2);
378 filter_clear();
379 //LhsVar (1) = 2;
380 return 0;
381 }
382
383 int
int_legdwavf(char * fname,void * pvApiCtx)384 int_legdwavf
385 #ifdef _SCILAB6_
386 (char *fname, void* pvApiCtx)
387 #else
388 (char *fname)
389 #endif
390 {
391 static int l1, m1, n1, l2, m2, n2;
392 static int minlhs = 1, maxlhs = 1, minrhs = 1, maxrhs = 1;
393 swt_wavelet pWaveStruct;
394 int errCode, family, member;
395 int readFlag;
396 char * input_string1 = NULL;
397 double *output1;
398
399 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
400 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
401
402 legdwavf_form_validate (pvApiCtx, &errCode);
403 if (errCode != SUCCESS)
404 {
405 validate_print (errCode);
406 return 0;
407 }
408
409 //GetRhsVar (1, "c", &m1, &n1, &l1);
410 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
411 m1=1;n1=1;
412 if(readFlag==SWT_GWSUPPORT_ERROR)
413 {
414 return 0;
415 }
416 legdwavf_content_validate (pvApiCtx, &errCode,input_string1);
417 if (errCode != SUCCESS)
418 {
419 validate_print (errCode);
420 return 0;
421 }
422
423 wavelet_parser(input_string1,&family,&member);
424 legendre_synthesis_initialize (member, &pWaveStruct);
425 m2 = 1;
426 n2 = pWaveStruct.length;
427 //CreateVar (2, "d", &m2, &n2, &l2);
428 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
429 if(readFlag==SWT_GWSUPPORT_ERROR)
430 {
431 return 0;
432 }
433 verbatim_copy (pWaveStruct.pLowPass, m2*n2, output1, m2*n2);
434 filter_clear();
435 //LhsVar (1) = 2;
436 return 0;
437 }
438
439 int
int_biorwavf(char * fname,void * pvApiCtx)440 int_biorwavf
441 #ifdef _SCILAB6_
442 (char *fname, void* pvApiCtx)
443 #else
444 (char *fname)
445 #endif
446 {
447 static int l1, m1, n1, l2, m2, n2, l3, m3, n3;
448 static int minlhs = 2, maxlhs = 2, minrhs = 1, maxrhs = 1;
449 swt_wavelet pWaveStruct;
450 int errCode, family, member;
451 int readFlag;
452 char * input_string1 = NULL;
453 double *output1;
454 double *output2;
455
456 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
457 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
458
459 biorwavf_form_validate (pvApiCtx, &errCode);
460 if (errCode != SUCCESS)
461 {
462 validate_print (errCode);
463 return 0;
464 }
465
466 // GetRhsVar (1, "c", &m1, &n1, &l1);
467 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
468 m1=1;n1=1;
469 if(readFlag==SWT_GWSUPPORT_ERROR)
470 {
471 return 0;
472 }
473 biorwavf_content_validate (pvApiCtx, &errCode,input_string1);
474 if (errCode != SUCCESS)
475 {
476 validate_print (errCode);
477 return 0;
478 }
479
480 wavelet_parser(input_string1,&family,&member);
481 sp_bior_synthesis_initialize (member, &pWaveStruct);
482 m2 = 1;
483 n2 = pWaveStruct.length;
484 m3 = 1;
485 n3 = pWaveStruct.length;
486 //CreateVar (2, "d", &m2, &n2, &l2);
487 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
488 if(readFlag==SWT_GWSUPPORT_ERROR)
489 {
490 return 0;
491 }
492 //CreateVar (3, "d", &m3, &n3, &l3);
493 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m3 , n3 , &output2 );
494 if(readFlag==SWT_GWSUPPORT_ERROR)
495 {
496 return 0;
497 }
498
499 verbatim_copy (pWaveStruct.pLowPass, m2*n2, output1, m2*n2);
500 filter_clear();
501
502 sp_bior_analysis_initialize (member, &pWaveStruct);
503 wrev(pWaveStruct.pLowPass, m3 * n3, output2, m3 * n3);
504 filter_clear();
505
506 //LhsVar (1) = 2;
507 //LhsVar (2) = 3;
508 return 0;
509 }
510
511 int
int_rbiorwavf(char * fname,void * pvApiCtx)512 int_rbiorwavf
513 #ifdef _SCILAB6_
514 (char *fname, void* pvApiCtx)
515 #else
516 (char *fname)
517 #endif
518 {
519 static int l1, m1, n1, l2, m2, n2, l3, m3, n3;
520 static int minlhs = 2, maxlhs = 2, minrhs = 1, maxrhs = 1;
521 swt_wavelet pWaveStruct;
522 int errCode, family, member;
523 int readFlag;
524 char * input_string1 = NULL;
525 double *output1;
526 double *output2;
527
528 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
529 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
530
531 rbiorwavf_form_validate (pvApiCtx, &errCode);
532 if (errCode != SUCCESS)
533 {
534 validate_print (errCode);
535 return 0;
536 }
537
538 //GetRhsVar (1, "c", &m1, &n1, &l1);
539 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
540 m1=1;n1=1;
541 if(readFlag==SWT_GWSUPPORT_ERROR)
542 {
543 return 0;
544 }
545 rbiorwavf_content_validate (pvApiCtx, &errCode,input_string1);
546 if (errCode != SUCCESS)
547 {
548 validate_print (errCode);
549 return 0;
550 }
551
552 wavelet_parser(input_string1,&family,&member);
553 sp_rbior_synthesis_initialize (member, &pWaveStruct);
554 m2 = 1;
555 n2 = pWaveStruct.length;
556 m3 = 1;
557 n3 = pWaveStruct.length;
558 //CreateVar (2, "d", &m2, &n2, &l2);
559 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
560 if(readFlag==SWT_GWSUPPORT_ERROR)
561 {
562 return 0;
563 }
564 //CreateVar (3, "d", &m3, &n3, &l3);
565 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m3 , n3 , &output2 );
566 if(readFlag==SWT_GWSUPPORT_ERROR)
567 {
568 return 0;
569 }
570
571 verbatim_copy (pWaveStruct.pLowPass, m2*n2,output1, m2*n2);
572 filter_clear();
573
574 sp_rbior_analysis_initialize (member, &pWaveStruct);
575 wrev(pWaveStruct.pLowPass, m3 * n3, output2, m3 * n3);
576 filter_clear();
577
578 //LhsVar (1) = 2;
579 //LhsVar (2) = 3;
580 return 0;
581 }
582
583 int
int_wfilters(char * fname,void * pvApiCtx)584 int_wfilters
585 #ifdef _SCILAB6_
586 (char *fname, void* pvApiCtx)
587 #else
588 (char *fname)
589 #endif
590 {
591 static int l1, m1, n1, l2, m2, n2, l3, m3, n3;
592 static int l4, m4, n4, l5, m5, n5;
593 static int minlhs = 2, maxlhs = 4, minrhs = 1, maxrhs = 2;
594 int errCode, flow, family, member, ii;
595 Func ana_fun, syn_fun;
596 swt_wavelet pWaveStruct;
597 int readFlag;
598 char * input_string1 = NULL;
599 char * input_string2 = NULL;
600 double *output1;
601 double *output2;
602 double *output3;
603 double *output4;
604
605 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
606 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
607
608 errCode = SUCCESS;
609 if (swt_gwsupport_GetType(pvApiCtx, 1)!=sci_strings)
610 errCode = UNKNOWN_INPUT_ERR;
611 if (errCode != SUCCESS)
612 {
613 validate_print (errCode);
614 return 0;
615 }
616
617 //GetRhsVar (1, "c", &m1, &n1, &l1);
618 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
619 m1=1;n1=1;
620 if(readFlag==SWT_GWSUPPORT_ERROR)
621 {
622 return 0;
623 }
624 l2 = 0;
625
626 if (Rhs==2)
627 {
628 if (swt_gwsupport_GetType(pvApiCtx, 2)!=sci_strings)
629 errCode = UNKNOWN_INPUT_ERR;
630 if (errCode != SUCCESS)
631 {
632 validate_print (errCode);
633 return 0;
634 }
635 //GetRhsVar (2, "c", &m2, &n2, &l2);
636 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string2 );
637 m2=1;n2=1;
638 if(readFlag==SWT_GWSUPPORT_ERROR)
639 {
640 return 0;
641 }
642 }
643
644 wfilters_form_validate (pvApiCtx, &errCode, &flow, input_string2,Rhs,Lhs);
645 if (errCode != SUCCESS)
646 {
647 validate_print (errCode);
648 return 0;
649 }
650 wfilters_content_validate (pvApiCtx, &errCode, input_string1);
651 if (errCode != SUCCESS)
652 {
653 validate_print (errCode);
654 return 0;
655 }
656
657 switch (flow) {
658 case 1:
659 {
660 //sciprint("enter flow 1!\n");
661 wavelet_parser(input_string1,&family,&member);
662 wavelet_fun_parser (input_string1, &ii);
663 ana_fun = wi[ii].analysis;
664 syn_fun = wi[ii].synthesis;
665 (*ana_fun)(member, &pWaveStruct);
666 m2 = 1;
667 m3 = 1;
668 m4 = 1;
669 m5 = 1;
670 n2 = pWaveStruct.length;
671 n3 = pWaveStruct.length;
672 n4 = pWaveStruct.length;
673 n5 = pWaveStruct.length;
674 //CreateVar (2, "d", &m2, &n2, &l2);
675 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
676 if(readFlag==SWT_GWSUPPORT_ERROR)
677 {
678 return 0;
679 }
680 //CreateVar (3, "d", &m3, &n3, &l3);
681 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m3 , n3 , &output2 );
682 if(readFlag==SWT_GWSUPPORT_ERROR)
683 {
684 return 0;
685 }
686 //CreateVar (4, "d", &m4, &n4, &l4);
687 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 3, m4 , n4 , &output3 );
688 if(readFlag==SWT_GWSUPPORT_ERROR)
689 {
690 return 0;
691 }
692 //CreateVar (5, "d", &m5, &n5, &l5);
693 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 4, m5 , n5 , &output4 );
694 if(readFlag==SWT_GWSUPPORT_ERROR)
695 {
696 return 0;
697 }
698 verbatim_copy (pWaveStruct.pLowPass, m2*n2, output1, m2*n2);
699 verbatim_copy (pWaveStruct.pHiPass, m3*n3, output2, m3*n3);
700 (*syn_fun)(member, &pWaveStruct);
701 verbatim_copy (pWaveStruct.pLowPass, m4*n4, output3, m4*n4);
702 verbatim_copy (pWaveStruct.pHiPass, m5*n5, output4, m5*n5);
703 filter_clear();
704 // AssignOutputVariable(pvApiCtx,1) = 2;
705 // AssignOutputVariable(pvApiCtx,2) = 3;
706 // AssignOutputVariable(pvApiCtx,3) = 4;
707 // AssignOutputVariable(pvApiCtx,4) = 5;
708 break;
709 }
710 case 2:
711 {
712 wavelet_parser(input_string1,&family,&member);
713 wavelet_fun_parser (input_string1, &ii);
714 ana_fun = wi[ii].analysis;
715 (*ana_fun)(member, &pWaveStruct);
716 m3 = 1;
717 m4 = 1;
718 n3 = pWaveStruct.length;
719 n4 = pWaveStruct.length;
720 //CreateVar (3, "d", &m3, &n3, &l3);
721 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
722 if(readFlag==SWT_GWSUPPORT_ERROR)
723 {
724 return 0;
725 }
726 //CreateVar (4, "d", &m4, &n4, &l4);
727 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m4 , n4 , &output2 );
728 if(readFlag==SWT_GWSUPPORT_ERROR)
729 {
730 return 0;
731 }
732 verbatim_copy (pWaveStruct.pLowPass, m3*n3, output1, m3*n3);
733 verbatim_copy (pWaveStruct.pHiPass, m4*n4, output2, m4*n4);
734 filter_clear();
735 // LhsVar (1) = 3;
736 // LhsVar (2) = 4;
737 break;
738 }
739 case 3:
740 {
741 wavelet_parser(input_string1,&family,&member);
742 wavelet_fun_parser (input_string1, &ii);
743 syn_fun = wi[ii].synthesis;
744 (*syn_fun)(member, &pWaveStruct);
745 m3 = 1;
746 m4 = 1;
747 n3 = pWaveStruct.length;
748 n4 = pWaveStruct.length;
749 //CreateVar (3, "d", &m3, &n3, &l3);
750 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
751 if(readFlag==SWT_GWSUPPORT_ERROR)
752 {
753 return 0;
754 }
755 //CreateVar (4, "d", &m4, &n4, &l4);
756 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m4 , n4 , &output2 );
757 if(readFlag==SWT_GWSUPPORT_ERROR)
758 {
759 return 0;
760 }
761 verbatim_copy (pWaveStruct.pLowPass, m3*n3, output1, m3*n3);
762 verbatim_copy (pWaveStruct.pHiPass, m4*n4, output2, m4*n4);
763 filter_clear();
764 //LhsVar (1) = 3;
765 //LhsVar (2) = 4;
766 break;
767 }
768 case 4:
769 {
770 wavelet_parser(input_string1,&family,&member);
771 wavelet_fun_parser (input_string1, &ii);
772 ana_fun = wi[ii].analysis;
773 (*ana_fun)(member, &pWaveStruct);
774 m3 = 1;
775 m4 = 1;
776 n3 = pWaveStruct.length;
777 n4 = pWaveStruct.length;
778 //CreateVar (3, "d", &m3, &n3, &l3);
779 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
780 if(readFlag==SWT_GWSUPPORT_ERROR)
781 {
782 return 0;
783 }
784 //CreateVar (4, "d", &m4, &n4, &l4);
785 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m4 , n4 , &output2 );
786 if(readFlag==SWT_GWSUPPORT_ERROR)
787 {
788 return 0;
789 }
790 verbatim_copy (pWaveStruct.pLowPass, m3*n3, output1, m3*n3);
791 //filter_clear();
792 syn_fun = wi[ii].synthesis;
793 (*syn_fun)(member, &pWaveStruct);
794 verbatim_copy (pWaveStruct.pLowPass, m4*n4, output2, m4*n4);
795 filter_clear();
796 //LhsVar (1) = 3;
797 //LhsVar (2) = 4;
798 break;
799 }
800 case 5:
801 {
802 wavelet_parser(input_string1,&family,&member);
803 wavelet_fun_parser (input_string1, &ii);
804 ana_fun = wi[ii].analysis;
805 (*ana_fun)(member, &pWaveStruct);
806 m3 = 1;
807 m4 = 1;
808 n3 = pWaveStruct.length;
809 n4 = pWaveStruct.length;
810 //CreateVar (3, "d", &m3, &n3, &l3);
811 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
812 if(readFlag==SWT_GWSUPPORT_ERROR)
813 {
814 return 0;
815 }
816 //CreateVar (4, "d", &m4, &n4, &l4);
817 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m4 , n4 , &output2 );
818 if(readFlag==SWT_GWSUPPORT_ERROR)
819 {
820 return 0;
821 }
822 verbatim_copy (pWaveStruct.pHiPass, m3*n3, output1, m3*n3);
823 syn_fun = wi[ii].synthesis;
824 (*syn_fun)(member, &pWaveStruct);
825 verbatim_copy (pWaveStruct.pHiPass, m4*n4, output2, m4*n4);
826 filter_clear();
827 //LhsVar (1) = 3;
828 //LhsVar (2) = 4;
829 break;
830 }
831 default:
832 break;
833 }
834
835 return 0;
836 }
837
838
839 int
int_wmaxlev(char * fname,void * pvApiCtx)840 int_wmaxlev
841 #ifdef _SCILAB6_
842 (char *fname, void* pvApiCtx)
843 #else
844 (char *fname)
845 #endif
846 {
847 static int l1, m1, n1, l2, m2, n2, l3, m3, n3;
848 static int minlhs = 1, maxlhs = 1, minrhs = 2, maxrhs = 2;
849 int ii, stride, val, stride1, stride2, val1, val2;
850 // int filterLen;
851 swt_wavelet pWaveStruct;
852 int errCode, family, member;
853 Func syn_fun;
854 int readFlag;
855 char * input_string1 = NULL;
856 int *input1;
857 int *output1;
858
859
860 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
861 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
862
863 wmaxlev_form_validate (pvApiCtx, &errCode);
864 if (errCode != SUCCESS)
865 {
866 validate_print (errCode);
867 return 0;
868 }
869
870 //GetRhsVar (1, "i", &m1, &n1, &l1);
871 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 1, &m1 , &n1 , &input1 );
872 if(readFlag==SWT_GWSUPPORT_ERROR)
873 {
874 return 0;
875 }
876 //GetRhsVar (2, "c", &m2, &n2, &l2);
877 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname,2 , &input_string1 );
878 m2=1;n2=1;
879 if(readFlag==SWT_GWSUPPORT_ERROR)
880 {
881 return 0;
882 }
883
884 wfilters_content_validate (pvApiCtx, &errCode, input_string1);
885 if (errCode != SUCCESS)
886 {
887 validate_print (errCode);
888 return 0;
889 }
890
891 wavelet_parser(input_string1,&family,&member);
892 wavelet_fun_parser (input_string1, &ii);
893 syn_fun = wi[ii].synthesis;
894 (*syn_fun)(member, &pWaveStruct);
895 filter_clear();
896 if (sci_matrix_scalar_real(pvApiCtx,1))
897 {
898 if (input1[0] <= 0)
899 {
900 sciprint("Input integer must be positive!\n");
901 return 0;
902 }
903 wave_len_validate (input1[0], pWaveStruct.length,
904 &stride, &val);
905 if (val == 0)
906 {
907 sciprint
908 ("Unrecognized Input Pattern or parameter not valid for the algorithm! Please refer to help pages!\n");
909 return 0;
910 }
911 else
912 {
913 m3 = 1;
914 n3 = 1;
915 //CreateVar (3, "i", &m3, &n3, &l3);
916 readFlag = swt_gwsupport_AllocMatrixOfDoublesAsInteger (pvApiCtx, fname, 1, m3 , n3 , &output1 );
917 if(readFlag==SWT_GWSUPPORT_ERROR)
918 {
919 return 0;
920 }
921 output1[0] = stride;
922 // LhsVar (1) = 3;
923 }
924 }
925 else
926 {
927 //sciprint("enter matrix\n");
928 if (input1[0] <= 0)
929 {
930 sciprint("Input integer must be positive!\n");
931 return 0;
932 }
933 if (input1[0] <= 0)
934 {
935 sciprint("Input integer must be positive!\n");
936 return 0;
937 }
938 wave_len_validate ( input1[0], pWaveStruct.length,
939 &stride1, &val1);
940 if (val1 == 0)
941 {
942 sciprint
943 ("The wavelet you select is not appropriate for that row size of the matrix!\n");
944 return 0;
945 }
946 wave_len_validate ( input1[1], pWaveStruct.length,
947 &stride2, &val2);
948
949 if (val2 == 0)
950 {
951 sciprint
952 ("The wavelet you select is not appropriate for that column size of the matrix!\n");
953 return 0;
954 }
955 if ((val1 == 0) || (val2 == 0))
956 return 0;
957 m3 = 1;
958 n3 = 1;
959 //CreateVar (3, "i", &m3, &n3, &l3);
960 readFlag = swt_gwsupport_AllocMatrixOfDoublesAsInteger (pvApiCtx, fname, 1, m3 , n3 , &output1 );
961 if(readFlag==SWT_GWSUPPORT_ERROR)
962 {
963 return 0;
964 }
965 output1[0] = (stride1 > stride2) ? stride2 : stride1;
966 //if (stride1>=stride2)
967 // istk(l3)[0]=stride2;
968 //else
969 // istk(l3)[0]=stride1;
970 // LhsVar (1) = 3;
971 }
972
973 return 0;
974 }
975
976
977 int
int_dwtmode(char * fname,void * pvApiCtx)978 int_dwtmode
979 #ifdef _SCILAB6_
980 (char *fname, void* pvApiCtx)
981 #else
982 (char *fname)
983 #endif
984 {
985 static int l1, m1, n1, l2, m2, n2, l3, m3, n3;
986 static int minlhs = 0, maxlhs = 1, minrhs = 0, maxrhs = 2;
987 int errCode;
988 //int row1, row2;
989 // int col;
990 //char *Str[] = {"symhh"};
991 //char sss[6] = "symhh";
992 char **Str;
993 int i;
994 int readFlag;
995 char * input_string1 = NULL;
996 char * input_string2 = NULL;
997
998 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
999 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
1000
1001
1002 if (Rhs == 0)
1003 dwt_print();
1004 else if (Rhs == 1)
1005 {
1006 //GetMatrixdims(1,&row,&col);
1007 if (sci_strings_scalar(pvApiCtx,1))
1008 {
1009 //sciprint("before GetVAR\n");
1010 //GetRhsVar(1, "c", &m1, &n1, &l1);
1011 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
1012 m1=1;n1=1;
1013 if(readFlag==SWT_GWSUPPORT_ERROR)
1014 {
1015 return 0;
1016 }
1017 if (!strcmp(input_string1,"status"))
1018 dwt_print();
1019 else
1020 {
1021 dwt_write(input_string1,&errCode);
1022 if (errCode != SUCCESS)
1023 {
1024 validate_print (errCode);
1025 return 0;
1026 }
1027 sciprint("\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
1028 sciprint("!! WARNING: Change DWT Extension Mode !!\n");
1029 sciprint("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
1030 dwt_print();
1031 }
1032 }
1033 else
1034 {
1035 sciprint("Unrecognized Input Pattern or parameter not valid for the algorithm! Please refer to help pages!\n");
1036 return 0;
1037 }
1038 }
1039 else if (Rhs == 2)
1040 {
1041 // GetMatrixdims(1, &row1, &col1);
1042 //GetMatrixdims(2, &row2, &col2);
1043 /* if ((swt_gwsupport_GetType(pvApiCtx, 1) == sci_strings) && (swt_gwsupport_GetType(pvApiCtx, 2) == sci_strings) && (is_scalar(row1,col1)) && (is_scalar(row2,col2)))*/
1044 if (sci_strings_scalar(pvApiCtx, 1) && sci_strings_scalar(pvApiCtx, 2))
1045 {
1046 //GetRhsVar(1, "c", &m1, &n1, &l1);
1047 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
1048 m1=1;n1=1;
1049 if(readFlag==SWT_GWSUPPORT_ERROR)
1050 {
1051 return 0;
1052 }
1053 //GetRhsVar(2, "c", &m2, &n2, &l2);
1054 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string2 );
1055 m2=1;n2=1;
1056 if(readFlag==SWT_GWSUPPORT_ERROR)
1057 {
1058 return 0;
1059 }
1060 if ((strcmp(input_string1,"status")==0) && (strcmp(input_string2,"nodisp")==0))
1061 {
1062 m3 = 1;
1063 n3 = 1;
1064 //*Str = sss;
1065
1066 Str=NULL;
1067 Str = (char **)malloc(1*sizeof(char *));
1068
1069 for(i=0; i<(int)1; i++)
1070 {
1071 Str[i] = (char *)malloc(6*sizeof(char));
1072
1073 }
1074 //printf("before dwt_parse\n");
1075 dwt_parse(Str);
1076 //printf("after dwt_parse\n");
1077 //printf("%s\n",Str[0]);
1078 //CreateVarFromPtr(3,"S", &m3, &n3, Str);
1079 readFlag = swt_gwsupport_CreateMatrixOfString (pvApiCtx, fname, 1, m3 , n3 , Str );
1080 if(readFlag==SWT_GWSUPPORT_ERROR)
1081 {
1082 return 0;
1083 }
1084 //printf("after Create\n");
1085 //AssignOutputVariable(pvApiCtx,1) = 3;
1086 //FreeRhsSVar(Str);
1087 }
1088 else if (strcmp(input_string2,"nodisp")==0 )
1089 {
1090 dwt_write(input_string1,&errCode);
1091 if (errCode != SUCCESS)
1092 {
1093 validate_print (errCode);
1094 return 0;
1095 }
1096 }
1097 else
1098 {
1099 sciprint("Unrecognized Input Pattern or parameter not valid for the algorithm! Please refer to help pages!\n");
1100 return 0;
1101 }
1102 }
1103 else
1104 {
1105 sciprint("Unrecognized Input Pattern or parameter not valid for the algorithm! Please refer to help pages!\n");
1106 return 0;
1107 }
1108 }
1109 else
1110 {
1111 sciprint("Unrecognized Input Pattern or parameter not valid for the algorithm! Please refer to help pages!\n");
1112 return 0;
1113 }
1114 return 0;
1115 }
1116