1 /*
2 * -------------------------------------------------------------------------
3 * dwt1d_int.c -- 1-D signal decomposition and reconstruction interface
4 * SWT - Scilab wavelet toolbox
5 * Copyright (C) 2005-2006 Roger Liu
6 * Copyright (C) 2010-2014 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 // #include <stack-c.h>
26
27 int
int_dwt(char * fname,void * pvApiCtx)28 int_dwt
29 #ifdef _SCILAB6_
30 (char *fname, void* pvApiCtx)
31 #else
32 (char *fname)
33 #endif
34 {
35 static int m1, n1, m2, n2, m3, n3;
36 static int m4, n4, m5, n5, m6, n6;
37 static int m7, n7, minlhs=2, maxlhs=2, minrhs=2, maxrhs=5;
38 int errCode, flow, family, member, ii, stride, val;
39 Func ana_fun;
40 swt_wavelet pWaveStruct;
41 extend_method extMethod;
42
43 int readFlag;
44 double *input1 = NULL;
45 double *input2 = NULL;
46 double *input3 = NULL;
47 double *input4 = NULL;
48 double *input5 = NULL;
49
50 char * input_string1 = NULL;
51 char * input_string2 = NULL;
52 char * input_string3 = NULL;
53 char * input_string4 = NULL;
54 char * input_string5 = NULL;
55 char * input_string6 = NULL;
56 double *output1 = NULL;
57 double *output2 = NULL;
58 double *output3 = NULL;
59 double *output4 = NULL;
60 double *output5 = NULL;
61
62 CheckInputArgument(pvApiCtx,minrhs,maxrhs);
63 CheckOutputArgument(pvApiCtx,minlhs,maxlhs);
64
65 //GetRhsVar(1, "d", &m1, &n1, &l1);
66
67 dwt_form_validate (pvApiCtx, &errCode,&flow,Rhs);
68 if (errCode != SUCCESS)
69 {
70 validate_print (errCode);
71 //sciprint("right here!\n");
72 return 0;
73 }
74
75 //CheckOutputArgument(pvApiCtx,minlhs,maxlhs);
76
77
78
79 switch (flow){
80 case 1:
81 {
82 //GetRhsVar(1, "d", &m1, &n1, &l1);
83 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
84 if(readFlag==SWT_GWSUPPORT_ERROR)
85 {
86 return 0;
87 }
88
89 //GetRhsVar(2, "c", &m2, &n2, &l2);
90 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string2 );
91 if(readFlag==SWT_GWSUPPORT_ERROR)
92 {
93 return 0;
94 }
95 dwt_content_validate (pvApiCtx, &errCode,flow,input_string2,input_string3,input_string4);
96
97 if (errCode != SUCCESS)
98 {
99 validate_print (errCode);
100 return 0;
101 }
102 wavelet_parser(input_string2,&family,&member);
103 wavelet_fun_parser (input_string2, &ii);
104 ana_fun = wi[ii].analysis;
105 (*ana_fun)(member, &pWaveStruct);
106 wave_len_validate ( m1*n1, pWaveStruct.length,
107 &stride, &val);
108
109 if (!val)
110 {
111 sciprint("Input signal is not valid for selected decompostion level and wavelets!\n");
112 return 0;
113 }
114 m3 = 1;
115 m4 = 1;
116 n3 = (int)floor((m1*n1 + pWaveStruct.length - 1)/2);
117 if (getdwtMode()==PER)
118 n3 = (int)ceil(((double)(m1*n1))/2.0);
119 n4 = n3;
120 //CreateVar(3, "d", &m3, &n3, &l3);
121 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
122 if(readFlag==SWT_GWSUPPORT_ERROR)
123 {
124 return 0;
125 }
126 //CreateVar(4, "d", &m4, &n4, &l4);
127 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m4 , n4 , &output2 );
128 if(readFlag==SWT_GWSUPPORT_ERROR)
129 {
130 return 0;
131 }
132
133 dwt_neo (input1, m1*n1, pWaveStruct.pLowPass,
134 pWaveStruct.pHiPass, pWaveStruct.length,
135 output1, output2, n3, getdwtMode());
136 filter_clear();
137 //AssignOutputVariable(pvApiCtx,1) = nbInputArgument(pvApiCtx) + 1;
138 //AssignOutputVariable(pvApiCtx,2) = nbInputArgument(pvApiCtx) + 2;
139 break;
140 }
141 case 2:
142 {
143 //GetRhsVar(1, "d", &m1, &n1, &l1);
144 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
145 if(readFlag==SWT_GWSUPPORT_ERROR)
146 {
147 return 0;
148 }
149 //GetRhsVar(2, "d", &m2, &n2, &l2);
150 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 2, &m2, &n2, &input2);
151 if(readFlag==SWT_GWSUPPORT_ERROR)
152 {
153 return 0;
154 }
155 //GetRhsVar(3, "d", &m3, &n3, &l3);
156 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 3, &m3, &n3, &input3);
157 if(readFlag==SWT_GWSUPPORT_ERROR)
158 {
159 return 0;
160 }
161 dwt_content_validate (pvApiCtx, &errCode,flow,input_string2,input_string3,input_string4);
162 if (errCode != SUCCESS)
163 {
164 validate_print (errCode);
165 return 0;
166 }
167 wave_len_validate ( m1*n1, m3*n3, &stride, &val);
168 if (!val)
169 {
170 sciprint("Input signal is not valid for selected decompostion level and wavelets!\n");
171 return 0;
172 }
173 m4 = 1;
174 m5 = 1;
175 n4 = (int)floor((m1*n1 + m2*n2 - 1)/2);
176 if (getdwtMode()==PER)
177 n4 = (int)ceil(((double)(m1*n1))/2.0);
178 n5 = n4;
179 //CreateVar(4, "d", &m4, &n4, &l4);
180 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
181 if(readFlag==SWT_GWSUPPORT_ERROR)
182 {
183 return 0;
184 }
185 //CreateVar(5, "d", &m5, &n5, &l5);
186 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m5 , n5 , &output2 );
187 if(readFlag==SWT_GWSUPPORT_ERROR)
188 {
189 return 0;
190 }
191 dwt_neo (input1, m1*n1, input2, input3, m2*n2,
192 output1, output2, n4, getdwtMode());
193 //AssignOutputVariable(pvApiCtx,1) = 4;
194 //AssignOutputVariable(pvApiCtx,2) = 5;
195 break;
196 }
197 case 3:
198 {
199 //GetRhsVar(1, "d", &m1, &n1, &l1);
200 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
201 if(readFlag==SWT_GWSUPPORT_ERROR)
202 {
203 return 0;
204 }
205
206 //GetRhsVar(2, "c", &m2, &n2, &l2);
207 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string2 );
208 if(readFlag==SWT_GWSUPPORT_ERROR)
209 {
210 return 0;
211 }
212 //GetRhsVar(3, "c", &m3, &n3, &l3);
213 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 3 , &input_string3 );
214 if(readFlag==SWT_GWSUPPORT_ERROR)
215 {
216 return 0;
217 }
218 //GetRhsVar(4, "c", &m4, &n4, &l4);
219 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 4 , &input_string4 );
220 if(readFlag==SWT_GWSUPPORT_ERROR)
221 {
222 return 0;
223 }
224 dwt_content_validate (pvApiCtx, &errCode,flow,input_string2,input_string3,input_string4);
225 if (errCode != SUCCESS)
226 {
227 validate_print (errCode);
228 return 0;
229 }
230 //dwt_write(cstk(l4),&errCode);
231 extend_method_parse (input_string4, &extMethod);
232 if (errCode != SUCCESS)
233 {
234 validate_print (errCode);
235 return 0;
236 }
237 wavelet_parser(input_string2,&family,&member);
238 wavelet_fun_parser (input_string2, &ii);
239 ana_fun = wi[ii].analysis;
240 (*ana_fun)(member, &pWaveStruct);
241 wave_len_validate ( m1*n1, pWaveStruct.length,
242 &stride, &val);
243 if (!val)
244 {
245 sciprint("Input signal is not valid for selected decompostion level and wavelets!\n");
246 return 0;
247 }
248 m5 = 1;
249 m6 = 1;
250 n5 = (int)floor((m1*n1 + pWaveStruct.length - 1)/2);
251 if (extMethod==PER)
252 n5 = (int)ceil(((double)(m1*n1))/2.0);
253 n6 = n5;
254 //CreateVar(5, "d", &m5, &n5, &l5);
255 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m5 , n5 , &output1 );
256 if(readFlag==SWT_GWSUPPORT_ERROR)
257 {
258 return 0;
259 }
260 //CreateVar(6, "d", &m6, &n6, &l6);
261 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m6 , n6 , &output2 );
262 if(readFlag==SWT_GWSUPPORT_ERROR)
263 {
264 return 0;
265 }
266 dwt_neo (input1, m1*n1, pWaveStruct.pLowPass,
267 pWaveStruct.pHiPass, pWaveStruct.length,
268 output1, output2, n5, extMethod);
269 //AssignOutputVariable(pvApiCtx,1) = 5;
270 //AssignOutputVariable(pvApiCtx,2) = 6;
271 filter_clear();
272 break;
273 }
274 case 4:
275 {
276 //GetRhsVar(1, "d", &m1, &n1, &l1);
277 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
278 if(readFlag==SWT_GWSUPPORT_ERROR)
279 {
280 return 0;
281 }
282 //GetRhsVar(2, "d", &m2, &n2, &l2);
283 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 2, &m2, &n2, &input2);
284 if(readFlag==SWT_GWSUPPORT_ERROR)
285 {
286 return 0;
287 }
288 //GetRhsVar(3, "d", &m3, &n3, &l3);
289 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 3, &m3, &n3, &input3);
290 if(readFlag==SWT_GWSUPPORT_ERROR)
291 {
292 return 0;
293 }
294 //GetRhsVar(4, "c", &m4, &n4, &l4);
295 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 4 , &input_string4 );
296 if(readFlag==SWT_GWSUPPORT_ERROR)
297 {
298 return 0;
299 }
300 //GetRhsVar(5, "c", &m5, &n5, &l5);
301 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 5 , &input_string5 );
302 if(readFlag==SWT_GWSUPPORT_ERROR)
303 {
304 return 0;
305 }
306 dwt_content_validate (pvApiCtx, &errCode,flow,input_string1,input_string2,input_string3);
307 if (errCode != SUCCESS)
308 {
309 validate_print (errCode);
310 return 0;
311 }
312 //dwt_write(cstk(l4),&errCode);
313 extend_method_parse (input_string4, &extMethod);
314 if (errCode != SUCCESS)
315 {
316 validate_print (errCode);
317 return 0;
318 }
319 wave_len_validate ( m1*n1, m3*n3, &stride, &val);
320 if (!val)
321 {
322 sciprint("Input signal is not valid for selected decompostion level and wavelets!\n");
323 return 0;
324 }
325 m6 = 1;
326 m7 = 1;
327 n6 = (int)floor((m1*n1 + m2*n2 - 1)/2);
328 if (extMethod==PER)
329 n6 = (int)ceil(((double)(m1*n1))/2.0);
330 n7 = n6;
331 //CreateVar(6, "d", &m6, &n6, &l6);
332 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m6 , n6 , &output1 );
333 if(readFlag==SWT_GWSUPPORT_ERROR)
334 {
335 return 0;
336 }
337 //CreateVar(7, "d", &m7, &n7, &l7);
338 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m7 , n7 , &output2 );
339 if(readFlag==SWT_GWSUPPORT_ERROR)
340 {
341 return 0;
342 }
343 dwt_neo (input1, m1*n1, input2, input3, m2*n2,
344 output1, output2, n6, extMethod);
345 //AssignOutputVariable(pvApiCtx,1) = 6;
346 //AssignOutputVariable(pvApiCtx,2) = 7;
347 break;
348 }
349 default:
350 break;
351 }
352
353 //sciprint("flow=%d\n", flow);
354 return 0;
355 }
356
357 int
int_idwt(char * fname,void * pvApiCtx)358 int_idwt
359 #ifdef _SCILAB6_
360 (char *fname, void* pvApiCtx)
361 #else
362 (char *fname)
363 #endif
364 {
365 static int m1, n1, m2, n2, m3, n3, m4, n4;
366 static int m5, n5, m6, n6, m7, n7, m8, n8;
367 static minlhs=1, maxlhs=1, minrhs=3, maxrhs=7;
368 int errCode, flow, family, member, ii, stride, val;
369 Func syn_fun;
370 swt_wavelet pWaveStruct;
371 extend_method extMethod;
372
373 int readFlag;
374 double *input1;
375 double *input2;
376 double *input3;
377 double *input4;
378 double *input5;
379 int *int_input1;
380 int *int_input2;
381 int *int_input3;
382 int *int_input4;
383 int *int_input5;
384
385 char * input_string1 = NULL;
386 char * input_string2 = NULL;
387 char * input_string3 = NULL;
388 char * input_string4 = NULL;
389 char * input_string5 = NULL;
390 char * input_string6 = NULL;
391 char * input_string7 = NULL;
392
393 double *output1;
394
395
396
397 CheckInputArgument(pvApiCtx,minrhs,maxrhs);
398 CheckOutputArgument(pvApiCtx,minlhs,maxlhs);
399
400 idwt_form_validate (pvApiCtx, &errCode,&flow,Rhs);
401 if (errCode != SUCCESS)
402 {
403 validate_print (errCode);
404 return 0;
405 }
406
407
408
409 switch (flow) {
410 case 1:
411 {
412 //GetRhsVar(1, "d", &m1, &n1, &l1);
413 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 1, &m1, &n1 , &input1 );
414 if(readFlag==SWT_GWSUPPORT_ERROR)
415 {
416 return 0;
417 }
418 //GetRhsVar(2, "d", &m2, &n2, &l2);
419 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
420 if(readFlag==SWT_GWSUPPORT_ERROR)
421 {
422 return 0;
423 }
424 //GetRhsVar(3, "c", &m3, &n3, &l3);
425 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 3 , &input_string3 );
426 m3=1;n3=1;
427 if(readFlag==SWT_GWSUPPORT_ERROR)
428 {
429 return 0;
430 }
431 errCode = SUCCESS;
432 //idwt_content_validate (pvApiCtx, &errCode,flow,l1,l2,l3,l4,l5,l6,l7);
433 wfilters_content_validate (pvApiCtx, &errCode, input_string3);
434 if (errCode != SUCCESS)
435 {
436 validate_print (errCode);
437 return 0;
438 }
439 wavelet_parser(input_string3,&family,&member);
440 wavelet_fun_parser (input_string3, &ii);
441 syn_fun = wi[ii].synthesis;
442 (*syn_fun)(member, &pWaveStruct);
443 wave_len_validate ( (m1*n1>0)?(m1*n1):(m2*n2),
444 pWaveStruct.length, &stride, &val);
445 if (!val)
446 {
447 sciprint("Input signal is not valid for selected decompostion level and wavelets!\n");
448 return 0;
449 }
450 m4 = 1;
451 if (m1*n1 != 0)// && (getdwtMode()!=PER))
452 n4 = m1*n1*2 - pWaveStruct.length + 2;
453 if ((m1*n1 != 0) && (getdwtMode()==PER))
454 n4 = m1*n1*2;
455 if (m1*n1 == 0)// && (getdwtMode()!=PER))
456 n4 = m2*n2*2 - pWaveStruct.length + 2;
457 if ((m1*n1 == 0) && (getdwtMode()==PER))
458 n4 = m2*n2*2;
459 //CreateVar(4, "d", &m4, &n4, &l4);
460 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
461 if(readFlag==SWT_GWSUPPORT_ERROR)
462 {
463 return 0;
464 }
465 if ((m1*n1==0) && (m2*n2!=0))
466 idwt_detail_neo (input2, m2*n2, pWaveStruct.pHiPass,
467 pWaveStruct.length, output1, m4*n4);
468 else if ((m1*n1!=0) && (m2*n2==0))
469 idwt_approx_neo (input1, m1*n1, pWaveStruct.pLowPass,
470 pWaveStruct.length, output1, m4*n4);
471 else if ((m1*n1!=0) && (m2*n2!=0))
472 idwt_neo (input1, input2, m1*n1,
473 pWaveStruct.pLowPass, pWaveStruct.pHiPass,
474 pWaveStruct.length, output1, m4*n4);
475 else
476 {
477 errCode=UNKNOWN_INPUT_ERR;
478 validate_print (errCode);
479 return 0;
480 }
481 //AssignOutputVariable(pvApiCtx,1) = 4;
482 filter_clear();
483 break;
484 }
485 case 2:
486 {
487 //GetRhsVar(1, "d", &m1, &n1, &l1);
488 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 1, &m1, &n1 , &input1 );
489 if(readFlag==SWT_GWSUPPORT_ERROR)
490 {
491 return 0;
492 }
493 //GetRhsVar(2, "d", &m2, &n2, &l2);
494 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
495 if(readFlag==SWT_GWSUPPORT_ERROR)
496 {
497 return 0;
498 }
499 //GetRhsVar(3, "d", &m3, &n3, &l3);
500 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 3, &m3, &n3 , &input3 );
501 if(readFlag==SWT_GWSUPPORT_ERROR)
502 {
503 return 0;
504 }
505 //GetRhsVar(4, "d", &m4, &n4, &l4);
506 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 4, &m4, &n4 , &input4 );
507 if(readFlag==SWT_GWSUPPORT_ERROR)
508 {
509 return 0;
510 }
511 idwt_content_validate (pvApiCtx, &errCode,flow, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
512 if (errCode != SUCCESS)
513 {
514 validate_print (errCode);
515 return 0;
516 }
517 wave_len_validate ( (m1*n1>0)?(m1*n1):(m2*n2),
518 (m3*n3), &stride, &val);
519 if (!val)
520 {
521 sciprint("Input signal is not valid for selected decompostion level and wavelets!\n");
522 return 0;
523 }
524 m5 = 1;
525 if (m1*n1 != 0)// && (getdwtMode()!=PER))
526 n5 = m1*n1*2 - m3*n3 + 2;
527 if ((m1*n1 != 0) && (getdwtMode()==PER))
528 n5 = m1*n1*2;
529 if (m1*n1 == 0) //&& (getdwtMode()!=PER))
530 n5 = m2*n2*2 - m3*n3 + 2;
531 if ((m1*n1 == 0) && (getdwtMode()==PER))
532 n5 = m2*n2*2;
533 //CreateVar(5, "d", &m5, &n5, &l5);
534 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m5 , n5 , &output1 );
535 if(readFlag==SWT_GWSUPPORT_ERROR)
536 {
537 return 0;
538 }
539 if ((m1*n1==0) && (m2*n2!=0))
540 idwt_detail_neo (input2, m2*n2, input4,
541 n4*m4, output1, m5*n5);
542 else if ((m1*n1!=0) && (m2*n2==0))
543 idwt_approx_neo (input1, m1*n1, input3,
544 n3*m3, output1, m5*n5);
545 else if ((m1*n1!=0) && (m2*n2!=0))
546 idwt_neo (input1, input2, m1*n1,
547 input3, input4, m3*n3, output1, m5*n5);
548 else
549 {
550 errCode=UNKNOWN_INPUT_ERR;
551 validate_print (errCode);
552 return 0;
553 }
554 //AssignOutputVariable(pvApiCtx,1) = 5;
555 break;
556 }
557 case 3:
558 {
559 //GetRhsVar(1, "d", &m1, &n1, &l1);
560 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 1, &m1, &n1 , &input1 );
561 if(readFlag==SWT_GWSUPPORT_ERROR)
562 {
563 return 0;
564 }
565 //GetRhsVar(2, "d", &m2, &n2, &l2);
566 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
567 if(readFlag==SWT_GWSUPPORT_ERROR)
568 {
569 return 0;
570 }
571 //GetRhsVar(3, "c", &m3, &n3, &l3);
572 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 3 , &input_string3 );
573 m3=1;n3=1;
574 if(readFlag==SWT_GWSUPPORT_ERROR)
575 {
576 return 0;
577 }
578 //GetRhsVar(4, "i", &m4, &n4, &l4);
579 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 4, &m4, &n4 , &int_input4 );
580 if(readFlag==SWT_GWSUPPORT_ERROR)
581 {
582 return 0;
583 }
584 idwt_content_validate (pvApiCtx, &errCode,flow, input_string3, int_input4, NULL, NULL, NULL, NULL, NULL);
585 if (errCode != SUCCESS)
586 {
587 validate_print (errCode);
588 return 0;
589 }
590 wavelet_parser(input_string3,&family,&member);
591 wavelet_fun_parser (input_string3, &ii);
592 syn_fun = wi[ii].synthesis;
593 (*syn_fun)(member, &pWaveStruct);
594 wave_len_validate ( (m1*n1>0)?(m1*n1):(m2*n2),
595 pWaveStruct.length, &stride, &val);
596 if (!val)
597 {
598 sciprint("Input signal is not valid for selected decompostion level and wavelets!\n");
599 return 0;
600 }
601 m5 = 1;
602 n5 = int_input4[0];
603 /*if (n5 > (((m1*n1>0)?(m1*n1):(m2*n2))*2 +
604 pWaveStruct.length - 1))
605 {
606 sciprint("Length Parameter is not valid for input vector!\n");
607 return 0;
608 }*/
609 if (n5 > (((m1*n1>0)?(m1*n1):(m2*n2))*2 +
610 pWaveStruct.length))
611 {
612 sciprint("Length Parameter is not valid for input vector!\n");
613 return 0;
614 }
615 //CreateVar(5, "d", &m5, &n5, &l5);
616 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m5 , n5 , &output1 );
617 if(readFlag==SWT_GWSUPPORT_ERROR)
618 {
619 return 0;
620 }
621 if ((m1*n1==0) && (m2*n2!=0))
622 idwt_detail_neo (input2, m2*n2, pWaveStruct.pHiPass,
623 pWaveStruct.length, output1, m5*n5);
624 else if ((m1*n1!=0) && (m2*n2==0))
625 idwt_approx_neo (input1, m1*n1, pWaveStruct.pLowPass,
626 pWaveStruct.length, output1, m5*n5);
627 else if ((m1*n1!=0) && (m2*n2!=0))
628 idwt_neo (input1, input2, m1*n1,
629 pWaveStruct.pLowPass, pWaveStruct.pHiPass,
630 pWaveStruct.length, output1, m5*n5);
631 else
632 {
633 errCode=UNKNOWN_INPUT_ERR;
634 validate_print (errCode);
635 return 0;
636 }
637 //AssignOutputVariable(pvApiCtx,1) = 5;
638 filter_clear();
639 break;
640 }
641 case 4:
642 {
643 //GetRhsVar(1, "d", &m1, &n1, &l1);
644 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 1, &m1, &n1 , &input1 );
645 if(readFlag==SWT_GWSUPPORT_ERROR)
646 {
647 return 0;
648 }
649 //GetRhsVar(2, "d", &m2, &n2, &l2);
650 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
651 if(readFlag==SWT_GWSUPPORT_ERROR)
652 {
653 return 0;
654 }
655 //GetRhsVar(3, "d", &m3, &n3, &l3);
656 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 3, &m3, &n3 , &input3 );
657 if(readFlag==SWT_GWSUPPORT_ERROR)
658 {
659 return 0;
660 }
661 //GetRhsVar(4, "d", &m4, &n4, &l4);
662 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 4, &m4, &n4 , &input4 );
663 if(readFlag==SWT_GWSUPPORT_ERROR)
664 {
665 return 0;
666 }
667 //GetRhsVar(5, "i", &m5, &n5, &l5);
668 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 5, &m5, &n5 , &int_input5 );
669 if(readFlag==SWT_GWSUPPORT_ERROR)
670 {
671 return 0;
672 }
673 idwt_content_validate (pvApiCtx, &errCode,flow, NULL, NULL, int_input5, NULL, NULL, NULL, NULL);
674 if (errCode != SUCCESS)
675 {
676 validate_print (errCode);
677 return 0;
678 }
679 wave_len_validate ( (m1*n1>0)?(m1*n1):(m2*n2),
680 (m3*n3), &stride, &val);
681 if (!val)
682 {
683 sciprint("Input signal is not valid for selected decompostion level and wavelets!\n");
684 return 0;
685 }
686 m6 = 1;
687 n6 = int_input5[0];
688 /*if (n6 > (((m1*n1>0)?(m1*n1):(m2*n2))*2 +
689 m3*n3 - 1))
690 {
691 sciprint("Length Parameter is not valid for input vector!\n");
692 return 0;
693 }*/
694 if (n6 > (((m1*n1>0)?(m1*n1):(m2*n2))*2 +
695 m3*n3))
696 {
697 sciprint("Length Parameter is not valid for input vector!\n");
698 return 0;
699 }
700 //CreateVar(6, "d", &m6, &n6, &l6);
701 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m6 , n6 , &output1 );
702 if(readFlag==SWT_GWSUPPORT_ERROR)
703 {
704 return 0;
705 }
706 if ((m1*n1==0) && (m2*n2!=0))
707 idwt_detail_neo (input2, m2*n2, input4,
708 n4*m4, output1, m6*n6);
709 else if ((m1*n1!=0) && (m2*n2==0))
710 idwt_approx_neo (input1, m1*n1, input3,
711 n3*m3, output1, m6*n6);
712 else if ((m1*n1!=0) && (m2*n2!=0))
713 idwt_neo (input1, input2, m1*n1,
714 input3, input4,
715 m3*n3, output1, m6*n6);
716 else
717 {
718 errCode=UNKNOWN_INPUT_ERR;
719 validate_print (errCode);
720 return 0;
721 }
722 //AssignOutputVariable(pvApiCtx,1) = 6;
723 break;
724 }
725 case 5:
726 {
727 //GetRhsVar(1, "d", &m1, &n1, &l1);
728 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 1, &m1, &n1 , &input1 );
729 if(readFlag==SWT_GWSUPPORT_ERROR)
730 {
731 return 0;
732 }
733 //GetRhsVar(2, "d", &m2, &n2, &l2);
734 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
735 if(readFlag==SWT_GWSUPPORT_ERROR)
736 {
737 return 0;
738 }
739 //GetRhsVar(3, "c", &m3, &n3, &l3);
740 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 3 , &input_string3 );
741 m3=1;n3=1;
742 if(readFlag==SWT_GWSUPPORT_ERROR)
743 {
744 return 0;
745 }
746 //GetRhsVar(4, "c", &m4, &n4, &l4);
747 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 4 , &input_string4 );
748 m4=1;n4=1;
749 if(readFlag==SWT_GWSUPPORT_ERROR)
750 {
751 return 0;
752 }
753 //GetRhsVar(5, "c", &m5, &n5, &l5);
754 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 5 , &input_string5 );
755 m5=1;n5=1;
756 if(readFlag==SWT_GWSUPPORT_ERROR)
757 {
758 return 0;
759 }
760 idwt_content_validate (pvApiCtx, &errCode,flow, input_string3, NULL, NULL, input_string4, input_string5, NULL, NULL);
761 if (errCode != SUCCESS)
762 {
763 validate_print (errCode);
764 return 0;
765 }
766 wavelet_parser(input_string3,&family,&member);
767 wavelet_fun_parser (input_string3, &ii);
768 syn_fun = wi[ii].synthesis;
769 (*syn_fun)(member, &pWaveStruct);
770 wave_len_validate ( (m1*n1>0)?(m1*n1):(m2*n2),
771 pWaveStruct.length, &stride, &val);
772 if (!val)
773 {
774 sciprint("Input signal is not valid for selected decompostion level and wavelets!\n");
775 return 0;
776 }
777 extend_method_parse (input_string5, &extMethod);
778 m6 = 1;
779 if (m1*n1 != 0)// && (getdwtMode()!=PER))
780 n6 = m1*n1*2 - pWaveStruct.length + 2;
781 if ((m1*n1 != 0) && (extMethod==PER))
782 n6 = m1*n1*2;
783 if (m1*n1 == 0) //&& (getdwtMode()!=PER))
784 n6 = m2*n2*2 - pWaveStruct.length + 2;
785 if ((m1*n1 == 0) && (extMethod==PER))
786 n6 = m2*n2*2;
787 //CreateVar(6, "d", &m6, &n6, &l6);
788 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m6 , n6 , &output1 );
789 if(readFlag==SWT_GWSUPPORT_ERROR)
790 {
791 return 0;
792 }
793 if ((m1*n1==0) && (m2*n2!=0))
794 idwt_detail_neo (input2, m2*n2, pWaveStruct.pHiPass,
795 pWaveStruct.length, output1, m6*n6);
796 else if ((m1*n1!=0) && (m2*n2==0))
797 idwt_approx_neo (input1, m1*n1, pWaveStruct.pLowPass,
798 pWaveStruct.length, output1, m6*n6);
799 else if ((m1*n1!=0) && (m2*n2!=0))
800 idwt_neo (input1, input2, m1*n1,
801 pWaveStruct.pLowPass, pWaveStruct.pHiPass,
802 pWaveStruct.length, output1, m6*n6);
803 else
804 {
805 errCode=UNKNOWN_INPUT_ERR;
806 validate_print (errCode);
807 return 0;
808 }
809 //AssignOutputVariable(pvApiCtx,1) = 6;
810 filter_clear();
811 break;
812 }
813 case 6:
814 {
815 //GetRhsVar(1, "d", &m1, &n1, &l1);
816 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 1, &m1, &n1 , &input1 );
817 if(readFlag==SWT_GWSUPPORT_ERROR)
818 {
819 return 0;
820 }
821 //GetRhsVar(2, "d", &m2, &n2, &l2);
822 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
823 if(readFlag==SWT_GWSUPPORT_ERROR)
824 {
825 return 0;
826 }
827 //GetRhsVar(3, "c", &m3, &n3, &l3);
828 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 3 , &input_string3 );
829 m3=1;n3=1;
830 if(readFlag==SWT_GWSUPPORT_ERROR)
831 {
832 return 0;
833 }
834 //GetRhsVar(4, "i", &m4, &n4, &l4);
835 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 4, &m4, &n4 , &int_input4 );
836 if(readFlag==SWT_GWSUPPORT_ERROR)
837 {
838 return 0;
839 }
840 //GetRhsVar(5, "c", &m5, &n5, &l5);
841 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 5 , &input_string5 );
842 m5=1;n5=1;
843 if(readFlag==SWT_GWSUPPORT_ERROR)
844 {
845 return 0;
846 }
847 //GetRhsVar(6, "c", &m6, &n6, &l6);
848 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 6 , &input_string6 );
849 m6=1;n6=1;
850 if(readFlag==SWT_GWSUPPORT_ERROR)
851 {
852 return 0;
853 }
854
855 idwt_content_validate (pvApiCtx, &errCode,flow, input_string3, int_input4, NULL, NULL, input_string5, input_string6, NULL);
856 if (errCode != SUCCESS)
857 {
858 validate_print (errCode);
859 return 0;
860 }
861 wavelet_parser(input_string3,&family,&member);
862 wavelet_fun_parser (input_string3, &ii);
863 syn_fun = wi[ii].synthesis;
864 (*syn_fun)(member, &pWaveStruct);
865 wave_len_validate ( (m1*n1>0)?(m1*n1):(m2*n2),
866 pWaveStruct.length, &stride, &val);
867 if (!val)
868 {
869 sciprint("Input signal is not valid for selected decompostion level and wavelets!\n");
870 return 0;
871 }
872 extend_method_parse (input_string6, &extMethod);
873 m7 = 1;
874 n7 = int_input4[0];
875 /*if (n7 > (((m1*n1>0)?(m1*n1):(m2*n2))*2 +
876 pWaveStruct.length - 1))
877 {
878 sciprint("Length Parameter is not valid for input vector!\n");
879 return 0;
880 }*/
881 if (n7 > (((m1*n1>0)?(m1*n1):(m2*n2))*2 +
882 pWaveStruct.length))
883 {
884 sciprint("Length Parameter is not valid for input vector!\n");
885 return 0;
886 }
887 //CreateVar(7, "d", &m7, &n7, &l7);
888 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m7 , n7 , &output1 );
889 if(readFlag==SWT_GWSUPPORT_ERROR)
890 {
891 return 0;
892 }
893 if ((m1*n1==0) && (m2*n2!=0))
894 idwt_detail_neo (input2, m2*n2, pWaveStruct.pHiPass,
895 pWaveStruct.length, output1, m7*n7);
896 else if ((m1*n1!=0) && (m2*n2==0))
897 idwt_approx_neo (input1, m1*n1, pWaveStruct.pLowPass,
898 pWaveStruct.length, output1, m7*n7);
899 else if ((m1*n1!=0) && (m2*n2!=0))
900 idwt_neo (input1, input2, m1*n1,
901 pWaveStruct.pLowPass, pWaveStruct.pHiPass,
902 pWaveStruct.length, output1, m7*n7);
903 else
904 {
905 errCode=UNKNOWN_INPUT_ERR;
906 validate_print (errCode);
907 return 0;
908 }
909 //AssignOutputVariable(pvApiCtx,1) = 7;
910 filter_clear();
911 break;
912 }
913 case 7:
914 {
915 //GetRhsVar(1, "d", &m1, &n1, &l1);
916 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 1, &m1, &n1 , &input1 );
917 if(readFlag==SWT_GWSUPPORT_ERROR)
918 {
919 return 0;
920 }
921 //GetRhsVar(2, "d", &m2, &n2, &l2);
922 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
923 if(readFlag==SWT_GWSUPPORT_ERROR)
924 {
925 return 0;
926 }
927 //GetRhsVar(3, "d", &m3, &n3, &l3);
928 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 3, &m3, &n3 , &input3 );
929 if(readFlag==SWT_GWSUPPORT_ERROR)
930 {
931 return 0;
932 }
933 //GetRhsVar(4, "d", &m4, &n4, &l4);
934 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 4, &m4, &n4 , &input4 );
935 if(readFlag==SWT_GWSUPPORT_ERROR)
936 {
937 return 0;
938 }
939 //GetRhsVar(5, "c", &m5, &n5, &l5);
940 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 5 , &input_string5 );
941 m5=1;n5=1;
942 if(readFlag==SWT_GWSUPPORT_ERROR)
943 {
944 return 0;
945 }
946 //GetRhsVar(6, "c", &m6, &n6, &l6);
947 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 6 , &input_string6 );
948 m6=1;n6=1;
949 if(readFlag==SWT_GWSUPPORT_ERROR)
950 {
951 return 0;
952 }
953 idwt_content_validate (pvApiCtx, &errCode,flow, NULL, NULL, NULL,NULL, input_string5, input_string6, NULL);
954 if (errCode != SUCCESS)
955 {
956 validate_print (errCode);
957 return 0;
958 }
959 wave_len_validate ( (m1*n1>0)?(m1*n1):(m2*n2),
960 (m3*n3), &stride, &val);
961 if (!val)
962 {
963 sciprint("Input signal is not valid for selected decompostion level and wavelets!\n");
964 return 0;
965 }
966 extend_method_parse (input_string6, &extMethod);
967 m7 = 1;
968 if (m1*n1 != 0)// && (getdwtMode()!=PER))
969 n7 = m1*n1*2 - m3*n3 + 2;
970 if ((m1*n1 != 0) && (extMethod==PER))
971 n7 = m1*n1*2;
972 if (m1*n1 == 0)// && (getdwtMode()!=PER))
973 n7 = m2*n2*2 - m3*n3 + 2;
974 if ((m1*n1 == 0) && (extMethod==PER))
975 n7 = m2*n2*2;
976 //CreateVar(7, "d", &m7, &n7, &l7);
977 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m7 , n7 , &output1 );
978 if(readFlag==SWT_GWSUPPORT_ERROR)
979 {
980 return 0;
981 }
982 if ((m1*n1==0) && (m2*n2!=0))
983 idwt_detail_neo (input2, m2*n2, input4,
984 n4*m4, output1, m7*n7);
985 else if ((m1*n1!=0) && (m2*n2==0))
986 idwt_approx_neo (input1, m1*n1, input3,
987 n3*m3, output1, m7*n7);
988 else if ((m1*n1!=0) && (m2*n2!=0))
989 idwt_neo (input1, input2, m1*n1,
990 input3, input4,
991 m3*n3, output1, m7*n7);
992 else
993 {
994 errCode=UNKNOWN_INPUT_ERR;
995 validate_print (errCode);
996 return 0;
997 }
998 //AssignOutputVariable(pvApiCtx,1) = 7;
999 break;
1000 }
1001 case 8:
1002 {
1003 //GetRhsVar(1, "d", &m1, &n1, &l1);
1004 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 1, &m1, &n1 , &input1 );
1005 if(readFlag==SWT_GWSUPPORT_ERROR)
1006 {
1007 return 0;
1008 }
1009 //GetRhsVar(2, "d", &m2, &n2, &l2);
1010 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
1011 if(readFlag==SWT_GWSUPPORT_ERROR)
1012 {
1013 return 0;
1014 }
1015 //GetRhsVar(3, "d", &m3, &n3, &l3);
1016 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 3, &m3, &n3 , &input3 );
1017 if(readFlag==SWT_GWSUPPORT_ERROR)
1018 {
1019 return 0;
1020 }
1021 //GetRhsVar(4, "d", &m4, &n4, &l4);
1022 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 4, &m4, &n4 , &input4 );
1023 if(readFlag==SWT_GWSUPPORT_ERROR)
1024 {
1025 return 0;
1026 }
1027 //GetRhsVar(5, "i", &m5, &n5, &l5);
1028 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 5, &m5, &n5 , &int_input5 );
1029 if(readFlag==SWT_GWSUPPORT_ERROR)
1030 {
1031 return 0;
1032 }
1033 //GetRhsVar(6, "c", &m6, &n6, &l6);
1034 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 6 , &input_string6 );
1035 m6=1;n6=1;
1036 if(readFlag==SWT_GWSUPPORT_ERROR)
1037 {
1038 return 0;
1039 }
1040 //GetRhsVar(7, "c", &m7, &n7, &l7);
1041 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 7 , &input_string7 );
1042 m7=1;n7=1;
1043 if(readFlag==SWT_GWSUPPORT_ERROR)
1044 {
1045 return 0;
1046 }
1047 idwt_content_validate (pvApiCtx, &errCode,flow, NULL, NULL, int_input5, NULL, NULL, input_string6, input_string7);
1048 if (errCode != SUCCESS)
1049 {
1050 validate_print (errCode);
1051 return 0;
1052 }
1053 wave_len_validate ( (m1*n1>0)?(m1*n1):(m2*n2),
1054 (m3*n3), &stride, &val);
1055 if (!val)
1056 {
1057 sciprint("Input signal is not valid for selected decompostion level and wavelets!\n");
1058 return 0;
1059 }
1060 extend_method_parse (input_string7, &extMethod);
1061 m8 = 1;
1062 n8 = int_input5[0];
1063 /*if (n8 > (((m1*n1>0)?(m1*n1):(m2*n2))*2 +
1064 m3*n3 - 1))
1065 {
1066 sciprint("Length Parameter is not valid for input vector!\n");
1067 return 0;
1068 }*/
1069 if (n8 > (((m1*n1>0)?(m1*n1):(m2*n2))*2 +
1070 m3*n3))
1071 {
1072 sciprint("Length Parameter is not valid for input vector!\n");
1073 return 0;
1074 }
1075 //CreateVar(8, "d", &m8, &n8, &l8);
1076 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m8 , n8 , &output1 );
1077 if(readFlag==SWT_GWSUPPORT_ERROR)
1078 {
1079 return 0;
1080 }
1081 if ((m1*n1==0) && (m2*n2!=0))
1082 idwt_detail_neo (input2, m2*n2, input4,
1083 n4*m4, output1, m8*n8);
1084 else if ((m1*n1!=0) && (m2*n2==0))
1085 idwt_approx_neo (input1, m1*n1, input3,
1086 n3*m3, output1, m8*n8);
1087 else if ((m1*n1!=0) && (m2*n2!=0))
1088 idwt_neo (input1, input2, m1*n1,
1089 input3, input4,
1090 m3*n3, output1, m8*n8);//, extMethod);
1091 else
1092 {
1093 errCode=UNKNOWN_INPUT_ERR;
1094 validate_print (errCode);
1095 return 0;
1096 }
1097 //AssignOutputVariable(pvApiCtx,1) = 8;
1098 break;
1099 }
1100 default:
1101 break;
1102 }
1103
1104 return 0;
1105 }
1106
1107
1108
1109 int
int_wavedec(char * fname,void * pvApiCtx)1110 int_wavedec
1111 #ifdef _SCILAB6_
1112 (char *fname, void* pvApiCtx)
1113 #else
1114 (char *fname)
1115 #endif
1116 {
1117 static int m1, n1, m2, n2, m3, n3;
1118 static int m4, n4, m5, n5, m6, n6;
1119 static int minlhs=2, maxlhs=2, minrhs=3, maxrhs=4;
1120 int errCode, flow, stride, val, ii, family, member;
1121 int count, calLen, temLen;
1122 Func ana_fun;
1123 swt_wavelet pWaveStruct;
1124
1125 int readFlag;
1126 double *input1 = NULL;
1127 int *input2 = NULL;
1128 double *input3 = NULL;
1129 double *input4 = NULL;
1130 char * input_string1 = NULL;
1131 double *output1;
1132 int *output2;
1133
1134 CheckOutputArgument(pvApiCtx,minlhs,maxlhs);
1135 CheckInputArgument(pvApiCtx,minrhs,maxrhs);
1136
1137 wavedec_form_validate (pvApiCtx, &errCode,&flow,Rhs);
1138 if (errCode != SUCCESS)
1139 {
1140 //sciprint("flow error!\n");
1141 validate_print (errCode);
1142 return 0;
1143 }
1144
1145
1146
1147
1148 switch (flow) {
1149 case 1:
1150 {
1151 //GetRhsVar(1, "d", &m1, &n1, &l1);
1152
1153 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
1154 if(readFlag==SWT_GWSUPPORT_ERROR)
1155 {
1156 return 0;
1157 }
1158 // GetRhsVar(2, "i", &m2, &n2, &l2);
1159 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &input2);
1160 if(readFlag==SWT_GWSUPPORT_ERROR)
1161 {
1162 return 0;
1163 }
1164 //GetRhsVar(3, "c", &m3, &n3, &l3);
1165 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 3 , &input_string1 );
1166 if(readFlag==SWT_GWSUPPORT_ERROR)
1167 {
1168 return 0;
1169 }
1170 wavedec_content_validate (pvApiCtx, &errCode,flow,input2,input_string1);
1171
1172
1173 if (errCode != SUCCESS)
1174 {
1175 validate_print (errCode);
1176 return 0;
1177 }
1178 wavelet_parser(input_string1,&family,&member);
1179 wavelet_fun_parser (input_string1, &ii);
1180 ana_fun = wi[ii].analysis;
1181 (*ana_fun)(member, &pWaveStruct);
1182 wave_len_validate ( m1*n1, pWaveStruct.length, &stride, &val);
1183 if ((!val) || (stride<input2[0]))
1184 {
1185 sciprint("Input signal is not valid for selected decompostion level and wavelets!\n");
1186 return 0;
1187 }
1188 m4 = 1;
1189 m5 = 1;
1190 n4 = 0;
1191 calLen = n1 * m1;
1192 for (count = 0; count < input2[0]; count++)
1193 {
1194 calLen += pWaveStruct.length - 1;
1195 temLen = calLen/2;
1196 n4 += temLen;
1197 calLen = temLen;
1198 }
1199 n4 += temLen;
1200 if (getdwtMode()==PER)
1201 {
1202 n4 = 0;
1203 calLen = n1 * m1;
1204 for (count = 0; count < input2[0]; count++)
1205 {
1206 //calLen += m3*n3 - 1;
1207 calLen = (int)ceil(((double)(calLen))/2.0);
1208 temLen = calLen;
1209 n4 += temLen;
1210 //calLen = temLen;
1211 }
1212 n4 += temLen;
1213 }
1214 n5 = input2[0] + 2;
1215 //CreateVar(4, "d", &m4, &n4, &l4);
1216 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
1217 if(readFlag==SWT_GWSUPPORT_ERROR)
1218 {
1219 return 0;
1220 }
1221 //CreateVar(5, "i", &m5, &n5, &l5);
1222 readFlag = swt_gwsupport_AllocMatrixOfDoublesAsInteger (pvApiCtx, fname, 2, m5 , n5 , &output2 );
1223 if(readFlag==SWT_GWSUPPORT_ERROR)
1224 {
1225 return 0;
1226 }
1227 wave_dec_len_cal (pWaveStruct.length, m1*n1,
1228 (int)input2[0], output2);
1229 wavedec (input1, m1*n1, output1, m4*n4,
1230 pWaveStruct.pLowPass, pWaveStruct.pHiPass,
1231 pWaveStruct.length, output2, n5,
1232 input2[0], getdwtMode());
1233 //AssignOutputVariable(pvApiCtx,1) = 4;
1234 //AssignOutputVariable(pvApiCtx,2) = 5;
1235 //AssignOutputVariable(pvApiCtx,1) = nbInputArgument(pvApiCtx) + 1;
1236 //AssignOutputVariable(pvApiCtx,2) = nbInputArgument(pvApiCtx) + 2;
1237 filter_clear();
1238 break;
1239 }
1240 case 2:
1241 {
1242 //GetRhsVar(1, "d", &m1, &n1, &l1);
1243 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
1244 if(readFlag==SWT_GWSUPPORT_ERROR)
1245 {
1246 return 0;
1247 }
1248 //GetRhsVar(2, "i", &m2, &n2, &l2);
1249 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &input2);
1250 if(readFlag==SWT_GWSUPPORT_ERROR)
1251 {
1252 return 0;
1253 }
1254 //GetRhsVar(3, "d", &m3, &n3, &l3);
1255 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 3, &m3, &n3, &input3);
1256 if(readFlag==SWT_GWSUPPORT_ERROR)
1257 {
1258 return 0;
1259 }
1260 //GetRhsVar(4, "d", &m4, &n4, &l4);
1261 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 4, &m4, &n4, &input4);
1262 if(readFlag==SWT_GWSUPPORT_ERROR)
1263 {
1264 return 0;
1265 }
1266 //sciprint("after get data!\n");
1267 wavedec_content_validate (pvApiCtx, &errCode,flow,input2,input_string1);
1268
1269 if (errCode != SUCCESS)
1270 {
1271 //sciprint("enter here\n");
1272 validate_print (errCode);
1273 return 0;
1274 }
1275 wave_len_validate ( m1*n1, m3*n3, &stride, &val);
1276 if ((!val) || (stride<input2[0]))
1277 {
1278 //sciprint("enter here!\n");
1279 sciprint("Input signal is not valid for selected decompostion level and wavelets!\n");
1280 return 0;
1281 }
1282 m5 = 1;
1283 m6 = 1;
1284 n5 = 0;
1285 calLen = n1 * m1;
1286 for (count = 0; count < input2[0]; count++)
1287 {
1288 calLen += m3*n3 - 1;
1289 temLen = calLen/2;
1290 n5 += temLen;
1291 calLen = temLen;
1292 }
1293 n5 += temLen;
1294 if (getdwtMode()==PER)
1295 {
1296 n5 = 0;
1297 calLen = n1 * m1;
1298 for (count = 0; count < input2[0]; count++)
1299 {
1300 //calLen += m3*n3 - 1;
1301 calLen = (int)ceil(((double)(calLen))/2.0);
1302 temLen = calLen;
1303 n5 += temLen;
1304 //calLen = temLen;
1305 }
1306 n5 += temLen;
1307 }
1308 n6 = input2[0] + 2;
1309 //CreateVar(5, "d", &m5, &n5, &l5);
1310 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m5 , n5 , &output1 );
1311 if(readFlag==SWT_GWSUPPORT_ERROR)
1312 {
1313 return 0;
1314 }
1315 //CreateVar(6, "i", &m6, &n6, &l6);
1316 readFlag = swt_gwsupport_AllocMatrixOfDoublesAsInteger (pvApiCtx, fname, 2, m6 , n6 , &output2 );
1317 if(readFlag==SWT_GWSUPPORT_ERROR)
1318 {
1319 return 0;
1320 }
1321 wave_dec_len_cal (m3*n3, m1*n1,
1322 input2[0], output2);
1323 wavedec (input1, m1*n1, output1, m5*n5, input3, input4,
1324 m3*n3, output2, n6, input2[0], getdwtMode());
1325 //AssignOutputVariable(pvApiCtx,1) = 5;
1326 //AssignOutputVariable(pvApiCtx,2) = 6;
1327 //AssignOutputVariable(pvApiCtx,1) = nbInputArgument(pvApiCtx) + 1;
1328 //AssignOutputVariable(pvApiCtx,2) = nbInputArgument(pvApiCtx) + 2;
1329 break;
1330 }
1331 default:
1332 break;
1333 }
1334
1335 return 0;
1336 }
1337
1338 int
int_waverec(char * fname,void * pvApiCtx)1339 int_waverec
1340 #ifdef _SCILAB6_
1341 (char *fname, void* pvApiCtx)
1342 #else
1343 (char *fname)
1344 #endif
1345 {
1346 static int m1, n1, m2, n2, m3, n3;
1347 static int m4, n4, m5, n5;
1348 static int minrhs=3, maxrhs=4, minlhs=1, maxlhs=1;
1349 int errCode, flow, len, count, val, family, member, ii;
1350 Func syn_fun;
1351 swt_wavelet pWaveStruct;
1352 int readFlag;
1353 double *input1;
1354 int *int_input2;
1355 double *input3;
1356 double *input4;
1357 char * input_string1 = NULL;
1358 double *output1;
1359
1360 CheckOutputArgument(pvApiCtx,minlhs,maxlhs);
1361 CheckInputArgument(pvApiCtx,minrhs,maxrhs);
1362
1363 waverec_form_validate (pvApiCtx, &errCode,&flow,Rhs);
1364 if (errCode != SUCCESS)
1365 {
1366 validate_print (errCode);
1367 return 0;
1368 }
1369
1370
1371 switch (flow) {
1372 case 1:
1373 {
1374 //GetRhsVar(1, "d", &m1, &n1, &l1);
1375 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 1, &m1 , &n1 , &input1 );
1376 if(readFlag==SWT_GWSUPPORT_ERROR)
1377 {
1378 return 0;
1379 }
1380 //GetRhsVar(2, "i", &m2, &n2, &l2);
1381 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 2, &m2 , &n2 , &int_input2 );
1382 if(readFlag==SWT_GWSUPPORT_ERROR)
1383 {
1384 return 0;
1385 }
1386 //GetRhsVar(3, "c", &m3, &n3, &l3);
1387 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname,3 , &input_string1 );
1388 m3=1;n3=1;
1389 if(readFlag==SWT_GWSUPPORT_ERROR)
1390 {
1391 return 0;
1392 }
1393 waverec_content_validate (pvApiCtx, &errCode,flow,input_string1);
1394 if (errCode != SUCCESS)
1395 {
1396 validate_print (errCode);
1397 return 0;
1398 }
1399 len = 0;
1400 for (count = 0; count < (m2 * n2 - 1); count++)
1401 len += int_input2[count];
1402 if (len != m1 * n1)
1403 {
1404 sciprint ("Inputs are not coef and length array!\n");
1405 return 0;
1406 }
1407 val = 0;
1408 for (count = 0; count < (m2 * n2 - 1); count++)
1409 {
1410 if (int_input2[count] > int_input2[count + 1])
1411 {
1412 val = 1;
1413 break;
1414 }
1415 }
1416 if (val != 0)
1417 {
1418 sciprint ("Inputs are not coef and length array!\n");
1419 return 0;
1420 }
1421 wavelet_parser(input_string1,&family,&member);
1422 wavelet_fun_parser (input_string1, &ii);
1423 syn_fun = wi[ii].synthesis;
1424 (*syn_fun)(member, &pWaveStruct);
1425 if (int_input2[0] < pWaveStruct.length)
1426 {
1427 sciprint ("Input signal is not valid for selected decompostion level and wavelets!\n");
1428 return 0;
1429 }
1430 //for(count=0;count<pWaveStruct.length;count++)
1431 // printf("%f\n",pWaveStruct.pLowPass[count]);
1432 m4 = 1;
1433 n4 = int_input2[m2*n2-1];
1434 //CreateVar(4, "d", &m4, &n4, &l4);
1435 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
1436 if(readFlag==SWT_GWSUPPORT_ERROR)
1437 {
1438 return 0;
1439 }
1440 waverec (input1, m1*n1, output1, m4*n4,
1441 pWaveStruct.pLowPass, pWaveStruct.pHiPass,
1442 pWaveStruct.length, int_input2, m2*n2,
1443 m2*n2-2, getdwtMode());
1444 //AssignOutputVariable(pvApiCtx,1) = 4;
1445 filter_clear();
1446 break;
1447 }
1448 case 2:
1449 {
1450 //GetRhsVar(1, "d", &m1, &n1, &l1);
1451 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 1, &m1 , &n1 , &input1 );
1452 if(readFlag==SWT_GWSUPPORT_ERROR)
1453 {
1454 return 0;
1455 }
1456 //GetRhsVar(2, "i", &m2, &n2, &l2);
1457 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 2, &m2 , &n2 , &int_input2 );
1458 if(readFlag==SWT_GWSUPPORT_ERROR)
1459 {
1460 return 0;
1461 }
1462 //GetRhsVar(3, "d", &m3, &n3, &l3);
1463 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname,3 , &m3 , &n3 , &input3 );
1464 if(readFlag==SWT_GWSUPPORT_ERROR)
1465 {
1466 return 0;
1467 }
1468 //GetRhsVar(4, "d", &m4, &n4, &l4);
1469 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 4, &m4 , &n4 , &input4 );
1470 if(readFlag==SWT_GWSUPPORT_ERROR)
1471 {
1472 return 0;
1473 }
1474 waverec_content_validate (pvApiCtx, &errCode,flow,input_string1);
1475 if (errCode != SUCCESS)
1476 {
1477 validate_print (errCode);
1478 return 0;
1479 }
1480 len = 0;
1481 for (count = 0; count < (m2 * n2 - 1); count++)
1482 len += int_input2[count];
1483 if (len != m1 * n1)
1484 {
1485 sciprint ("Inputs are not coef and length array!\n");
1486 return 0;
1487 }
1488 val = 0;
1489 for (count = 0; count < (m2 * n2 - 1); count++)
1490 {
1491 if (int_input2[count] > int_input2[count + 1])
1492 {
1493 val = 1;
1494 break;
1495 }
1496 }
1497 if (val != 0)
1498 {
1499 sciprint ("Inputs are not coef and length array!\n");
1500 return 0;
1501 }
1502 if (int_input2[0] < m3*n3)
1503 {
1504 sciprint ("Input signal is not valid for selected decompostion level and wavelets!\n");
1505 return 0;
1506 }
1507 m5 = 1;
1508 n5 = int_input2[m2*n2-1];
1509 //CreateVar(5, "d", &m5, &n5, &l5);
1510 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m5 , n5 , &output1 );
1511 if(readFlag==SWT_GWSUPPORT_ERROR)
1512 {
1513 return 0;
1514 }
1515 waverec (input1, m1*n1, output1, m5*n5,
1516 input3, input4, m3*n3, int_input2, m2*n2,
1517 m2*n2-2, getdwtMode());
1518 //AssignOutputVariable(pvApiCtx,1) = 5;
1519 break;
1520 }
1521 default:
1522 break;
1523 }
1524 return 0;
1525 }
1526
1527 int
int_wrcoef(char * fname,void * pvApiCtx)1528 int_wrcoef
1529 #ifdef _SCILAB6_
1530 (char *fname, void* pvApiCtx)
1531 #else
1532 (char *fname)
1533 #endif
1534 {
1535 static int m1, n1, m2, n2, m3, n3;
1536 static int m4, n4, m5, n5, m6, n6;
1537 static int m7, n7;
1538 static int minrhs=4, maxrhs=6, minlhs=1, maxlhs=1;
1539 int errCode, flow, len, count, val, family, member, ii;
1540 Func syn_fun;
1541 swt_wavelet pWaveStruct;
1542 int readFlag;
1543 double *input2 = NULL;
1544 int *int_input2 = NULL;
1545 int *int_input3 = NULL;
1546 double *input4 = NULL;
1547 double *input5 = NULL;
1548 int *int_input5 = NULL;
1549 int *int_input6 = NULL;
1550 char * input_string1 = NULL;
1551 char * input_string4 = NULL;
1552 double *output1;
1553 double *output2;
1554
1555
1556 CheckInputArgument(pvApiCtx,minrhs,maxrhs);
1557 CheckOutputArgument(pvApiCtx,minlhs,maxlhs);
1558
1559 wrcoef_form_validate (pvApiCtx, &errCode, &flow, Rhs);
1560 if (errCode != SUCCESS)
1561 {
1562 validate_print (errCode);
1563 return 0;
1564 }
1565
1566 switch (flow) {
1567 case 1:
1568 {
1569 //GetRhsVar(1, "c", &m1, &n1, &l1);
1570 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
1571 m1=1;n1=1;
1572 if(readFlag==SWT_GWSUPPORT_ERROR)
1573 {
1574 return 0;
1575 }
1576 //GetRhsVar(2, "d", &m2, &n2, &l2);
1577 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
1578 if(readFlag==SWT_GWSUPPORT_ERROR)
1579 {
1580 return 0;
1581 }
1582 //GetRhsVar(3, "i", &m3, &n3, &l3);
1583 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 3, &m3 , &n3 , &int_input3 );
1584 if(readFlag==SWT_GWSUPPORT_ERROR)
1585 {
1586 return 0;
1587 }
1588 //GetRhsVar(4, "c", &m4, &n4, &l4);
1589 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 4 , &input_string4 );
1590 m4=1;n4=1;
1591 if(readFlag==SWT_GWSUPPORT_ERROR)
1592 {
1593 return 0;
1594 }
1595 //printf("enter flow 1\n");
1596 len = 0;
1597 for (count = 0; count < (m3 * n3 - 1); count++)
1598 len += int_input3[count];
1599 if (len != m2 * n2)
1600 {
1601 sciprint ("Inputs are not coef and length array!\n");
1602 return 0;
1603 }
1604 val = 0;
1605 for (count = 0; count < (m3 * n3 - 1); count++)
1606 {
1607 if (int_input3[count] > int_input3[count + 1])
1608 {
1609 val = 1;
1610 break;
1611 }
1612 }
1613 if (val != 0)
1614 {
1615 sciprint ("Inputs are not coef and length array!\n");
1616 return 0;
1617 }
1618 //printf("before content check\n");
1619 wrcoef_content_validate (pvApiCtx, &errCode, flow, input_string1, input_string4, NULL, NULL);
1620 if (errCode != SUCCESS)
1621 {
1622 validate_print (errCode);
1623 return 0;
1624 }
1625 //printf("before wavelet parser\n");
1626 wavelet_parser(input_string4,&family,&member);
1627 wavelet_fun_parser (input_string4, &ii);
1628 syn_fun = wi[ii].synthesis;
1629 (*syn_fun)(member, &pWaveStruct);
1630 //printf("after parser\n");
1631 if (int_input3[0] < pWaveStruct.length)
1632 {
1633 sciprint ("Input signal is not valid for selected decompostion level and wavelets!\n");
1634 return 0;
1635 }
1636 m5 = 1;
1637 n5 = int_input3[m3*n3-1];
1638 //CreateVar(5, "d", &m5, &n5, &l5);
1639 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m5 , n5 , &output1 );
1640 if(readFlag==SWT_GWSUPPORT_ERROR)
1641 {
1642 return 0;
1643 }
1644 //printf("before wrcoef\n");
1645 wrcoef (input2, m2*n2, pWaveStruct.pLowPass,
1646 pWaveStruct.pHiPass, pWaveStruct.length,
1647 int_input3, m3*n3, output1, m5*n5, input_string1,
1648 m3*n3-2, m3*n3-2, getdwtMode());
1649 //AssignOutputVariable(pvApiCtx,1) = 5;
1650 filter_clear();
1651 break;
1652 }
1653 case 2:
1654 {
1655 //GetRhsVar(1, "c", &m1, &n1, &l1);
1656 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
1657 m1=1;n1=1;
1658 if(readFlag==SWT_GWSUPPORT_ERROR)
1659 {
1660 return 0;
1661 }
1662 //GetRhsVar(2, "d", &m2, &n2, &l2);
1663 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
1664 if(readFlag==SWT_GWSUPPORT_ERROR)
1665 {
1666 return 0;
1667 }
1668 //GetRhsVar(3, "i", &m3, &n3, &l3);
1669 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 3, &m3 , &n3 , &int_input3 );
1670 if(readFlag==SWT_GWSUPPORT_ERROR)
1671 {
1672 return 0;
1673 }
1674 //GetRhsVar(4, "c", &m4, &n4, &l4);
1675 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 4 , &input_string4 );
1676 m4=1;n4=1;
1677 if(readFlag==SWT_GWSUPPORT_ERROR)
1678 {
1679 return 0;
1680 }
1681 //GetRhsVar(5, "i", &m5, &n5, &l5);
1682 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 5, &m5 , &n5 , &int_input5 );
1683 if(readFlag==SWT_GWSUPPORT_ERROR)
1684 {
1685 return 0;
1686 }
1687 len = 0;
1688 for (count = 0; count < (m3 * n3 - 1); count++)
1689 len += int_input3[count];
1690 if (len != m2 * n2)
1691 {
1692 sciprint ("Inputs are not coef and length array!\n");
1693 return 0;
1694 }
1695 val = 0;
1696 for (count = 0; count < (m3 * n3 - 1); count++)
1697 {
1698 if (int_input3[count] > int_input3[count + 1])
1699 {
1700 val = 1;
1701 break;
1702 }
1703 }
1704 if (val != 0)
1705 {
1706 sciprint ("Inputs are not coef and length array!\n");
1707 return 0;
1708 }
1709 wrcoef_content_validate (pvApiCtx, &errCode, flow, input_string1, input_string4, int_input3, NULL);
1710 if (errCode != SUCCESS)
1711 {
1712 validate_print (errCode);
1713 return 0;
1714 }
1715 wavelet_parser(input_string4,&family,&member);
1716 wavelet_fun_parser (input_string4, &ii);
1717 syn_fun = wi[ii].synthesis;
1718 (*syn_fun)(member, &pWaveStruct);
1719 if (int_input3[0] < pWaveStruct.length)
1720 {
1721 sciprint ("Input signal is not valid for selected decompostion level and wavelets!\n");
1722 return 0;
1723 }
1724 if (int_input5[0] > (m3*n3-2))
1725 {
1726 sciprint("Input signal is not valid for selected decompostion level and wavelets!\n");
1727 return 0;
1728 }
1729 m6 = 1;
1730 n6 = int_input3[m3*n3-1];
1731 //CreateVar(6, "d", &m6, &n6, &l6);
1732 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m6 , n6 , &output1 );
1733 if(readFlag==SWT_GWSUPPORT_ERROR)
1734 {
1735 return 0;
1736 }
1737 wrcoef (input2, m2*n2, pWaveStruct.pLowPass,
1738 pWaveStruct.pHiPass, pWaveStruct.length,
1739 int_input3, m3*n3, output1, m6*n6, input_string1,
1740 m3*n3-2, int_input5[0], getdwtMode());
1741 // AssignOutputVariable(pvApiCtx,1) = 6;
1742 filter_clear();
1743 break;
1744 }
1745 case 3:
1746 {
1747
1748 //GetRhsVar(1, "c", &m1, &n1, &l1);
1749 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
1750 m1=1;n1=1;
1751 if(readFlag==SWT_GWSUPPORT_ERROR)
1752 {
1753 return 0;
1754 }
1755 //GetRhsVar(2, "d", &m2, &n2, &l2);
1756 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
1757 if(readFlag==SWT_GWSUPPORT_ERROR)
1758 {
1759 return 0;
1760 }
1761 //GetRhsVar(3, "i", &m3, &n3, &l3);
1762 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 3, &m3 , &n3 , &int_input3 );
1763 if(readFlag==SWT_GWSUPPORT_ERROR)
1764 {
1765 return 0;
1766 }
1767 // GetRhsVar(4, "d", &m4, &n4, &l4);
1768 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 4, &m4 , &n4 , &input4 );
1769 if(readFlag==SWT_GWSUPPORT_ERROR)
1770 {
1771 return 0;
1772 }
1773 // GetRhsVar(5, "d", &m5, &n5, &l5);
1774 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 5, &m5 , &n5 , &input5 );
1775 if(readFlag==SWT_GWSUPPORT_ERROR)
1776 {
1777 return 0;
1778 }
1779 len = 0;
1780 for (count = 0; count < (m3 * n3 - 1); count++)
1781 len += int_input3[count];
1782 if (len != m2 * n2)
1783 {
1784 sciprint ("Inputs are not coef and length array!\n");
1785 return 0;
1786 }
1787 val = 0;
1788 for (count = 0; count < (m3 * n3 - 1); count++)
1789 {
1790 if (int_input3[count] > int_input3[count + 1])
1791 {
1792 val = 1;
1793 break;
1794 }
1795 }
1796 if (val != 0)
1797 {
1798 sciprint ("Inputs are not coef and length array!\n");
1799 return 0;
1800 }
1801 wrcoef_content_validate (pvApiCtx, &errCode, flow, input_string1, NULL, NULL, NULL);
1802 if (errCode != SUCCESS)
1803 {
1804 validate_print (errCode);
1805 return 0;
1806 }
1807 if (int_input3[0] < m4*n4)
1808 {
1809 sciprint ("Input signal is not valid for selected decompostion level and wavelets!\n");
1810 return 0;
1811 }
1812 m6 = 1;
1813 n6 = int_input3[m3*n3-1];
1814 // CreateVar(6, "d", &m6, &n6, &l6);
1815 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m6 , n6 , &output1 );
1816 if(readFlag==SWT_GWSUPPORT_ERROR)
1817 {
1818 return 0;
1819 }
1820 wrcoef (input2, m2*n2, input4, input5, m4*n4,
1821 int_input3, m3*n3, output1, m6*n6, input_string1,
1822 m3*n3-2, m3*n3-2, getdwtMode());
1823 //AssignOutputVariable(pvApiCtx,1) = 6;
1824 break;
1825 }
1826 case 4:
1827 {
1828 //GetRhsVar(1, "c", &m1, &n1, &l1);
1829 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
1830 m1=1;n1=1;
1831 if(readFlag==SWT_GWSUPPORT_ERROR)
1832 {
1833 return 0;
1834 }
1835 //GetRhsVar(2, "d", &m2, &n2, &l2);
1836 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
1837 if(readFlag==SWT_GWSUPPORT_ERROR)
1838 {
1839 return 0;
1840 }
1841 //GetRhsVar(3, "i", &m3, &n3, &l3);
1842 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 3, &m3 , &n3 , &int_input3 );
1843 if(readFlag==SWT_GWSUPPORT_ERROR)
1844 {
1845 return 0;
1846 }
1847 // GetRhsVar(4, "d", &m4, &n4, &l4);
1848 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 4, &m4 , &n4 , &input4 );
1849 if(readFlag==SWT_GWSUPPORT_ERROR)
1850 {
1851 return 0;
1852 }
1853 // GetRhsVar(5, "d", &m5, &n5, &l5);
1854 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 5, &m5 , &n5 , &input5 );
1855 if(readFlag==SWT_GWSUPPORT_ERROR)
1856 {
1857 return 0;
1858 }
1859 //GetRhsVar(6, "i", &m6, &n6, &l6);
1860 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 6, &m6 , &n6 , &int_input6 );
1861 if(readFlag==SWT_GWSUPPORT_ERROR)
1862 {
1863 return 0;
1864 }
1865 len = 0;
1866 for (count = 0; count < (m3 * n3 - 1); count++)
1867 len += int_input3[count];
1868 if (len != m2 * n2)
1869 {
1870 sciprint ("Inputs are not coef and length array!\n");
1871 return 0;
1872 }
1873 val = 0;
1874 for (count = 0; count < (m3 * n3 - 1); count++)
1875 {
1876 if (int_input3[count] > int_input3[count + 1])
1877 {
1878 val = 1;
1879 break;
1880 }
1881 }
1882 if (val != 0)
1883 {
1884 sciprint ("Inputs are not coef and length array!\n");
1885 return 0;
1886 }
1887 wrcoef_content_validate (pvApiCtx, &errCode, flow, input_string1, NULL, NULL, int_input6);
1888 if (errCode != SUCCESS)
1889 {
1890 validate_print (errCode);
1891 return 0;
1892 }
1893 if (int_input6[0] > (m3*n3-2))
1894 {
1895 sciprint("Input signal is not valid for selected decompostion level and wavelets!\n");
1896 return 0;
1897 }
1898 if (int_input3[0] < m4*n4)
1899 {
1900 sciprint ("Input signal is not valid for selected decompostion level and wavelets!\n");
1901 return 0;
1902 }
1903 m7 = 1;
1904 n7 = int_input3[m3*n3-1];
1905 //CreateVar(7, "d", &m7, &n7, &l7);
1906 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m7 , n7 , &output1 );
1907 if(readFlag==SWT_GWSUPPORT_ERROR)
1908 {
1909 return 0;
1910 }
1911 wrcoef (input2, m2*n2, input4, input5, m4*n4,
1912 int_input3, m3*n3, output1, m7*n7, input_string1,
1913 m3*n3-2, int_input6[0], getdwtMode());
1914 //AssignOutputVariable(pvApiCtx,1) = 7;
1915 break;
1916 }
1917 default:
1918 break;
1919 }
1920
1921 return 0;
1922 }
1923
1924 int
int_appcoef(char * fname,void * pvApiCtx)1925 int_appcoef
1926 #ifdef _SCILAB6_
1927 (char *fname, void* pvApiCtx)
1928 #else
1929 (char *fname)
1930 #endif
1931 {
1932 static int m1, n1, m2, n2, m3, n3;
1933 static int m4, n4, m5, n5, m6, n6;
1934 static int minrhs=3, maxrhs=5, minlhs=1, maxlhs=1;
1935 int errCode, flow, len, count, val, family, member, ii;
1936 Func syn_fun;
1937 swt_wavelet pWaveStruct;
1938 int readFlag;
1939 double *input1 = NULL;
1940 int *int_input2 = NULL;
1941 double *input3 = NULL;
1942 double *input4 = NULL;
1943 int *int_input4 = NULL;
1944 int *int_input5 = NULL;
1945 int *int_input6 = NULL;
1946 char * input_string3 = NULL;
1947 char * input_string4 = NULL;
1948 double *output1;
1949
1950 CheckInputArgument(pvApiCtx,minrhs,maxrhs);
1951 CheckOutputArgument(pvApiCtx,minlhs,maxlhs);
1952
1953 appcoef_form_validate (pvApiCtx, &errCode, &flow, Rhs);
1954 if (errCode != SUCCESS)
1955 {
1956 validate_print (errCode);
1957 return 0;
1958 }
1959
1960
1961 switch (flow){
1962 case 1:
1963 {
1964 //GetRhsVar(1, "d", &m1, &n1, &l1);
1965 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 1, &m1, &n1 , &input1 );
1966 if(readFlag==SWT_GWSUPPORT_ERROR)
1967 {
1968 return 0;
1969 }
1970 //GetRhsVar(2, "i", &m2, &n2, &l2);
1971 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 2, &m2, &n2 , &int_input2 );
1972 if(readFlag==SWT_GWSUPPORT_ERROR)
1973 {
1974 return 0;
1975 }
1976 //GetRhsVar(3, "c", &m3, &n3, &l3);
1977 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 3 , &input_string3 );
1978 m3=1;n3=1;
1979 if(readFlag==SWT_GWSUPPORT_ERROR)
1980 {
1981 return 0;
1982 }
1983 len = 0;
1984 for (count = 0; count < (m2 * n2 - 1); count++)
1985 len += int_input2[count];
1986 if (len != m1 * n1)
1987 {
1988 sciprint ("Inputs are not coef and length array!\n");
1989 return 0;
1990 }
1991 val = 0;
1992 for (count = 0; count < (m2 * n2 - 1); count++)
1993 {
1994 if (int_input2[count] > int_input2[count + 1])
1995 {
1996 val = 1;
1997 break;
1998 }
1999 }
2000 if (val != 0)
2001 {
2002 sciprint ("Inputs are not coef and length array!\n");
2003 return 0;
2004 }
2005 appcoef_content_validate (pvApiCtx, &errCode, flow, input_string3);
2006 if (errCode != SUCCESS)
2007 {
2008 validate_print (errCode);
2009 return 0;
2010 }
2011 wavelet_parser(input_string3,&family,&member);
2012 wavelet_fun_parser (input_string3, &ii);
2013 syn_fun = wi[ii].synthesis;
2014 (*syn_fun)(member, &pWaveStruct);
2015 if (int_input2[0] < pWaveStruct.length)
2016 {
2017 sciprint ("Input signal is not valid for selected decompostion level and wavelets!\n");
2018 return 0;
2019 }
2020 m4 = 1;
2021 n4 = int_input2[0];
2022 //CreateVar(4, "d", &m4, &n4, &l4);
2023 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
2024 if(readFlag==SWT_GWSUPPORT_ERROR)
2025 {
2026 return 0;
2027 }
2028 appcoef (input1, m1*n1, output1, m4*n4,
2029 pWaveStruct.pLowPass, pWaveStruct.pHiPass,
2030 pWaveStruct.length, int_input2, m2*n2,
2031 m2*n2-2, m2*n2-2, getdwtMode());
2032 //AssignOutputVariable(pvApiCtx,1) = 4;
2033 filter_clear();
2034 break;
2035 }
2036 case 2:
2037 {
2038 //GetRhsVar(1, "d", &m1, &n1, &l1);
2039 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 1, &m1, &n1 , &input1 );
2040 if(readFlag==SWT_GWSUPPORT_ERROR)
2041 {
2042 return 0;
2043 }
2044 //GetRhsVar(2, "i", &m2, &n2, &l2);
2045 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 2, &m2, &n2 , &int_input2 );
2046 if(readFlag==SWT_GWSUPPORT_ERROR)
2047 {
2048 return 0;
2049 }
2050 //GetRhsVar(3, "c", &m3, &n3, &l3);
2051 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 3 , &input_string3 );
2052 m3=1;n3=1;
2053 if(readFlag==SWT_GWSUPPORT_ERROR)
2054 {
2055 return 0;
2056 }
2057 //GetRhsVar(4, "i", &m4, &n4, &l4);
2058 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 4, &m4, &n4 , &int_input4 );
2059 if(readFlag==SWT_GWSUPPORT_ERROR)
2060 {
2061 return 0;
2062 }
2063 len = 0;
2064 for (count = 0; count < (m2 * n2 - 1); count++)
2065 len += int_input2[count];
2066 if (len != m1 * n1)
2067 {
2068 sciprint ("Inputs are not coef and length array!\n");
2069 return 0;
2070 }
2071 val = 0;
2072 for (count = 0; count < (m2 * n2 - 1); count++)
2073 {
2074 if (int_input2[count] > int_input2[count + 1])
2075 {
2076 val = 1;
2077 break;
2078 }
2079 }
2080 if (val != 0)
2081 {
2082 sciprint ("Inputs are not coef and length array!\n");
2083 return 0;
2084 }
2085 appcoef_content_validate (pvApiCtx, &errCode, flow, input_string3);
2086 if (errCode != SUCCESS)
2087 {
2088 validate_print (errCode);
2089 return 0;
2090 }
2091 if ((int_input4[0]>(m2*n2-2)) || (int_input4[0]<0))
2092 {
2093 sciprint ("Level Parameter is not valid for input vector!\n");
2094 return 0;
2095 }
2096 wavelet_parser(input_string3,&family,&member);
2097 wavelet_fun_parser (input_string3, &ii);
2098 syn_fun = wi[ii].synthesis;
2099 (*syn_fun)(member, &pWaveStruct);
2100 if (int_input2[0] < pWaveStruct.length)
2101 {
2102 sciprint ("Input signal is not valid for selected decompostion level and wavelets!\n");
2103 return 0;
2104 }
2105 m5 = 1;
2106 n5 = int_input2[n2 * m2 - 2 - int_input4[0] + 1];
2107 //CreateVar(5, "d", &m5, &n5, &l5);
2108 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m5 , n5 , &output1 );
2109 if(readFlag==SWT_GWSUPPORT_ERROR)
2110 {
2111 return 0;
2112 }
2113 appcoef (input1, m1*n1, output1, m5*n5,
2114 pWaveStruct.pLowPass, pWaveStruct.pHiPass,
2115 pWaveStruct.length, int_input2, m2*n2,
2116 m2*n2-2, int_input4[0], getdwtMode());
2117 //AssignOutputVariable(pvApiCtx,1) = 5;
2118 filter_clear();
2119 break;
2120 }
2121 case 3:
2122 {
2123 //GetRhsVar(1, "d", &m1, &n1, &l1);
2124 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 1, &m1, &n1 , &input1 );
2125 if(readFlag==SWT_GWSUPPORT_ERROR)
2126 {
2127 return 0;
2128 }
2129 //GetRhsVar(2, "i", &m2, &n2, &l2);
2130 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 2, &m2, &n2 , &int_input2 );
2131 if(readFlag==SWT_GWSUPPORT_ERROR)
2132 {
2133 return 0;
2134 }
2135 //GetRhsVar(3, "d", &m3, &n3, &l3);
2136 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 3, &m3, &n3 , &input3 );
2137 if(readFlag==SWT_GWSUPPORT_ERROR)
2138 {
2139 return 0;
2140 }
2141 //GetRhsVar(4, "d", &m4, &n4, &l4);
2142 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 4, &m4, &n4 , &input4 );
2143 if(readFlag==SWT_GWSUPPORT_ERROR)
2144 {
2145 return 0;
2146 }
2147 len = 0;
2148 for (count = 0; count < (m2 * n2 - 1); count++)
2149 len += int_input2[count];
2150 if (len != m1 * n1)
2151 {
2152 sciprint ("Inputs are not coef and length array!\n");
2153 return 0;
2154 }
2155 val = 0;
2156 for (count = 0; count < (m2 * n2 - 1); count++)
2157 {
2158 if (int_input2[count] > int_input2[count + 1])
2159 {
2160 val = 1;
2161 break;
2162 }
2163 }
2164 if (val != 0)
2165 {
2166 sciprint ("Inputs are not coef and length array!\n");
2167 return 0;
2168 }
2169 appcoef_content_validate (pvApiCtx, &errCode, flow, NULL);
2170 if (errCode != SUCCESS)
2171 {
2172 validate_print (errCode);
2173 return 0;
2174 }
2175 if (int_input2[0] < m3*n3)
2176 {
2177 sciprint ("Input signal is not valid for selected decompostion level and wavelets!\n");
2178 return 0;
2179 }
2180 m5 = 1;
2181 n5 = int_input2[0];
2182 //CreateVar(5, "d", &m5, &n5, &l5);
2183 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m5 , n5 , &output1 );
2184 if(readFlag==SWT_GWSUPPORT_ERROR)
2185 {
2186 return 0;
2187 }
2188 appcoef (input1, m1*n1, output1, m5*n5, input3, input4,
2189 m3*n3, int_input2, m2*n2, m2*n2-2, m2*n2-2, getdwtMode());
2190 //AssignOutputVariable(pvApiCtx,1) = 5;
2191 break;
2192 }
2193 case 4:
2194 {
2195 //GetRhsVar(1, "d", &m1, &n1, &l1);
2196 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 1, &m1, &n1 , &input1 );
2197 if(readFlag==SWT_GWSUPPORT_ERROR)
2198 {
2199 return 0;
2200 }
2201 //GetRhsVar(2, "i", &m2, &n2, &l2);
2202 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 2, &m2, &n2 , &int_input2 );
2203 if(readFlag==SWT_GWSUPPORT_ERROR)
2204 {
2205 return 0;
2206 }
2207 //GetRhsVar(3, "d", &m3, &n3, &l3);
2208 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 3, &m3, &n3 , &input3 );
2209 if(readFlag==SWT_GWSUPPORT_ERROR)
2210 {
2211 return 0;
2212 }
2213 //GetRhsVar(4, "d", &m4, &n4, &l4);
2214 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 4, &m4, &n4 , &input4 );
2215 if(readFlag==SWT_GWSUPPORT_ERROR)
2216 {
2217 return 0;
2218 }
2219 //GetRhsVar(5, "i", &m5, &n5, &l5);
2220 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 5, &m5, &n5 , &int_input5 );
2221 if(readFlag==SWT_GWSUPPORT_ERROR)
2222 {
2223 return 0;
2224 }
2225 len = 0;
2226 for (count = 0; count < (m2 * n2 - 1); count++)
2227 len += int_input2[count];
2228 if (len != m1 * n1)
2229 {
2230 sciprint ("Inputs are not coef and length array!\n");
2231 return 0;
2232 }
2233 val = 0;
2234 for (count = 0; count < (m2 * n2 - 1); count++)
2235 {
2236 if (int_input2[count] > int_input2[count + 1])
2237 {
2238 val = 1;
2239 break;
2240 }
2241 }
2242 if (val != 0)
2243 {
2244 sciprint ("Inputs are not coef and length array!\n");
2245 return 0;
2246 }
2247 appcoef_content_validate (pvApiCtx, &errCode, flow, NULL);
2248 if (errCode != SUCCESS)
2249 {
2250 validate_print (errCode);
2251 return 0;
2252 }
2253 if ((int_input5[0]>(m2*n2-2)) || (int_input5[0]<0))
2254 {
2255 sciprint ("Level Parameter is not valid for input vector!\n");
2256 return 0;
2257 }
2258 if (int_input2[0] < m3*n3)
2259 {
2260 sciprint ("Input signal is not valid for selected decompostion level and wavelets!\n");
2261 return 0;
2262 }
2263 m6 = 1;
2264 n6 = int_input2[n2 * m2 - 2 - int_input5[0] + 1];
2265 //CreateVar(6, "d", &m6, &n6, &l6);
2266 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m6 , n6 , &output1 );
2267 if(readFlag==SWT_GWSUPPORT_ERROR)
2268 {
2269 return 0;
2270 }
2271 appcoef (input1, m1*n1, output1, m6*n6, input3, input4,
2272 m3*n3, int_input2, m2*n2, m2*n2-2, int_input5[0], getdwtMode());
2273 //AssignOutputVariable(pvApiCtx,1) = 6;
2274 break;
2275 }
2276 default:
2277 break;
2278 }
2279
2280 return 0;
2281 }
2282
2283 int
int_detcoef(char * fname,void * pvApiCtx)2284 int_detcoef
2285 #ifdef _SCILAB6_
2286 (char *fname, void* pvApiCtx)
2287 #else
2288 (char *fname)
2289 #endif
2290 {
2291 static int m1, n1, m2, n2, m3, n3, m4, n4;
2292 static int minrhs=2, maxrhs=3, minlhs=1, maxlhs=1;
2293 int errCode, flow, len, val, count;
2294 int readFlag;
2295 double *input1;
2296 int *input2;
2297 int *input3;
2298 double *output1;
2299
2300 CheckInputArgument(pvApiCtx,minrhs,maxrhs);
2301 CheckOutputArgument(pvApiCtx,minlhs,maxlhs);
2302
2303 detcoef_form_validate (pvApiCtx, &errCode, &flow, Rhs);
2304 if (errCode != SUCCESS)
2305 {
2306 validate_print (errCode);
2307 return 0;
2308 }
2309
2310 switch (flow) {
2311 case 1:
2312 {
2313 //GetRhsVar(1, "d", &m1, &n1, &l1);
2314 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 1, &m1, &n1 , &input1 );
2315 if(readFlag==SWT_GWSUPPORT_ERROR)
2316 {
2317 return 0;
2318 }
2319 //GetRhsVar(2, "i", &m2, &n2, &l2);
2320 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
2321 if(readFlag==SWT_GWSUPPORT_ERROR)
2322 {
2323 return 0;
2324 }
2325 len = 0;
2326 for (count = 0; count < (m2 * n2 - 1); count++)
2327 len += input2[count];
2328 if (len != m1 * n1)
2329 {
2330 sciprint ("Inputs are not coef and length array!\n");
2331 return 0;
2332 }
2333 val = 0;
2334 for (count = 0; count < (m2 * n2 - 1); count++)
2335 {
2336 if (input2[count] > input2[count + 1])
2337 {
2338 val = 1;
2339 break;
2340 }
2341 }
2342 if (val != 0)
2343 {
2344 sciprint ("Inputs are not coef and length array!\n");
2345 return 0;
2346 }
2347 m3 = 1;
2348 n3 = input2[1];
2349 //CreateVar(3, "d", &m3, &n3, &l3);
2350 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
2351 if(readFlag==SWT_GWSUPPORT_ERROR)
2352 {
2353 return 0;
2354 }
2355 detcoef(input1, m1*n1, input2, m2*n2, output1, m3*n3,
2356 m2*n2-2, m2*n2-2);
2357 //AssignOutputVariable(pvApiCtx,1) = 3;
2358 break;
2359 }
2360 case 2:
2361 {
2362 // //GetRhsVar(1, "d", &m1, &n1, &l1);
2363 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 1, &m1, &n1 , &input1 );
2364 if(readFlag==SWT_GWSUPPORT_ERROR)
2365 {
2366 return 0;
2367 }
2368 //sciprint ("First input m1 %d n1 %d \n",m1,n1);
2369 //GetRhsVar(2, "i", &m2, &n2, &l2);
2370 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
2371 if(readFlag==SWT_GWSUPPORT_ERROR)
2372 {
2373 return 0;
2374 }
2375 //sciprint ("second input m1 %d n1 %d \n",m2,n2);
2376 //GetRhsVar(3, "i", &m3, &n3, &l3);
2377 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 3, &m3, &n3 , &input3 );
2378 if(readFlag==SWT_GWSUPPORT_ERROR)
2379 {
2380 return 0;
2381 }
2382 //sciprint ("third input m1 %d n1 %d \n",m3,n3);
2383 len = 0;
2384 for (count = 0; count < (m2 * n2 - 1); count++)
2385 len += input2[count];
2386 if (len != m1 * n1)
2387 {
2388 sciprint ("Inputs are not coef and length array!\n");
2389 return 0;
2390 }
2391 val = 0;
2392 for (count = 0; count < (m2 * n2 - 1); count++)
2393 {
2394 if (input2[count] > input2[count + 1])
2395 {
2396 val = 1;
2397 break;
2398 }
2399 }
2400 if (val != 0)
2401 {
2402 sciprint ("Inputs are not coef and length array!\n");
2403 return 0;
2404 }
2405 if ((input3[0]>(m2*n2-2)) || (input3[0]<1))
2406 {
2407 sciprint ("Level Parameter is not valid for input vector!\n");
2408 return 0;
2409 }
2410 m4 = 1;
2411 n4 = input2[n2 * m2 - input3[0] - 1];
2412 //CreateVar(4, "d", &m4, &n4, &l4);
2413 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
2414 if(readFlag==SWT_GWSUPPORT_ERROR)
2415 {
2416 return 0;
2417 }
2418 //sciprint ("ok1\n");
2419 detcoef(input1, m1*n1, input2, m2*n2, output1, m4*n4,
2420 m2*n2-2, input3[0]);
2421 //sciprint ("ok2\n");
2422 //AssignOutputVariable(pvApiCtx,1) = 4;
2423 break;
2424 }
2425 default:
2426 break;
2427 }
2428
2429 return 0;
2430 }
2431
2432 int
int_wenergy(char * fname,void * pvApiCtx)2433 int_wenergy
2434 #ifdef _SCILAB6_
2435 (char *fname, void* pvApiCtx)
2436 #else
2437 (char *fname)
2438 #endif
2439 {
2440 static int m1, n1, m2, n2, m3, n3, m4, n4;
2441 static int minrhs=2, maxrhs=2, minlhs=2, maxlhs=2;
2442 int errCode, len, val, count;
2443 int readFlag;
2444 double *input1;
2445 int *int_input2;
2446 double *output1;
2447 double *output2;
2448
2449 CheckInputArgument(pvApiCtx,minrhs,maxrhs);
2450 CheckOutputArgument(pvApiCtx,minlhs,maxlhs);
2451
2452 wenergy_form_validate (pvApiCtx, &errCode, Rhs);
2453 if (errCode != SUCCESS)
2454 {
2455 validate_print (errCode);
2456 return 0;
2457 }
2458
2459 //GetRhsVar(1, "d", &m1, &n1, &l1);
2460 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 1, &m1, &n1 , &input1 );
2461 if(readFlag==SWT_GWSUPPORT_ERROR)
2462 {
2463 return 0;
2464 }
2465 //GetRhsVar(2, "i", &m2, &n2, &l2);
2466 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 2, &m2, &n2 , &int_input2 );
2467 if(readFlag==SWT_GWSUPPORT_ERROR)
2468 {
2469 return 0;
2470 }
2471
2472 len = 0;
2473 for (count = 0; count < (m2 * n2 - 1); count++)
2474 len += int_input2[count];
2475 if (len != m1 * n1)
2476 {
2477 sciprint ("Inputs are not coef and length array!\n");
2478 return 0;
2479 }
2480 val = 0;
2481 for (count = 0; count < (m2 * n2 - 1); count++)
2482 {
2483 if (int_input2[count] > int_input2[count + 1])
2484 {
2485 val = 1;
2486 break;
2487 }
2488 }
2489 if (val != 0)
2490 {
2491 sciprint ("Inputs are not coef and length array!\n");
2492 return 0;
2493 }
2494
2495 m3 = 1;
2496 n3 = 1;
2497 m4 = 1;
2498 n4 = m2 * n2 - 2;
2499 //CreateVar(3, "d", &m3, &n3, &l3);
2500 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
2501 if(readFlag==SWT_GWSUPPORT_ERROR)
2502 {
2503 return 0;
2504 }
2505 //CreateVar(4, "d", &m4, &n4, &l4);
2506 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m4 , n4 , &output2 );
2507 if(readFlag==SWT_GWSUPPORT_ERROR)
2508 {
2509 return 0;
2510 }
2511 wenergy(input1, m1 * n1, int_input2, m2 * n2,
2512 output1, m3 * n3, output2, m4 * n4);
2513 //AssignOutputVariable(pvApiCtx,1) = 3;
2514 //AssignOutputVariable(pvApiCtx,2) = 4;
2515 return 0;
2516 }
2517
2518 int
int_upcoef(char * fname,void * pvApiCtx)2519 int_upcoef
2520 #ifdef _SCILAB6_
2521 (char *fname, void* pvApiCtx)
2522 #else
2523 (char *fname)
2524 #endif
2525 {
2526 static int m1, n1, m2, n2, m3, n3;
2527 static int m4, n4, m5, n5, m6, n6;
2528 static int m7, n7;
2529 static int minrhs=3, maxrhs=6, minlhs=1, maxlhs=1;
2530 int errCode, flow, family, member, ii;
2531 int s1, s2;
2532 Func syn_fun;
2533 swt_wavelet pWaveStruct;
2534 int readFlag;
2535 double *input2;
2536 double *input3;
2537 double *input4;
2538 double *input5;
2539 double *output1;
2540 int *int_input2;
2541 int *int_input4;
2542 int *int_input5;
2543 int *int_input6;
2544 char *input_string1=NULL;
2545 char *input_string3=NULL;
2546
2547 CheckInputArgument(pvApiCtx,minrhs,maxrhs);
2548 CheckOutputArgument(pvApiCtx,minlhs,maxlhs);
2549
2550 upcoef_form_validate (pvApiCtx, &errCode, &flow, Rhs);
2551 if (errCode != SUCCESS)
2552 {
2553 validate_print (errCode);
2554 return 0;
2555 }
2556
2557
2558
2559 switch (flow) {
2560 case 1:
2561 {
2562 //GetRhsVar(1, "c", &m1, &n1, &l1);
2563 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
2564 m1=1;n1=1;
2565 if(readFlag==SWT_GWSUPPORT_ERROR)
2566 {
2567 return 0;
2568 }
2569 //GetRhsVar(2, "d", &m2, &n2, &l2);
2570 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
2571 if(readFlag==SWT_GWSUPPORT_ERROR)
2572 {
2573 return 0;
2574 }
2575 //GetRhsVar(3, "c", &m3, &n3, &l3);
2576 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 3 , &input_string3 );
2577 m3=1;n3=1;
2578 if(readFlag==SWT_GWSUPPORT_ERROR)
2579 {
2580 return 0;
2581 }
2582 //GetRhsVar(4, "i", &m4, &n4, &l4);
2583 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 4, &m4, &n4 , &int_input4 );
2584 if(readFlag==SWT_GWSUPPORT_ERROR)
2585 {
2586 return 0;
2587 }
2588 upcoef_content_validate (pvApiCtx, &errCode, flow, input_string1, input_string3, int_input4, NULL,NULL);
2589 if (errCode != SUCCESS)
2590 {
2591 validate_print (errCode);
2592 return 0;
2593 }
2594 wavelet_parser(input_string3,&family,&member);
2595 wavelet_fun_parser (input_string3, &ii);
2596 syn_fun = wi[ii].synthesis;
2597 (*syn_fun)(member, &pWaveStruct);
2598 // if (pWaveStruct.length>m2*n2)
2599 //{
2600 //sciprint ("Input signal is not valid for selected decompostion level and wavelets!\n");
2601 //return 0;
2602 //}
2603 upcoef_len_cal (m2*n2, pWaveStruct.length, int_input4[0],
2604 &s1, &s2);
2605 m5 = 1;
2606 n5 = s1;
2607 //CreateVar(5, "d", &m5, &n5, &l5);
2608 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m5 , n5 , &output1 );
2609 if(readFlag==SWT_GWSUPPORT_ERROR)
2610 {
2611 return 0;
2612 }
2613 upcoef (input2, m2*n2, pWaveStruct.pLowPass,
2614 pWaveStruct.pHiPass, pWaveStruct.length, output1,
2615 m5*n5, s1, input_string1, int_input4[0]);
2616 //AssignOutputVariable(pvApiCtx,1) = 5;
2617 break;
2618 }
2619 case 2:
2620 {
2621 //GetRhsVar(1, "c", &m1, &n1, &l1);
2622 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
2623 m1=1;n1=1;
2624 if(readFlag==SWT_GWSUPPORT_ERROR)
2625 {
2626 return 0;
2627 }
2628 //GetRhsVar(2, "d", &m2, &n2, &l2);
2629 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
2630 if(readFlag==SWT_GWSUPPORT_ERROR)
2631 {
2632 return 0;
2633 }
2634 //GetRhsVar(3, "c", &m3, &n3, &l3);
2635 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 3 , &input_string3 );
2636 m3=1;n3=1;
2637 if(readFlag==SWT_GWSUPPORT_ERROR)
2638 {
2639 return 0;
2640 }
2641 //GetRhsVar(4, "i", &m4, &n4, &l4);
2642 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 4, &m4, &n4 , &int_input4 );
2643 if(readFlag==SWT_GWSUPPORT_ERROR)
2644 {
2645 return 0;
2646 }
2647 //GetRhsVar(5, "i", &m5, &n5, &l5);
2648 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 5, &m5, &n5 , &int_input5 );
2649 if(readFlag==SWT_GWSUPPORT_ERROR)
2650 {
2651 return 0;
2652 }
2653 upcoef_content_validate (pvApiCtx, &errCode, flow, input_string1, input_string3, int_input4, int_input5, NULL);
2654 if (errCode != SUCCESS)
2655 {
2656 validate_print (errCode);
2657 return 0;
2658 }
2659 wavelet_parser(input_string3,&family,&member);
2660 wavelet_fun_parser (input_string3, &ii);
2661 syn_fun = wi[ii].synthesis;
2662 (*syn_fun)(member, &pWaveStruct);
2663 // if (pWaveStruct.length>m2*n2)
2664 //{
2665 // sciprint ("Input signal is not valid for selected decompostion level and wavelets!\n");
2666 // return 0;
2667 //}
2668 upcoef_len_cal (m2*n2, pWaveStruct.length, int_input4[0],
2669 &s1, &s2);
2670 if (int_input5[0]>s1)
2671 {
2672 sciprint("Length Parameter is not valid for input vector!\n");
2673 return 0;
2674 }
2675 m6 = 1;
2676 n6 = int_input5[0];
2677 //CreateVar(6, "d", &m6, &n6, &l6);
2678 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m6 , n6 , &output1 );
2679 if(readFlag==SWT_GWSUPPORT_ERROR)
2680 {
2681 return 0;
2682 }
2683 upcoef (input2, m2*n2, pWaveStruct.pLowPass,
2684 pWaveStruct.pHiPass, pWaveStruct.length, output1,
2685 m6*n6, s1, input_string1, int_input4[0]);
2686 //AssignOutputVariable(pvApiCtx,1) = 6;
2687 filter_clear();
2688 break;
2689 }
2690 case 3:
2691 {
2692 //GetRhsVar(1, "c", &m1, &n1, &l1);
2693 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
2694 m1=1;n1=1;
2695 if(readFlag==SWT_GWSUPPORT_ERROR)
2696 {
2697 return 0;
2698 }
2699 //GetRhsVar(2, "d", &m2, &n2, &l2);
2700 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
2701 if(readFlag==SWT_GWSUPPORT_ERROR)
2702 {
2703 return 0;
2704 }
2705 //GetRhsVar(3, "d", &m3, &n3, &l3);
2706 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 3, &m3, &n3 , &input3 );
2707 if(readFlag==SWT_GWSUPPORT_ERROR)
2708 {
2709 return 0;
2710 }
2711 //GetRhsVar(4, "d", &m4, &n4, &l4);
2712 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 4, &m4, &n4 , &input4 );
2713 if(readFlag==SWT_GWSUPPORT_ERROR)
2714 {
2715 return 0;
2716 }
2717 //GetRhsVar(5, "i", &m5, &n5, &l5);
2718 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 5, &m5, &n5 , &int_input5 );
2719 if(readFlag==SWT_GWSUPPORT_ERROR)
2720 {
2721 return 0;
2722 }
2723 upcoef_content_validate (pvApiCtx, &errCode, flow, input_string1, NULL, NULL, int_input5, NULL);
2724 if (errCode != SUCCESS)
2725 {
2726 validate_print (errCode);
2727 return 0;
2728 }
2729 //if (m3*n3>m2*n2)
2730 //{
2731 //sciprint ("Input signal is not valid for selected decompostion level and wavelets!\n");
2732 //return 0;
2733 //}
2734 upcoef_len_cal (m2*n2, m3*n3, int_input5[0], &s1, &s2);
2735 m6 = 1;
2736 n6 = s1;
2737 //CreateVar(6, "d", &m6, &n6, &l6);
2738 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m6 , n6 , &output1 );
2739 if(readFlag==SWT_GWSUPPORT_ERROR)
2740 {
2741 return 0;
2742 }
2743 upcoef (input2, m2*n2, input3, input4, m3*n3, output1,
2744 m6*n6, s1, input_string1, int_input5[0]);
2745 //AssignOutputVariable(pvApiCtx,1) = 6;
2746 break;
2747 }
2748 case 4:
2749 {
2750 //GetRhsVar(1, "c", &m1, &n1, &l1);
2751 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
2752 m1=1;n1=1;
2753 if(readFlag==SWT_GWSUPPORT_ERROR)
2754 {
2755 return 0;
2756 }
2757 //GetRhsVar(2, "d", &m2, &n2, &l2);
2758 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
2759 if(readFlag==SWT_GWSUPPORT_ERROR)
2760 {
2761 return 0;
2762 }
2763 //GetRhsVar(3, "d", &m3, &n3, &l3);
2764 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 3, &m3, &n3 , &input3 );
2765 if(readFlag==SWT_GWSUPPORT_ERROR)
2766 {
2767 return 0;
2768 }
2769 //GetRhsVar(4, "d", &m4, &n4, &l4);
2770 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 4, &m4, &n4 , &input4 );
2771 if(readFlag==SWT_GWSUPPORT_ERROR)
2772 {
2773 return 0;
2774 }
2775 //GetRhsVar(5, "i", &m5, &n5, &l5);
2776 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 5, &m5, &n5 , &int_input5 );
2777 if(readFlag==SWT_GWSUPPORT_ERROR)
2778 {
2779 return 0;
2780 }
2781 //GetRhsVar(6, "i", &m6, &n6, &l6);
2782 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 6, &m6, &n6 , &int_input6 );
2783 if(readFlag==SWT_GWSUPPORT_ERROR)
2784 {
2785 return 0;
2786 }
2787 upcoef_content_validate (pvApiCtx, &errCode, flow, input_string1, NULL, NULL, int_input5, int_input6);
2788 if (errCode != SUCCESS)
2789 {
2790 validate_print (errCode);
2791 return 0;
2792 }
2793 // if (m3*n3>m2*n2)
2794 //{
2795 //sciprint ("Input signal is not valid for selected decompostion level and wavelets!\n");
2796 //return 0;
2797 //}
2798 upcoef_len_cal (m2*n2, m3*n3, int_input5[0], &s1, &s2);
2799 if (int_input6[0]>s1)
2800 {
2801 sciprint("Length Parameter is not valid for input vector!\n");
2802 return 0;
2803 }
2804 m7 = 1;
2805 n7 = int_input6[0];
2806 //CreateVar(7, "d", &m7, &n7, &l7);
2807 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m7 , n7 , &output1 );
2808 if(readFlag==SWT_GWSUPPORT_ERROR)
2809 {
2810 return 0;
2811 }
2812 upcoef (input2, m2*n2, input3, input4, m3*n3, output1,
2813 m7*n7, s1, input_string1, int_input5[0]);
2814 //AssignOutputVariable(pvApiCtx,1) = 7;
2815 break;
2816 }
2817 case 5:
2818 {
2819 //GetRhsVar(1, "c", &m1, &n1, &l1);
2820 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
2821 m1=1;n1=1;
2822 if(readFlag==SWT_GWSUPPORT_ERROR)
2823 {
2824 return 0;
2825 }
2826 //GetRhsVar(2, "d", &m2, &n2, &l2);
2827 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
2828 if(readFlag==SWT_GWSUPPORT_ERROR)
2829 {
2830 return 0;
2831 }
2832 //GetRhsVar(3, "c", &m3, &n3, &l3);
2833 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 3 , &input_string3 );
2834 m3=1;n3=1;
2835 if(readFlag==SWT_GWSUPPORT_ERROR)
2836 {
2837 return 0;
2838 }
2839 upcoef_content_validate (pvApiCtx, &errCode, flow, input_string1, input_string3, NULL, NULL, NULL);
2840 if (errCode != SUCCESS)
2841 {
2842 validate_print (errCode);
2843 return 0;
2844 }
2845 wavelet_parser(input_string3,&family,&member);
2846 wavelet_fun_parser (input_string3, &ii);
2847 syn_fun = wi[ii].synthesis;
2848 (*syn_fun)(member, &pWaveStruct);
2849 //if (pWaveStruct.length>m2*n2)
2850 //{
2851 // sciprint ("Input signal is not valid for selected decompostion level and wavelets!\n");
2852 // return 0;
2853 //}
2854 upcoef_len_cal (m2*n2, pWaveStruct.length, 1, &s1, &s2);
2855 m4 = 1;
2856 n4 = s1;
2857 //CreateVar(4, "d", &m4, &n4, &l4);
2858 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
2859 if(readFlag==SWT_GWSUPPORT_ERROR)
2860 {
2861 return 0;
2862 }
2863 upcoef (input2, m2*n2, pWaveStruct.pLowPass,
2864 pWaveStruct.pHiPass, pWaveStruct.length, output1,
2865 m4*n4, s1, input_string1, 1);
2866 //AssignOutputVariable(pvApiCtx,1) = 4;
2867 filter_clear();
2868 break;
2869 }
2870 case 6:
2871 {
2872 //GetRhsVar(1, "c", &m1, &n1, &l1);
2873 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
2874 m1=1;n1=1;
2875 if(readFlag==SWT_GWSUPPORT_ERROR)
2876 {
2877 return 0;
2878 }
2879 //GetRhsVar(2, "d", &m2, &n2, &l2);
2880 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 2, &m2, &n2 , &input2 );
2881 if(readFlag==SWT_GWSUPPORT_ERROR)
2882 {
2883 return 0;
2884 }
2885 //GetRhsVar(3, "d", &m3, &n3, &l3);
2886 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 3, &m3, &n3 , &input3 );
2887 if(readFlag==SWT_GWSUPPORT_ERROR)
2888 {
2889 return 0;
2890 }
2891 //GetRhsVar(4, "d", &m4, &n4, &l4);
2892 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 4, &m4, &n4 , &input4 );
2893 if(readFlag==SWT_GWSUPPORT_ERROR)
2894 {
2895 return 0;
2896 }
2897 upcoef_content_validate (pvApiCtx, &errCode, flow, input_string1, NULL,NULL,NULL,NULL);
2898 if (errCode != SUCCESS)
2899 {
2900 validate_print (errCode);
2901 return 0;
2902 }
2903 // if (m3*n3>m2*n2)
2904 //{
2905 // sciprint ("Input signal is not valid for selected decompostion level and wavelets!\n");
2906 //return 0;
2907 //}
2908 upcoef_len_cal (m2*n2, m3*n3, 1, &s1, &s2);
2909 m5 = 1;
2910 n5 = s1;
2911 //CreateVar(5, "d", &m5, &n5, &l5);
2912 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m5 , n5 , &output1 );
2913 if(readFlag==SWT_GWSUPPORT_ERROR)
2914 {
2915 return 0;
2916 }
2917 upcoef (input2, m2*n2, input3, input4, m3*n3,
2918 output1, m5*n5, s1, input_string1, 1);
2919 //AssignOutputVariable(pvApiCtx,1) = 5;
2920 break;
2921 }
2922 default:
2923 break;
2924 }
2925 return 0;
2926 }
2927
2928 int
int_upwlev(char * fname,void * pvApiCtx)2929 int_upwlev
2930 #ifdef _SCILAB6_
2931 (char *fname, void* pvApiCtx)
2932 #else
2933 (char *fname)
2934 #endif
2935 {
2936 static int m1, n1, m2, n2, m3, n3;
2937 static int m4, n4, m5, n5, m6, n6;
2938 static int m7, n7;
2939 static int minrhs=3, maxrhs=4, minlhs=3, maxlhs=3;
2940 int errCode, flow, len, count, val, family, member, ii;
2941 Func syn_fun;
2942 swt_wavelet pWaveStruct;
2943 int readFlag;
2944 double *input1;
2945 int *int_input2;
2946 char *input_string3=NULL;
2947 double *input3;
2948 double *input4;
2949 double *output1;
2950 int *int_output2;
2951 double *output3;
2952
2953 CheckInputArgument(pvApiCtx,minrhs,maxrhs);
2954 CheckOutputArgument(pvApiCtx,minlhs,maxlhs);
2955
2956 upwlev_form_validate (pvApiCtx, &errCode, &flow, Rhs);
2957 if (errCode != SUCCESS)
2958 {
2959 validate_print (errCode);
2960 return 0;
2961 }
2962
2963 switch (flow) {
2964 case 1:
2965 {
2966 //GetRhsVar(1, "d", &m1, &n1, &l1);
2967 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 1, &m1, &n1 , &input1 );
2968 if(readFlag==SWT_GWSUPPORT_ERROR)
2969 {
2970 return 0;
2971 }
2972 //GetRhsVar(2, "i", &m2, &n2, &l2);
2973 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 2, &m2, &n2 , &int_input2 );
2974 if(readFlag==SWT_GWSUPPORT_ERROR)
2975 {
2976 return 0;
2977 }
2978 //GetRhsVar(3, "c", &m3, &n3, &l3);
2979 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 3 , &input_string3 );
2980 m3=1;n3=1;
2981 if(readFlag==SWT_GWSUPPORT_ERROR)
2982 {
2983 return 0;
2984 }
2985 upwlev_content_validate (pvApiCtx, &errCode, flow, input_string3);
2986 if (errCode != SUCCESS)
2987 {
2988 validate_print (errCode);
2989 return 0;
2990 }
2991 if (m2*n2 <= 3)
2992 {
2993 sciprint("Inputs are not coef and length array!\n");
2994 return 0;
2995 }
2996 len = 0;
2997 for (count = 0; count < (m2 * n2 - 1); count++)
2998 len += int_input2[count];
2999 if (len != m1 * n1)
3000 {
3001 sciprint ("Inputs are not coef and length array!\n");
3002 return 0;
3003 }
3004 val = 0;
3005 for (count = 0; count < (m2 * n2 - 1); count++)
3006 {
3007 if (int_input2[count] > int_input2[count + 1])
3008 {
3009 val = 1;
3010 break;
3011 }
3012 }
3013 if (val != 0)
3014 {
3015 sciprint ("Inputs are not coef and length array!\n");
3016 return 0;
3017 }
3018 wavelet_parser(input_string3,&family,&member);
3019 wavelet_fun_parser (input_string3, &ii);
3020 syn_fun = wi[ii].synthesis;
3021 (*syn_fun)(member, &pWaveStruct);
3022 if (int_input2[0] < pWaveStruct.length)
3023 {
3024 sciprint ("Input signal is not valid for selected decompostion level and wavelets!\n");
3025 return 0;
3026 }
3027 if (m2*n2<4)
3028 {
3029 sciprint("Decomposition level less than 2 is not accepted!\n");
3030 return 0;
3031 }
3032 m4 = 1;
3033 m5 = 1;
3034 m6 = 1;
3035 n4 = m1*n1 - 2*int_input2[0] + int_input2[2];
3036 n5 = m2 * n2 - 1;
3037 n6 = int_input2[0];
3038 //CreateVar(4, "d", &m4, &n4, &l4);
3039 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
3040 if(readFlag==SWT_GWSUPPORT_ERROR)
3041 {
3042 return 0;
3043 }
3044 //CreateVar(5, "i", &m5, &n5, &l5);
3045 readFlag = swt_gwsupport_AllocMatrixOfDoublesAsInteger (pvApiCtx, fname, 2, m5 , n5 , &int_output2 );
3046 if(readFlag==SWT_GWSUPPORT_ERROR)
3047 {
3048 return 0;
3049 }
3050 //CreateVar(6, "d", &m6, &n6, &l6);
3051 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 3, m6 , n6 , &output3 );
3052 if(readFlag==SWT_GWSUPPORT_ERROR)
3053 {
3054 return 0;
3055 }
3056 //printf("before upwlev!\n");
3057 upwlev (input1, m1*n1, int_input2, m2*n2, pWaveStruct.pLowPass,
3058 pWaveStruct.pHiPass, pWaveStruct.length,
3059 output1, m4*n4, int_output2, m5*n5, output3, m6*n6,
3060 m2*n2-2, getdwtMode());
3061 //printf("after upwlev!\n");
3062 //AssignOutputVariable(pvApiCtx,1) = 4;
3063 //AssignOutputVariable(pvApiCtx,2) = 5;
3064 //AssignOutputVariable(pvApiCtx,3) = 6;
3065 filter_clear();
3066 break;
3067 }
3068 case 2:
3069 {
3070 //GetRhsVar(1, "d", &m1, &n1, &l1);
3071 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 1, &m1, &n1 , &input1 );
3072 if(readFlag==SWT_GWSUPPORT_ERROR)
3073 {
3074 return 0;
3075 }
3076 //GetRhsVar(2, "i", &m2, &n2, &l2);
3077 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 2, &m2, &n2 , &int_input2 );
3078 if(readFlag==SWT_GWSUPPORT_ERROR)
3079 {
3080 return 0;
3081 }
3082 //GetRhsVar(3, "d", &m3, &n3, &l3);
3083 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 3, &m3, &n3 , &input3 );
3084 if(readFlag==SWT_GWSUPPORT_ERROR)
3085 {
3086 return 0;
3087 }
3088 //GetRhsVar(4, "d", &m4, &n4, &l4);
3089 readFlag = swt_gwsupport_GetRealMatrixOfDoubles (pvApiCtx, fname, 4, &m4, &n4 , &input4 );
3090 if(readFlag==SWT_GWSUPPORT_ERROR)
3091 {
3092 return 0;
3093 }
3094 upwlev_content_validate (pvApiCtx, &errCode, flow, NULL);
3095 if (errCode != SUCCESS)
3096 {
3097 validate_print (errCode);
3098 return 0;
3099 }
3100 if (m2*n2 <= 3)
3101 {
3102 sciprint("Inputs are not coef and length array!\n");
3103 return 0;
3104 }
3105 len = 0;
3106 for (count = 0; count < (m2 * n2 - 1); count++)
3107 len += int_input2[count];
3108 if (len != m1 * n1)
3109 {
3110 sciprint ("Inputs are not coef and length array!\n");
3111 return 0;
3112 }
3113 val = 0;
3114 for (count = 0; count < (m2 * n2 - 1); count++)
3115 {
3116 if (int_input2[count] > int_input2[count + 1])
3117 {
3118 val = 1;
3119 break;
3120 }
3121 }
3122 if (val != 0)
3123 {
3124 sciprint ("Inputs are not coef and length array!\n");
3125 return 0;
3126 }
3127 if (int_input2[0]<m3*n3)
3128 {
3129 sciprint ("Input signal is not valid for selected decompostion level and wavelets!\n");
3130 return 0;
3131 }
3132 if (m2*n2<4)
3133 {
3134 sciprint("Decomposition level less than 2 is not accepted!\n");
3135 return 0;
3136 }
3137 m5 = 1;
3138 m6 = 1;
3139 m7 = 1;
3140 n5 = m1*n1 - 2*int_input2[0] + int_input2[2];
3141 n6 = m2 * n2 - 1;
3142 n7 = int_input2[0];
3143 //CreateVar(5, "d", &m5, &n5, &l5);
3144 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m5 , n5 , &output1 );
3145 if(readFlag==SWT_GWSUPPORT_ERROR)
3146 {
3147 return 0;
3148 }
3149 //CreateVar(6, "i", &m6, &n6, &l6);
3150 readFlag = swt_gwsupport_AllocMatrixOfDoublesAsInteger (pvApiCtx, fname, 2, m6 , n6 , &int_output2 );
3151 if(readFlag==SWT_GWSUPPORT_ERROR)
3152 {
3153 return 0;
3154 }
3155 //CreateVar(7, "d", &m7, &n7, &l7);
3156 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 3, m7 , n7 , &output3 );
3157 if(readFlag==SWT_GWSUPPORT_ERROR)
3158 {
3159 return 0;
3160 }
3161 upwlev (input1, m1*n1, int_input2, m2*n2, input3,
3162 input4, m3*n3,
3163 output1, m5*n5, int_output2, m6*n6, output3, m7*n7,
3164 m2*n2-2, getdwtMode());
3165 //AssignOutputVariable(pvApiCtx,1) = 5;
3166 //AssignOutputVariable(pvApiCtx,2) = 6;
3167 //AssignOutputVariable(pvApiCtx,3) = 7;
3168 break;
3169 }
3170 default:
3171 break;
3172 }
3173 return 0;
3174 }
3175