Limit sparse/Eigen include propagation
[scilab.git] / scilab / modules / graphics / sci_gateway / cpp / sci_matplot.cpp
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) 2014 - Scilab Enterprises - Anais AUBERT
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_matplot.h                                                    */
17 /* desc : interface for matplot routine                                   */
18 /*------------------------------------------------------------------------*/
19
20 #include "graphics_gw.hxx"
21 #include "function.hxx"
22 #include "double.hxx"
23 #include "string.hxx"
24 #include "graphichandle.hxx"
25 #include "overload.hxx"
26 #include "execvisitor.hxx"
27 #include "int.hxx"
28
29 extern "C"
30 {
31 #include <string.h>
32 #include "gw_graphics.h"
33 #include "GetCommandArg.h"
34 #include "DefaultCommandArg.h"
35 #include "BuildObjects.h"
36 #include "sciCall.h"
37 #include "api_scilab.h"
38 #include "localization.h"
39 #include "Scierror.h"
40 #include "Matplot.h"
41 }
42
43 /*--------------------------------------------------------------------------*/
44 types::Function::ReturnValue sci_matplot(types::typed_list &in, types::optional_list &opt, int _iRetCount, types::typed_list &out)
45 {
46     int m1 = 0;
47     int n1 = 0;
48     int *dims = NULL;
49     int frame_def = 8;
50     int *frame = &frame_def;
51     int axes_def = 1;
52     int *axes = &axes_def;
53     int *frameflag = NULL;
54     int *axesflag  = NULL;
55
56     char* strf      = NULL ;
57     char strfl[4];
58     double* rect    = NULL ;
59     int* nax        = NULL ;
60     BOOL flagNax    = FALSE;
61
62     void* l1 = NULL;
63     int plottype = -1;
64
65     bool bFREE = false;
66
67     if (in.size() < 1)
68     {
69         ast::ExecVisitor exec;
70         return Overload::call(L"%_Matplot", in, _iRetCount, out, &exec);
71
72     }
73     else if (in.size() > 5)
74     {
75         Scierror(999, _("%s: Wrong number of input argument(s): %d to %d expected.\n"), "Matplot", 1, 5);
76         return types::Function::Error;
77     }
78
79     if (in[0]->isDouble())
80     {
81         types::Double *pIn = in[0]->getAs<types::Double>();
82         l1 = (void*) pIn->get();
83         if (pIn->getDims() > 2)
84         {
85
86             dims = pIn->getDimsArray();
87             if (pIn->getDims() > 3 || (dims[2] != 1 && dims[2] != 3 && dims[2] != 4))
88             {
89                 Scierror(999, _("%s: Wrong type for input argument #%d: A real or integer expected.\n"), "Matplot", 1);
90                 return types::Function::Error;
91             }
92
93             m1 = dims[0];
94             n1 = dims[1];
95             if (dims[2] == 1)
96             {
97                 plottype = buildMatplotType(MATPLOT_HM1_Double, MATPLOT_FORTRAN, MATPLOT_GRAY);
98             }
99             else if (dims[2] == 3)
100             {
101                 plottype = buildMatplotType(MATPLOT_HM3_Double, MATPLOT_FORTRAN, MATPLOT_RGB);
102             }
103             else
104             {
105                 plottype = buildMatplotType(MATPLOT_HM4_Double, MATPLOT_FORTRAN, MATPLOT_RGBA);
106             }
107         }
108         else
109         {
110             m1 = pIn->getRows();
111             n1 = pIn->getCols();
112             plottype = buildMatplotType(MATPLOT_Double, MATPLOT_FORTRAN, MATPLOT_INDEX);
113         }
114     }
115     else if (in[0]->isInt8())
116     {
117         types::Int8 *pIn = in[0]->getAs<types::Int8>();
118         l1 = (void*) pIn->get();
119         if (pIn->getDims() > 2)
120         {
121
122             dims = pIn->getDimsArray();
123             if (pIn->getDims() > 3 || (dims[2] != 1 && dims[2] != 3 && dims[2] != 4))
124             {
125                 Scierror(999, _("%s: Wrong type for input argument #%d: A real or integer expected.\n"), "Matplot", 1);
126                 return types::Function::Error;
127             }
128
129             m1 = dims[0];
130             n1 = dims[1];
131             if (dims[2] == 1)
132             {
133                 plottype = buildMatplotType(MATPLOT_HM1_Char, MATPLOT_FORTRAN, MATPLOT_GRAY);
134             }
135             else if (dims[2] == 3)
136             {
137                 plottype = buildMatplotType(MATPLOT_HM1_Char, MATPLOT_FORTRAN, MATPLOT_RGB);
138             }
139             else
140             {
141                 plottype = buildMatplotType(MATPLOT_HM1_Char, MATPLOT_FORTRAN, MATPLOT_RGBA);
142             }
143         }
144         else
145         {
146             m1 = pIn->getRows();
147             n1 = pIn->getCols();
148             plottype = buildMatplotType(MATPLOT_Char, MATPLOT_FORTRAN, MATPLOT_INDEX);
149         }
150     }
151     else if (in[0]->isUInt8())
152     {
153         types::UInt8 *pIn = in[0]->getAs<types::UInt8>();
154         l1 = (void*) pIn->get();
155         if (pIn->getDims() > 2)
156         {
157
158             dims = pIn->getDimsArray();
159             if (pIn->getDims() > 3 || (dims[2] != 1 && dims[2] != 3 && dims[2] != 4))
160             {
161                 Scierror(999, _("%s: Wrong type for input argument #%d: A real or integer expected.\n"), "Matplot", 1);
162                 return types::Function::Error;
163             }
164
165             m1 = dims[0];
166             n1 = dims[1];
167             if (dims[2] == 1)
168             {
169                 plottype = buildMatplotType(MATPLOT_HM1_UChar, MATPLOT_FORTRAN, MATPLOT_GRAY);
170             }
171             else if (dims[2] == 3)
172             {
173                 plottype = buildMatplotType(MATPLOT_HM1_UChar, MATPLOT_FORTRAN, MATPLOT_RGB);
174             }
175             else
176             {
177                 plottype = buildMatplotType(MATPLOT_HM1_UChar, MATPLOT_FORTRAN, MATPLOT_RGBA);
178             }
179         }
180         else
181         {
182             m1 = pIn->getRows();
183             n1 = pIn->getCols();
184             plottype = buildMatplotType(MATPLOT_UChar, MATPLOT_FORTRAN, MATPLOT_INDEX);
185         }
186     }
187     else if (in[0]->isInt16())
188     {
189         types::Int16 *pIn = in[0]->getAs<types::Int16>();
190         l1 = (void*) pIn->get();
191         m1 = pIn->getRows();
192         n1 = pIn->getCols();
193         plottype = buildMatplotType(MATPLOT_Short, MATPLOT_FORTRAN, MATPLOT_INDEX);
194     }
195     else if (in[0]->isUInt16())
196     {
197         types::UInt16 *pIn = in[0]->getAs<types::UInt16>();
198         l1 = (void*) pIn->get();
199         m1 = pIn->getRows();
200         n1 = pIn->getCols();
201         plottype = buildMatplotType(MATPLOT_UShort, MATPLOT_FORTRAN, MATPLOT_INDEX);
202     }
203     else if ((in[0]->isInt32()) || (in[0]->isInt64()))
204     {
205         types::Int32 *pIn = in[0]->getAs<types::Int32>();
206         l1 = (void*) pIn->get();
207         m1 = pIn->getRows();
208         n1 = pIn->getCols();
209         plottype = buildMatplotType(MATPLOT_Int, MATPLOT_FORTRAN, MATPLOT_INDEX);
210     }
211     else if ((in[0]->isUInt32()) || (in[0]->isUInt64()))
212     {
213         types::UInt32 *pIn = in[0]->getAs<types::UInt32>();
214         l1 = (void*) pIn->get();
215         m1 = pIn->getRows();
216         n1 = pIn->getCols();
217         plottype = buildMatplotType(MATPLOT_UInt, MATPLOT_FORTRAN, MATPLOT_INDEX);
218     }
219
220     if (in.size() > 1)
221     {
222         if (in[1]->isString() == false)
223         {
224             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), "Matplot1", 2);
225             return types::Function::Error;
226
227         }
228         strf =  wide_string_to_UTF8(in[1]->getAs<types::String>()->get(0));
229         bFREE = true;
230         if (in.size() > 2)
231         {
232             if (in[2]->isDouble() == false)
233             {
234                 Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), "Matplot1", 3);
235                 return types::Function::Error;
236
237             }
238
239             rect =  in[2]->getAs<types::Double>()->get();
240             if (in.size() > 3)
241             {
242                 if (in[3]->isDouble() == false)
243                 {
244                     Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), "Matplot1", 4);
245                     return types::Function::Error;
246
247                 }
248
249                 types::Double* pDbl = in[3]->getAs<types::Double>();
250                 double* pdbl = pDbl->get();
251                 int iSize = pDbl->getSize();
252                 nax = new int[iSize];
253                 for (int i = 0; i < iSize; i++)
254                 {
255                     nax[i] = (int)pdbl[i];
256                 }
257
258                 flagNax = TRUE;
259             }
260         }
261     }
262
263     if (opt.size() > 4)
264     {
265         Scierror(999, _("%s: Wrong number of input argument(s): %d to %d expected.\n"), "Matplot", 1, 5);
266         return types::Function::Error;
267     }
268
269     // get optional argument if necessary
270     for (int i = 0; i < opt.size(); i++)
271     {
272         if (opt[i].first == L"strf")
273         {
274             if (opt[i].second->isString() == false)
275             {
276                 Scierror(999, _("%s: Wrong type for input argument #%ls: A string expected.\n"), "Matplot1", opt[i].first.c_str());
277                 return types::Function::Error;
278             }
279
280             if (strf)
281             {
282                 continue;
283             }
284
285             strf =  wide_string_to_UTF8(opt[i].second->getAs<types::String>()->get(0));
286             bFREE = true;
287         }
288         else
289         {
290             if (opt[i].second->isDouble() == false)
291             {
292                 Scierror(999, _("%s: Wrong type for input argument #%ls: A matrix expected.\n"), "Matplot1", opt[i].first.c_str());
293                 return types::Function::Error;
294             }
295
296             types::Double* pDbl = opt[i].second->getAs<types::Double>();
297             double* pdbl = pDbl->get();
298             int iSize = pDbl->getSize();
299
300             if (opt[i].first == L"rect" && rect == NULL)
301             {
302                 rect = pdbl;
303             }
304             else if (opt[i].first == L"nax" && nax == NULL)
305             {
306                 nax = new int[iSize];
307                 for (int i = 0; i < iSize; i++)
308                 {
309                     nax[i] = (int)pdbl[i];
310                 }
311                 flagNax = TRUE;
312             }
313             else if (opt[i].first == L"frameflag" && frameflag == NULL)
314             {
315                 frameflag = new int[iSize];
316                 for (int i = 0; i < iSize; i++)
317                 {
318                     frameflag[i] = (int)pdbl[i];
319                 }
320             }
321             else if (opt[i].first == L"axesflag" && axesflag == NULL)
322             {
323                 axesflag = new int[iSize];
324                 for (int i = 0; i < iSize; i++)
325                 {
326                     axesflag[i] = (int)pdbl[i];
327                 }
328             }
329         }
330     }
331
332     getOrCreateDefaultSubwin();
333
334     if (strf == NULL)
335     {
336         reinitDefStrfN();
337
338         strcpy(strfl, DEFSTRFN);
339         strf = strfl;
340
341         if (!isDefRect(rect))
342         {
343             strfl[1] = '7';
344         }
345
346         if (frameflag != &frame_def)
347         {
348             strfl[1] = (char)(*frame + 48);
349         }
350
351         if (axesflag != &axes_def)
352         {
353             strfl[2] = (char)(*axes + 48);
354         }
355     }
356
357     ObjmatplotImage(l1, &m1, &n1, strf, rect, nax, flagNax, plottype);
358
359     if (bFREE)
360     {
361         FREE(strf);
362     }
363
364     if (nax)
365     {
366         delete[] nax;
367     }
368
369     if (frameflag)
370     {
371         delete[] frameflag;
372     }
373
374     if (axesflag)
375     {
376         delete[] axesflag;
377     }
378
379     return types::Function::OK;
380 }
381 /*--------------------------------------------------------------------------*/