a835b77bc4985ef77c08ecb651b716b9e48d28d5
[scilab.git] / scilab / modules / graphics / sci_gateway / c / sci_matplot.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  * This file must be used under the terms of the CeCILL.
7  * This source file is licensed as described in the file COPYING, which
8  * you should have received as part of this distribution.  The terms
9  * are also available at
10  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
11  *
12  */
13
14 /*------------------------------------------------------------------------*/
15 /* file: sci_matplot.h                                                    */
16 /* desc : interface for matplot routine                                   */
17 /*------------------------------------------------------------------------*/
18
19 #include "gw_graphics.h"
20 #include "GetCommandArg.h"
21 #include "DefaultCommandArg.h"
22 #include "BuildObjects.h"
23 #include "sciCall.h"
24 #include "api_scilab.h"
25 #include "localization.h"
26 #include "Scierror.h"
27 #include "Matplot.h"
28 /*--------------------------------------------------------------------------*/
29
30 int sci_matplot(char *fname, unsigned long fname_len)
31 {
32     SciErr sciErr;
33     int m1 = 0, n1 = 0;
34     int frame_def = 8;
35     int *frame = &frame_def;
36     int axes_def = 1;
37     int *axes = &axes_def;
38     static rhs_opts opts[] =
39     {
40         { -1, "axesflag", -1, 0, 0, NULL},
41         { -1, "frameflag", -1, 0, 0, NULL},
42         { -1, "nax", -1, 0, 0, NULL},
43         { -1, "rect", -1, 0, 0, NULL},
44         { -1, "strf", -1, 0, 0, NULL},
45         { -1, NULL, -1, 0, 0, NULL}
46     };
47
48     char   * strf    = NULL ;
49     char strfl[4];
50     double* rect    = NULL ;
51     int    * nax     = NULL ;
52     BOOL     flagNax = FALSE;
53
54     int* piAddr1 = NULL;
55     void * l1 = NULL;
56     int type = 0;
57     int precision = 0;
58     int plottype = -1;
59
60     if (nbInputArgument(pvApiCtx) <= 0)
61     {
62         sci_demo(fname, fname_len);
63         return 0;
64     }
65     CheckInputArgument(pvApiCtx, 1, 5);
66
67     if (getOptionals(pvApiCtx, fname, opts) == 0)
68     {
69         ReturnArguments(pvApiCtx);
70         return 0;
71     }
72     if (FirstOpt() < 2)
73     {
74         Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"),
75                  fname, 1, 2);
76         return(0);
77     }
78
79     //get variable address
80     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
81     if (sciErr.iErr)
82     {
83         printError(&sciErr, 0);
84         return 1;
85     }
86
87     sciErr = getVarType(pvApiCtx, piAddr1, &type);
88     if (sciErr.iErr)
89     {
90         Scierror(999, _("%s: Cannot get the data type.\n"), fname, 1);
91         printError(&sciErr, 0);
92         return 1;
93     }
94
95     switch (type)
96     {
97         case sci_matrix :
98             sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &m1, &n1, (double **)&l1);
99             if (sciErr.iErr)
100             {
101                 Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
102                 printError(&sciErr, 0);
103                 return 1;
104             }
105
106             if (m1 * n1 == 0)
107             {
108                 AssignOutputVariable(pvApiCtx, 1) = 0;
109                 ReturnArguments(pvApiCtx);
110                 return 0;
111             }
112
113             plottype = buildMatplotType(MATPLOT_Double, MATPLOT_FORTRAN, MATPLOT_INDEX);
114             break;
115         case sci_ints :
116             sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr1, &precision);
117             if (sciErr.iErr)
118             {
119                 Scierror(999, _("%s: Cannot get the integer precision for argument %d.\n"), fname, 1);
120                 printError(&sciErr, 0);
121                 return 1;
122             }
123
124             switch (precision)
125             {
126                 case SCI_INT8 :
127                     sciErr = getMatrixOfInteger8(pvApiCtx, piAddr1, &m1, &n1, (char **)(&l1));
128                     if (sciErr.iErr)
129                     {
130                         Scierror(202, _("%s: Cannot get the data for argument %d.\n"), fname, 1);
131                         printError(&sciErr, 0);
132                         return 1;
133                     }
134                     plottype = buildMatplotType(MATPLOT_Char, MATPLOT_FORTRAN, MATPLOT_RGB_332);
135                     break;
136                 case SCI_UINT8 :
137                     sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddr1, &m1, &n1, (unsigned char **)(&l1));
138                     if (sciErr.iErr)
139                     {
140                         Scierror(202, _("%s: Cannot get the data for argument %d.\n"), fname, 1);
141                         printError(&sciErr, 0);
142                         return 1;
143                     }
144                     plottype = buildMatplotType(MATPLOT_UChar, MATPLOT_FORTRAN, MATPLOT_GRAY);
145                     break;
146                 case SCI_INT16 :
147                     sciErr = getMatrixOfInteger16(pvApiCtx, piAddr1, &m1, &n1, (short **)(&l1));
148                     if (sciErr.iErr)
149                     {
150                         Scierror(202, _("%s: Cannot get the data for argument %d.\n"), fname, 1);
151                         printError(&sciErr, 0);
152                         return 1;
153                     }
154                     plottype = buildMatplotType(MATPLOT_Short, MATPLOT_FORTRAN, MATPLOT_RGB_444);
155                     break;
156                 case SCI_UINT16 :
157                     sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddr1, &m1, &n1, (unsigned short **)(&l1));
158                     if (sciErr.iErr)
159                     {
160                         Scierror(202, _("%s: Cannot get the data for argument %d.\n"), fname, 1);
161                         printError(&sciErr, 0);
162                         return 1;
163                     }
164                     plottype = buildMatplotType(MATPLOT_UShort, MATPLOT_FORTRAN, MATPLOT_RGBA_4444);
165                     break;
166                 case SCI_INT32 :
167                     sciErr = getMatrixOfInteger32(pvApiCtx, piAddr1, &m1, &n1, (int **)(&l1));
168                     if (sciErr.iErr)
169                     {
170                         Scierror(202, _("%s: Cannot get the data for argument %d.\n"), fname, 1);
171                         printError(&sciErr, 0);
172                         return 1;
173                     }
174                     plottype = buildMatplotType(MATPLOT_Int, MATPLOT_FORTRAN, MATPLOT_RGB);
175                     break;
176                 case SCI_UINT32 :
177                     sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddr1, &m1, &n1, (unsigned int **)(&l1));
178                     if (sciErr.iErr)
179                     {
180                         Scierror(202, _("%s: Cannot get the data for argument %d.\n"), fname, 1);
181                         printError(&sciErr, 0);
182                         return 1;
183                     }
184                     plottype = buildMatplotType(MATPLOT_UInt, MATPLOT_FORTRAN, MATPLOT_RGBA);
185                     break;
186                 default :
187                     Scierror(202, _("%s: Wrong type for argument %d: A real or integer expected.\n"), fname, 1);
188                     return 1;
189             }
190             break;
191         case sci_mlist :
192             if (isHypermatType(pvApiCtx, piAddr1))
193             {
194                 int htype = 0;
195                 int ndims = 0;
196                 int * dims = NULL;
197
198                 sciErr = getHypermatType(pvApiCtx, piAddr1, &htype);
199                 if (sciErr.iErr)
200                 {
201                     Scierror(202, _("%s: Cannot get the hypermatrix data type for argument %d.\n"), fname, 1);
202                     return 1;
203                 }
204
205                 if (htype == sci_ints)
206                 {
207                     sciErr = getHypermatOfIntegerPrecision(pvApiCtx, piAddr1, &precision);
208                     if (sciErr.iErr)
209                     {
210                         Scierror(202, _("%s: Cannot get the hypermatrix data type for argument %d.\n"), fname, 1);
211                         return 1;
212                     }
213
214                     if (precision != SCI_UINT8 && precision != SCI_INT8)
215                     {
216                         Scierror(202, _("%s: Wrong type for argument %d: A real or integer expected.\n"), fname, 1);
217                         return 1;
218                     }
219
220                     if (precision == SCI_UINT8)
221                     {
222                         sciErr = getHypermatOfUnsignedInteger8(pvApiCtx, piAddr1, &dims, &ndims, (unsigned char **)&l1);
223                     }
224                     else
225                     {
226                         sciErr = getHypermatOfInteger8(pvApiCtx, piAddr1, &dims, &ndims, (char **)&l1);
227                     }
228
229                     if (sciErr.iErr || ndims != 3 || (dims[2] != 1 && dims[2] != 3 && dims[2] != 4))
230                     {
231                         Scierror(202, _("%s: Wrong type for argument %d: A real or integer expected.\n"), fname, 1);
232                         return 1;
233                     }
234
235                     m1 = dims[0];
236                     n1 = dims[1];
237                     if (dims[2] == 1)
238                     {
239                         if (precision == SCI_INT8)
240                         {
241                             plottype = buildMatplotType(MATPLOT_HM1_Char, MATPLOT_FORTRAN, MATPLOT_GRAY);
242                         }
243                         else
244                         {
245                             plottype = buildMatplotType(MATPLOT_HM1_UChar, MATPLOT_FORTRAN, MATPLOT_GRAY);
246                         }
247                     }
248                     else if (dims[2] == 3)
249                     {
250                         if (precision == SCI_INT8)
251                         {
252                             plottype = buildMatplotType(MATPLOT_HM3_Char, MATPLOT_FORTRAN, MATPLOT_RGB);
253                         }
254                         else
255                         {
256                             plottype = buildMatplotType(MATPLOT_HM3_UChar, MATPLOT_FORTRAN, MATPLOT_RGB);
257                         }
258                     }
259                     else
260                     {
261                         if (precision == SCI_INT8)
262                         {
263                             plottype = buildMatplotType(MATPLOT_HM4_Char, MATPLOT_FORTRAN, MATPLOT_RGBA);
264                         }
265                         else
266                         {
267                             plottype = buildMatplotType(MATPLOT_HM4_UChar, MATPLOT_FORTRAN, MATPLOT_RGBA);
268                         }
269                     }
270                 }
271                 else if (htype == sci_matrix)
272                 {
273                     sciErr = getHypermatOfDouble(pvApiCtx, piAddr1, &dims, &ndims, (double **)&l1);
274                     if (sciErr.iErr || ndims != 3 || (dims[2] != 1 && dims[2] != 3 && dims[2] != 4))
275                     {
276                         Scierror(202, _("%s: Wrong type for argument %d: A real or integer expected.\n"), fname, 1);
277                         return 1;
278                     }
279
280                     m1 = dims[0];
281                     n1 = dims[1];
282                     if (dims[2] == 1)
283                     {
284                         plottype = buildMatplotType(MATPLOT_HM1_Double, MATPLOT_FORTRAN, MATPLOT_GRAY);
285                     }
286                     else if (dims[2] == 3)
287                     {
288                         plottype = buildMatplotType(MATPLOT_HM3_Double, MATPLOT_FORTRAN, MATPLOT_RGB);
289                     }
290                     else
291                     {
292                         plottype = buildMatplotType(MATPLOT_HM4_Double, MATPLOT_FORTRAN, MATPLOT_RGBA);
293                     }
294                 }
295                 else
296                 {
297                     Scierror(202, _("%s: Wrong type for argument %d: A real or integer expected.\n"), "data", 1);
298                     return 1;
299                 }
300             }
301             break;
302         default :
303             Scierror(202, _("%s: Wrong type for argument %d: A real or integer expected.\n"), fname, 1);
304             return 1;
305     }
306
307     GetStrf(pvApiCtx, fname, 2, opts, &strf);
308     GetRect(pvApiCtx, fname, 3, opts, &rect);
309     GetNax(pvApiCtx, 4, opts, &nax, &flagNax);
310
311     getOrCreateDefaultSubwin();
312
313     if (isDefStrf(strf))
314     {
315         strcpy(strfl, DEFSTRFN);
316
317         strf = strfl;
318         if (!isDefRect(rect))
319         {
320             strfl[1] = '7';
321         }
322
323         GetOptionalIntArg(pvApiCtx, fname, 5, "frameflag", &frame, 1, opts);
324         if (frame != &frame_def)
325         {
326             strfl[1] = (char)(*frame + 48);
327         }
328         GetOptionalIntArg(pvApiCtx, fname, 5, "axesflag", &axes, 1, opts);
329         if (axes != &axes_def)
330         {
331             strfl[2] = (char)(*axes + 48);
332         }
333     }
334
335     ObjmatplotImage((unsigned char *)(l1), &m1, &n1, strf, rect, nax, flagNax, plottype);
336
337     /* NG end */
338     AssignOutputVariable(pvApiCtx, 1) = 0;
339     ReturnArguments(pvApiCtx);
340     return 0;
341 }
342 /*--------------------------------------------------------------------------*/