c478ed555eaeeb3820dbd3a45b912b61dded160d
[scilab.git] / scilab / modules / graphics / sci_gateway / c / sci_plot2d1.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  *
6  * Copyright (C) 2012 - 2016 - Scilab Enterprises
7  *
8  * This file is hereby licensed under the terms of the GNU GPL v2.0,
9  * pursuant to article 5.3.4 of the CeCILL v.2.1.
10  * This file was originally licensed under the terms of the CeCILL v2.1,
11  * and continues to be available under such terms.
12  * For more information, see the COPYING file which you should have received
13  * along with this program.
14  *
15  */
16
17 /*------------------------------------------------------------------------*/
18 /* file: sci_plot2d1.c                                                    */
19 /* desc : interface for plot2d2, plot2d3 and plot2d4 routines    */
20 /*------------------------------------------------------------------------*/
21 #include <string.h>
22 #include "gw_graphics.h"
23 #include "api_scilab.h"
24 #include "GetCommandArg.h"
25 #include "DefaultCommandArg.h"
26 #include "sciCall.h"
27 #include "localization.h"
28 #include "Scierror.h"
29 #include "sci_malloc.h"
30
31 /*--------------------------------------------------------------------------*/
32 int sci_plot2d1_2 (char *fname, void *pvApiCtx)
33 {
34     return sci_plot2d1_G("plot2d2", 2, pvApiCtx); /* NG */
35 }
36 /*--------------------------------------------------------------------------*/
37 int sci_plot2d1_3 (char *fname, void *pvApiCtx)
38 {
39     return sci_plot2d1_G("plot2d3", 3, pvApiCtx); /* NG */
40 }
41 /*--------------------------------------------------------------------------*/
42 int sci_plot2d1_4 (char *fname, void *pvApiCtx)
43 {
44     return sci_plot2d1_G("plot2d4", 4, pvApiCtx); /* NG */
45 }
46 /*--------------------------------------------------------------------------*/
47 int sci_plot2d1_G(char * fname, int ptype, void *pvApiCtx)
48 {
49     SciErr sciErr;
50     int* piAddrl1 = NULL;
51     double* l1 = NULL;
52     int* piAddrl2 = NULL;
53     double* l2 = NULL;
54     double* lt = NULL;
55
56     int frame_def = 8;
57     int *frame = &frame_def;
58     int axes_def = 1;
59     int *axes = &axes_def;
60     int iskip = 0, test  = 0;
61     int m1 = 0, n1 = 0, m2 = 0, n2 = 0, i = 0, j = 0;
62
63     static rhs_opts opts[] =
64     {
65         { -1, "axesflag", -1, 0, 0, NULL},
66         { -1, "frameflag", -1, 0, 0, NULL},
67         { -1, "leg", -1, 0, 0, NULL},
68         { -1, "logflag", -1, 0, 0, NULL},
69         { -1, "nax", -1, 0, 0, NULL},
70         { -1, "rect", -1, 0, 0, NULL},
71         { -1, "strf", -1, 0, 0, NULL},
72         { -1, "style", -1, 0, 0, NULL},
73         { -1, NULL, -1, 0, 0, NULL}
74     };
75
76     int    * style    = NULL ;
77     double* rect     = NULL ;
78     int    * nax      = NULL ;
79     BOOL     flagNax  = FALSE;
80     char   * strf     = NULL ;
81     char strfl[4];
82     char   * legend   = NULL ;
83     char   * logFlags = NULL ;
84
85     if (nbInputArgument(pvApiCtx) <= 0)
86     {
87         /* lauch the default routines depending on the name of the calling function */
88         sci_demo(fname, pvApiCtx);
89         return 0;
90     }
91     CheckInputArgument(pvApiCtx, 1, 9); /* to allow plot2dxx(y) */
92
93
94     iskip = 0;
95     if (getOptionals(pvApiCtx, fname, opts) == 0)
96     {
97         ReturnArguments(pvApiCtx);
98         return 0;
99     }
100
101     if (checkInputArgumentType(pvApiCtx, 1, sci_strings))
102     {
103         /* logflags */
104         if (get_logflags_arg(pvApiCtx, fname, 1, opts, &logFlags) == 0)
105         {
106             return 0;
107         }
108         iskip = 1;
109     }
110
111     /* added to support plot2dxx([logflags],y) */
112     if (nbInputArgument(pvApiCtx) == 1 + iskip)
113     {
114         if (FirstOpt(pvApiCtx) <= nbInputArgument(pvApiCtx))
115         {
116             Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 3 + iskip);
117             return (0);
118         }
119
120         sciErr = getVarAddressFromPosition(pvApiCtx, 1 + iskip, &piAddrl2);
121         if (sciErr.iErr)
122         {
123             printError(&sciErr, 0);
124             return 1;
125         }
126
127         // Retrieve a matrix of double at position 1 + iskip.
128         sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
129         if (sciErr.iErr)
130         {
131             printError(&sciErr, 0);
132             Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1 + iskip);
133             return 1;
134         }
135
136         sciErr = allocMatrixOfDouble(pvApiCtx, 2 + iskip, m2, n2, &l1);
137         if (sciErr.iErr)
138         {
139             printError(&sciErr, 0);
140             Scierror(999, _("%s: Memory allocation error.\n"), fname);
141             return 1;
142         }
143
144         if (m2 == 1 && n2 > 1)
145         {
146             m2 = n2;
147             n2 = 1;
148         }
149
150         m1 = m2;
151         n1 = n2;
152
153         for (i = 0; i < m2 ; ++i)
154         {
155             for (j = 0 ; j < n2 ;  ++j)
156             {
157                 *(l1 + i + m2 * j) = (double) i + 1;
158             }
159         }
160     }
161
162
163     if (nbInputArgument(pvApiCtx) >= 2 + iskip)
164     {
165         if (FirstOpt(pvApiCtx) < 3 + iskip)
166         {
167             Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"),
168                      fname, 1, 3 + iskip);
169             return (0);
170         }
171
172
173         /* x */
174         sciErr = getVarAddressFromPosition(pvApiCtx, 1 + iskip, &piAddrl1);
175         if (sciErr.iErr)
176         {
177             printError(&sciErr, 0);
178             return 1;
179         }
180
181         // Retrieve a matrix of double at position 1 + iskip.
182         sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1);
183         if (sciErr.iErr)
184         {
185             printError(&sciErr, 0);
186             Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1 + iskip);
187             return 1;
188         }
189
190         if (iskip == 1)
191         {
192             if (logFlags[0] == 'e')
193             {
194                 m1 = 0;
195                 n1 = 0;
196             }
197         }
198
199         /* y */
200         sciErr = getVarAddressFromPosition(pvApiCtx, 2 + iskip, &piAddrl2);
201         if (sciErr.iErr)
202         {
203             printError(&sciErr, 0);
204             return 1;
205         }
206
207         // Retrieve a matrix of double at position 2 + iskip.
208         sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
209         if (sciErr.iErr)
210         {
211             printError(&sciErr, 0);
212             Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2 + iskip);
213             return 1;
214         }
215
216         /* if (m2 * n2 == 0) { m1 = 0; n1 = 0;}  */
217
218         test = (m1 * n1 == 0) /* x = [] */
219                /* x,y vectors of same length */
220                || ((m1 == 1 || n1 == 1) && (m2 == 1 || n2 == 1) && (m1 * n1 == m2 * n2))
221                || ((m1 == m2) && (n1 == n2)) /* size(x) == size(y) */
222                /* x vector size(y)==[size(x),.] */
223                || ((m1 == 1 && n1 == m2) || (n1 == 1 && m1 == m2));
224
225         //CheckDimProp
226         if (!test)
227         {
228             Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
229             return 1;
230         }
231
232
233         if (m1 * n1 == 0)
234         {
235             /* default x=1:n */
236             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m2, n2, &lt);
237             if (sciErr.iErr)
238             {
239                 printError(&sciErr, 0);
240                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
241                 return 1;
242             }
243
244             if (m2 == 1 && n2 > 1)
245             {
246                 m2 = n2;
247                 n2 = 1;
248             }
249             for (i = 0; i < m2 ; ++i)
250             {
251                 for (j = 0 ; j < n2 ;  ++j)
252                 {
253                     *(lt + i + m2 * j) = (double) i + 1;
254                 }
255             }
256             m1 = m2;
257             n1 = n2;
258             l1 = lt;
259         }
260         else if ((m1 == 1 || n1 == 1) && (m2 != 1 && n2 != 1))
261         {
262             /* a single x vector for mutiple columns for y */
263             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m2, n2, &lt);
264             if (sciErr.iErr)
265             {
266                 printError(&sciErr, 0);
267                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
268                 return 1;
269             }
270
271             for (i = 0; i < m2 ; ++i)
272             {
273                 for (j = 0 ; j < n2 ;  ++j)
274                 {
275                     *(lt + i + m2 * j) = l1[i];
276                 }
277             }
278             m1 = m2;
279             n1 = n2;
280             l1 = lt;
281         }
282         else if ((m1 == 1 && n1 == 1) && (n2 != 1))
283         {
284             /* a single y row vector  for a single x */
285             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n2, &lt);
286             if (sciErr.iErr)
287             {
288                 printError(&sciErr, 0);
289                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
290                 return 1;
291             }
292
293             for (j = 0 ; j < n2 ;  ++j)
294             {
295                 lt[j] = *l1;
296             }
297             n1 = n2;
298             l1 = lt;
299         }
300         else
301         {
302             if (m2 == 1 && n2 > 1)
303             {
304                 m2 = n2;
305                 n2 = 1;
306             }
307             if (m1 == 1 && n1 > 1)
308             {
309                 m1 = n1;
310                 n1 = 1;
311             }
312         }
313     }
314
315     if (get_style_arg(pvApiCtx, fname, 3 + iskip, n1, opts, &style) == 0)
316     {
317         return 0;
318     }
319     if (get_strf_arg(pvApiCtx, fname, 4 + iskip, opts, &strf) == 0)
320     {
321         return 0;
322     }
323     if (get_legend_arg(pvApiCtx, fname, 5 + iskip, opts, &legend) == 0)
324     {
325         return 0;
326     }
327     if (get_rect_arg(pvApiCtx, fname, 6 + iskip, opts, &rect) == 0)
328     {
329         return 0;
330     }
331     if (get_nax_arg(pvApiCtx, 7 + iskip, opts, &nax, &flagNax)==0)
332     {
333         return 0;
334     }
335
336     if (iskip == 0)
337     {
338         if (get_logflags_arg(pvApiCtx, fname, 8, opts, &logFlags) == 0)
339         {
340             return 0;
341         }
342     }
343
344     if (isDefStrf(strf))
345     {
346         strcpy(strfl, DEFSTRFN);
347
348         strf = strfl;
349         if (!isDefRect(rect))
350         {
351             strfl[1] = '7';
352         }
353         if (!isDefLegend(legend))
354         {
355             strfl[0] = '1';
356         }
357         if (get_optional_int_arg(pvApiCtx, fname, 9, "frameflag", &frame, 1, opts) == 0)
358         {
359             return 0;
360         }
361         if (frame != &frame_def)
362         {
363             strfl[1] = (char)(*frame + 48);
364         }
365         if (get_optional_int_arg(pvApiCtx, fname, 9, "axesflag", &axes, 1, opts) == 0)
366         {
367             return 0;
368         }
369         if (axes != &axes_def)
370         {
371             strfl[2] = (char)(*axes + 48);
372         }
373     }
374
375     if (ptype == 0)
376     {
377         ptype = 1;
378     }
379
380     Objplot2d (ptype, logFlags, (l1), (l2), &n1, &m1, style, strf, legend, rect, nax, flagNax);
381
382     // Allocated by sciGetStyle (get_style_arg function in GetCommandArg.c)
383     FREE(style);
384
385     AssignOutputVariable(pvApiCtx, 1) = 0;
386     ReturnArguments(pvApiCtx);
387     return 0;
388 }
389 /*--------------------------------------------------------------------------*/