65716325f1fca59626d5f8d5da0f13e994cbb74f
[scilab.git] / scilab / modules / graphics / sci_gateway / c / sci_plot3d.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) 2008 - INRIA - Sylvestre LEDRU (nicer default plot3d)
6  *
7  * This file must be used under the terms of the CeCILL.
8  * This source file is licensed as described in the file COPYING, which
9  * you should have received as part of this distribution.  The terms
10  * are also available at
11  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
12  *
13  */
14
15 /*------------------------------------------------------------------------*/
16 /* file: sci_plot3d.c                                                     */
17 /* desc : interface for plot3d (and plot3d1) routine                      */
18 /*------------------------------------------------------------------------*/
19
20 #include <stdio.h>
21
22 #include "gw_graphics.h"
23 #include "api_scilab.h"
24 #include "BuildObjects.h"
25 #include "GetCommandArg.h"
26 #include "MALLOC.h"
27 #include "sciCall.h"
28 #include "localization.h"
29 #include "Scierror.h"
30
31 /*--------------------------------------------------------------------------*/
32 int sci_plot3d(char * fname, unsigned long fname_len)
33 {
34     SciErr sciErr;
35     static double  ebox_def [6] = { 0, 1, 0, 1, 0, 1};
36     double *ebox = ebox_def;
37     static int iflag_def[3] = {2, 2, 4};
38     int *iflag = iflag_def;
39     double  alpha_def = 35.0 , theta_def = 45.0;
40     double *alpha = &alpha_def, *theta = &theta_def;
41     int m1 = 0, n1 = 0,  m2 = 0, n2 = 0, m3 = 0, n3 = 0;
42     int m3n = 0, n3n = 0, m3l = 0;
43
44     int izcol = 0,  isfac = 0;
45     double *zcol = NULL;
46     int mustFree = 0;
47
48     static rhs_opts opts[] =
49     {
50         { -1, "alpha", -1, 0, 0, NULL},
51         { -1, "ebox", -1, 0, 0, NULL},
52         { -1, "flag", -1, 0, 0, NULL},
53         { -1, "leg", -1, 0, 0, NULL},
54         { -1, "theta", -1, 0, 0, NULL},
55         { -1, NULL, -1, 0, 0, NULL}
56     };
57
58     char * legend = NULL;
59
60     int* piAddr1  = NULL;
61     int* piAddr2  = NULL;
62     int* piAddr3  = NULL;
63     int* piAddr31 = NULL;
64     int* piAddr32 = NULL;
65
66     double* l1  = NULL;
67     double* l2  = NULL;
68     double* l3  = NULL;
69     double* l3n = NULL;
70
71     /*
72     ** This overload the function to call demo script
73     ** the demo script is called %_<fname>
74     */
75     if (nbInputArgument(pvApiCtx) <= 0)
76     {
77         sci_demo(fname, fname_len);
78         return 0;
79     }
80
81     if (nbInputArgument(pvApiCtx) == 2)
82     {
83         Scierror(77, _("%s: Wrong number of input argument(s).\n"), fname);
84         return -1;
85     }
86
87     CheckInputArgument(pvApiCtx, 1, 8);
88
89     if (getOptionals(pvApiCtx, fname, opts) == 0)
90     {
91         ReturnArguments(pvApiCtx);
92         return 0;
93     }
94
95     if (nbInputArgument(pvApiCtx) != 1 && FirstOpt() < 4)
96     {
97         Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 4);
98         return -1;
99     }
100
101     //get variable address
102     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
103     if (sciErr.iErr)
104     {
105         printError(&sciErr, 0);
106         return 1;
107     }
108
109     // Retrieve a matrix of double at position 1.
110     sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &m1, &n1, &l1);
111     if (sciErr.iErr)
112     {
113         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
114         printError(&sciErr, 0);
115         return 1;
116     }
117
118     if (nbInputArgument(pvApiCtx) == 1)
119     {
120         int i;
121
122         if (m1 * n1 == 0)
123         {
124             AssignOutputVariable(pvApiCtx, 1) = 0;
125             ReturnArguments(pvApiCtx);
126             return 0;
127         }
128
129         l3 = l1;
130         m3 = m1;
131         n3 = n1;
132         m1 = 1;
133         n1 = m3;
134         m2 = 1;
135         n2 = n3;
136         l1 = (double *)MALLOC(sizeof(double) * n1);
137         for (i = 0; i < n1; l1[i] = (++i))
138         {
139             ;
140         }
141         l2 = (double *)MALLOC(sizeof(double) * n2);
142         for (i = 0; i < n2; l2[i] = (++i))
143         {
144             ;
145         }
146
147         mustFree = 1;
148     }
149
150     if (nbInputArgument(pvApiCtx) >= 3)
151     {
152         //get variable address
153         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
154         if (sciErr.iErr)
155         {
156             printError(&sciErr, 0);
157             return 1;
158         }
159
160         // Retrieve a matrix of double at position 2.
161         sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2);
162         if (sciErr.iErr)
163         {
164             Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2);
165             printError(&sciErr, 0);
166             return 1;
167         }
168
169         if (m1 * n1 == 0)
170         {
171             AssignOutputVariable(pvApiCtx, 1) = 0;
172             ReturnArguments(pvApiCtx);
173             return 0;
174         }
175
176         /*     third argument can be a matrix z or a list list(z,zcol) */
177         sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
178         if (sciErr.iErr)
179         {
180             printError(&sciErr, 0);
181             return 1;
182         }
183
184         switch (getInputArgumentType(pvApiCtx, 3))
185         {
186             case sci_matrix :
187                 //get variable address
188                 sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
189                 if (sciErr.iErr)
190                 {
191                     printError(&sciErr, 0);
192                     return 1;
193                 }
194
195                 // Retrieve a matrix of double at position 3.
196                 sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3);
197                 if (sciErr.iErr)
198                 {
199                     Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3);
200                     printError(&sciErr, 0);
201                     return 1;
202                 }
203
204                 izcol = 0;
205                 break;
206             case sci_list :
207                 izcol = 1;
208                 /* z = list(z,colors) */
209                 sciErr = getListItemNumber(pvApiCtx, piAddr3, &m3l);
210                 if (sciErr.iErr)
211                 {
212                     Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3);
213                     printError(&sciErr, 0);
214                     return 1;
215                 }
216
217                 if (m3l != 2)
218                 {
219                     Scierror(999, _("%s: Wrong size for input argument #%d: List of size %d expected.\n"),
220                              fname, 2, m3l, 2);
221                     return 1;
222                 }
223
224                 sciErr = getListItemAddress(pvApiCtx, piAddr3, 1, &piAddr31);
225                 if (sciErr.iErr)
226                 {
227                     printError(&sciErr, 0);
228                     return 1;
229                 }
230
231                 sciErr = getMatrixOfDouble(pvApiCtx, piAddr31, &m3, &n3, &l3); /* z */
232                 if (sciErr.iErr)
233                 {
234                     Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3);
235                     printError(&sciErr, 0);
236                     return 1;
237                 }
238
239                 sciErr = getListItemAddress(pvApiCtx, piAddr3, 2, &piAddr32);
240                 if (sciErr.iErr)
241                 {
242                     printError(&sciErr, 0);
243                     return 1;
244                 }
245
246                 sciErr = getMatrixOfDouble(pvApiCtx, piAddr32, &m3n, &n3n, &l3n); /* z */
247                 if (sciErr.iErr)
248                 {
249                     Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3);
250                     printError(&sciErr, 0);
251                     return 1;
252                 }
253
254                 zcol  = (l3n);
255                 if (m3n * n3n != n3 &&  m3n * n3n != m3 * n3)
256                 {
257                     Scierror(999, _("%s: Wrong size for input argument #%d: %d or %d expected.\n"), fname, 3, n3, m3 * n3);
258                     return 1;
259                 }
260                 /*
261                  *   Added by E Segre 4/5/2000. In the case where zcol is a
262                  *   matrix of the same size as z, we set izcol to 2. This
263                  *   value is later transmitted to the C2F(fac3dg) routine,
264                  *   which has been modified to do the interpolated shading
265                  *    (see the file SCI/modules/graphics/src/c/Plo3d.c
266                  */
267                 if (m3n * n3n == m3 * n3)
268                 {
269                     izcol = 2 ;
270                 }
271                 break;
272             default :
273                 OverLoad(3);
274                 return 0;
275         }
276     }
277
278     iflag_def[1] = 8;
279
280     GetOptionalDoubleArg(pvApiCtx, fname, 4, "theta", &theta, 1, opts);
281     GetOptionalDoubleArg(pvApiCtx, fname, 5, "alpha", &alpha, 1, opts);
282     GetLabels(pvApiCtx, fname, 6, opts, &legend);
283     GetOptionalIntArg(pvApiCtx, fname, 7, "flag", &iflag, 3, opts);
284     GetOptionalDoubleArg(pvApiCtx, fname, 8, "ebox", &ebox, 6, opts);
285
286     if (m1 * n1 == m3 * n3 && m1 * n1 == m2 * n2 && m1 * n1 != 1)
287     {
288         if (! (m1 == m2 && m2 == m3 && n1 == n2 && n2 == n3))
289         {
290             Scierror(999, _("%s: Wrong value for input arguments #%d, #%d and #%d: Incompatible length.\n"), fname, 1, 2, 3);
291             return 1;
292         }
293     }
294     else
295     {
296         if (m2 * n2 != n3)
297         {
298             Scierror(999, _("%s: Wrong value for input arguments #%d and #%d: Incompatible length.\n"), fname, 2, 3);
299             return 1;
300         }
301
302         if (m1 * n1 != m3)
303         {
304             Scierror(999, _("%s: Wrong value for input arguments #%d and #%d: Incompatible length.\n"), fname, 1, 3);
305             return 1;
306         }
307
308         if (m1 * n1 <= 1 || m2 * n2 <= 1)
309         {
310             Scierror(999, _("%s: Wrong size for input arguments #%d and #%d: %s expected.\n"), fname, 2, 3, ">= 2");
311             return 1;
312         }
313     }
314
315     if (m1 * n1 == 0 || m2 * n2 == 0 || m3 * n3 == 0)
316     {
317         AssignOutputVariable(pvApiCtx, 1) = 0;
318         ReturnArguments(pvApiCtx);
319         return 0;
320     }
321
322     getOrCreateDefaultSubwin();
323
324     /******************** 24/05/2002 ********************/
325     if (m1 * n1 == m3 * n3 && m1 * n1 == m2 * n2 && m1 * n1 != 1) /* NG beg */
326     {
327         isfac = 1;
328     }
329     else
330     {
331         isfac = 0;
332     }
333
334
335     Objplot3d (fname, &isfac, &izcol, (l1), (l2), (l3), zcol, &m3, &n3, theta, alpha, legend, iflag, ebox, &m1, &n1, &m2, &n2, &m3, &n3, &m3n, &n3n); /*Adding F.Leray 12.03.04 and 19.03.04*/
336
337     if (mustFree)
338     {
339         FREE(l1);
340         FREE(l2);
341     }
342
343     AssignOutputVariable(pvApiCtx, 1) = 0;
344     ReturnArguments(pvApiCtx);
345     return 0;
346
347 }
348 /*--------------------------------------------------------------------------*/