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