0a721cca301a9b8f2d2780eeb1394be354b44c2b
[scilab.git] / scilab / modules / graphics / sci_gateway / c / sci_fec.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2006 - INRIA - Fabrice Leray
4  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
5  * Copyright (C) 2011 - DIGITEO - Bruno JOFRET
6  *
7  * Copyright (C) 2012 - 2016 - Scilab Enterprises
8  *
9  * This file is hereby licensed under the terms of the GNU GPL v2.0,
10  * pursuant to article 5.3.4 of the CeCILL v.2.1.
11  * This file was originally licensed under the terms of the CeCILL v2.1,
12  * and continues to be available under such terms.
13  * For more information, see the COPYING file which you should have received
14  * along with this program.
15  *
16  */
17
18 /*------------------------------------------------------------------------*/
19 /* file: sci_fec.c                                                        */
20 /* desc : interface for sci_fec routine                                   */
21 /*------------------------------------------------------------------------*/
22 #include <string.h>
23 #include "gw_graphics.h"
24 #include "api_scilab.h"
25 #include "GetCommandArg.h"
26 #include "BuildObjects.h"
27 #include "sciCall.h"
28 #include "DefaultCommandArg.h"
29 #include "localization.h"
30 #include "Scierror.h"
31
32 /*--------------------------------------------------------------------------*/
33 int sci_fec(char *fname, void *pvApiCtx)
34 {
35     SciErr sciErr;
36     int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0, m4 = 0, n4 = 0, mn1 = 0;
37
38     static rhs_opts opts[] =
39     {
40         { -1, "colminmax", -1, 0, 0, NULL},
41         { -1, "colout", -1, 0, 0, NULL},
42         { -1, "leg", -1, 0, 0, NULL},
43         { -1, "mesh", -1, 0, 0, NULL},
44         { -1, "nax", -1, 0, 0, NULL},
45         { -1, "rect", -1, 0, 0, NULL},
46         { -1, "strf", -1, 0, 0, NULL},
47         { -1, "zminmax", -1, 0, 0, NULL},
48         { -1, NULL, -1, 0, 0, NULL}
49     };
50
51     char* strf      = NULL;
52     char strfl[4];
53     char* legend    = NULL;
54     double* rect    = NULL;
55     double* zminmax = NULL;
56     int* colminmax  = NULL;
57     int* nax        = NULL;
58     int* colOut     = NULL;
59     BOOL flagNax    = FALSE;
60     BOOL withMesh   = FALSE;
61
62     int* piAddr1 = NULL;
63     int* piAddr2 = NULL;
64     int* piAddr3 = NULL;
65     int* piAddr4 = NULL;
66
67     double* l1 = NULL;
68     double* l2 = NULL;
69     double* l3 = NULL;
70     double* l4 = NULL;
71
72     if (nbInputArgument(pvApiCtx) <= 0)
73     {
74         sci_demo(fname, pvApiCtx);
75         return 0;
76     }
77
78     CheckInputArgument(pvApiCtx, 4, 12);
79
80     if (getOptionals(pvApiCtx, fname, opts) == 0)
81     {
82         ReturnArguments(pvApiCtx);
83         return 0;
84     }
85
86     if (FirstOpt(pvApiCtx) < 5)
87     {
88         Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 5);
89         return -1;
90     }
91
92     //get variable address
93     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
94     if (sciErr.iErr)
95     {
96         printError(&sciErr, 0);
97         return 1;
98     }
99
100     // Retrieve a matrix of double at position 1.
101     sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &m1, &n1, &l1);
102     if (sciErr.iErr)
103     {
104         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
105         printError(&sciErr, 0);
106         return 1;
107     }
108
109     //get variable address
110     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
111     if (sciErr.iErr)
112     {
113         printError(&sciErr, 0);
114         return 1;
115     }
116
117     // Retrieve a matrix of double at position 2.
118     sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2);
119     if (sciErr.iErr)
120     {
121         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2);
122         printError(&sciErr, 0);
123         return 1;
124     }
125
126     //CheckSameDims
127     if (m1 != m2 || n1 != n2)
128     {
129         Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
130         return 1;
131     }
132
133
134     //get variable address
135     sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
136     if (sciErr.iErr)
137     {
138         printError(&sciErr, 0);
139         return 1;
140     }
141
142     // Retrieve a matrix of double at position 3.
143     sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3);
144     if (sciErr.iErr)
145     {
146         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3);
147         printError(&sciErr, 0);
148         return 1;
149     }
150
151     if (n3 < 5)
152     {
153         Scierror(999, _("%s: Wrong number of columns for input argument #%d: at least %d expected.\n"), fname, 3, 5);
154         return 0;
155     }
156     // remove number and flag
157     n3 -= 2;
158
159     //get variable address
160     sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
161     if (sciErr.iErr)
162     {
163         printError(&sciErr, 0);
164         return 1;
165     }
166
167     // Retrieve a matrix of double at position 4.
168     sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &m4, &n4, &l4);
169     if (sciErr.iErr)
170     {
171         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 4);
172         printError(&sciErr, 0);
173         return 1;
174     }
175
176
177     if (m1 * n1 == 0 || m3 == 0)
178     {
179         AssignOutputVariable(pvApiCtx, 1) = 0;
180         ReturnArguments(pvApiCtx);
181         return 0;
182     }
183
184     if (get_strf_arg(pvApiCtx, fname, 5, opts, &strf) == 0)
185     {
186         return 0;
187     }
188     if (get_legend_arg(pvApiCtx, fname, 6, opts, &legend) == 0)
189     {
190         return 0;
191     }
192     if (get_rect_arg(pvApiCtx, fname, 7, opts, &rect) == 0)
193     {
194         return 0;
195     }
196     if (get_nax_arg(pvApiCtx, 8, opts, &nax, &flagNax)==0)
197     {
198         return 0;
199     }
200     if (get_zminmax_arg(pvApiCtx, fname, 9, opts, &zminmax) == 0)
201     {
202         return 0;
203     }
204     if (get_colminmax_arg(pvApiCtx, fname, 10, opts, &colminmax)==0)
205     {
206         return 0;
207     }
208     if (get_colout_arg(pvApiCtx, fname, 11, opts, &colOut)==0)
209     {
210         return 0;
211     }
212     if (get_with_mesh_arg(pvApiCtx, fname, 12, opts, &withMesh)==0)
213     {
214         return 0;
215     }
216
217     getOrCreateDefaultSubwin();
218
219     if (isDefStrf (strf))
220     {
221         strcpy(strfl, DEFSTRFN);
222
223         strf = strfl;
224         if (!isDefRect(rect))
225         {
226             strfl[1] = '7';
227         }
228         if (!isDefLegend(legend))
229         {
230             strfl[0] = '1';
231         }
232     }
233     mn1 = m1 * n1;
234
235     Objfec ((l1), (l2), (l3), (l4), &mn1, &m3, &n3, strf, legend, rect, nax, zminmax, colminmax, colOut, withMesh, flagNax);
236
237     AssignOutputVariable(pvApiCtx, 1) = 0;
238     ReturnArguments(pvApiCtx);
239
240     return 0;
241 }
242
243 /*--------------------------------------------------------------------------*/