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