matplot color fixed
[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     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             dims = pIn->getDimsArray();
86             if (pIn->getDims() > 3 || (dims[2] != 1 && dims[2] != 3 && dims[2] != 4))
87             {
88                 Scierror(999, _("%s: Wrong type for input argument #%d: A real or integer expected.\n"), "Matplot", 1);
89                 return types::Function::Error;
90             }
91
92             m1 = dims[0];
93             n1 = dims[1];
94             if (dims[2] == 1)
95             {
96                 plottype = buildMatplotType(MATPLOT_HM1_Double, MATPLOT_FORTRAN, MATPLOT_GRAY);
97             }
98             else if (dims[2] == 3)
99             {
100                 plottype = buildMatplotType(MATPLOT_HM3_Double, MATPLOT_FORTRAN, MATPLOT_RGB);
101             }
102             else
103             {
104                 plottype = buildMatplotType(MATPLOT_HM4_Double, MATPLOT_FORTRAN, MATPLOT_RGBA);
105             }
106         }
107         else
108         {
109             m1 = pIn->getRows();
110             n1 = pIn->getCols();
111             plottype = buildMatplotType(MATPLOT_Double, MATPLOT_FORTRAN, MATPLOT_INDEX);
112         }
113     }
114     else if (in[0]->isInt8())
115     {
116         types::Int8 *pIn = in[0]->getAs<types::Int8>();
117         l1 = (void*) pIn->get();
118         if (pIn->getDims() > 2)
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_HM3_Char, MATPLOT_FORTRAN, MATPLOT_RGB);
136             }
137             else
138             {
139                 plottype = buildMatplotType(MATPLOT_HM4_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_RGB_332);
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             dims = pIn->getDimsArray();
156             if (pIn->getDims() > 3 || (dims[2] != 1 && dims[2] != 3 && dims[2] != 4))
157             {
158                 Scierror(999, _("%s: Wrong type for input argument #%d: A real or integer expected.\n"), "Matplot", 1);
159                 return types::Function::Error;
160             }
161
162             m1 = dims[0];
163             n1 = dims[1];
164             if (dims[2] == 1)
165             {
166                 plottype = buildMatplotType(MATPLOT_HM1_UChar, MATPLOT_FORTRAN, MATPLOT_GRAY);
167             }
168             else if (dims[2] == 3)
169             {
170                 plottype = buildMatplotType(MATPLOT_HM3_UChar, MATPLOT_FORTRAN, MATPLOT_RGB);
171             }
172             else
173             {
174                 plottype = buildMatplotType(MATPLOT_HM4_UChar, MATPLOT_FORTRAN, MATPLOT_RGBA);
175             }
176         }
177         else
178         {
179             m1 = pIn->getRows();
180             n1 = pIn->getCols();
181             plottype = buildMatplotType(MATPLOT_UChar, MATPLOT_FORTRAN, MATPLOT_GRAY);
182         }
183     }
184     else if (in[0]->isInt16())
185     {
186         types::Int16 *pIn = in[0]->getAs<types::Int16>();
187         l1 = (void*) pIn->get();
188         m1 = pIn->getRows();
189         n1 = pIn->getCols();
190         plottype = buildMatplotType(MATPLOT_Short, MATPLOT_FORTRAN, MATPLOT_RGB_444);
191     }
192     else if (in[0]->isUInt16())
193     {
194         types::UInt16 *pIn = in[0]->getAs<types::UInt16>();
195         l1 = (void*) pIn->get();
196         m1 = pIn->getRows();
197         n1 = pIn->getCols();
198         plottype = buildMatplotType(MATPLOT_UShort, MATPLOT_FORTRAN, MATPLOT_RGBA_4444);
199     }
200     else if ((in[0]->isInt32()) || (in[0]->isInt64()))
201     {
202         types::Int32 *pIn = in[0]->getAs<types::Int32>();
203         l1 = (void*) pIn->get();
204         m1 = pIn->getRows();
205         n1 = pIn->getCols();
206         plottype = buildMatplotType(MATPLOT_Int, MATPLOT_FORTRAN, MATPLOT_RGB);
207     }
208     else if ((in[0]->isUInt32()) || (in[0]->isUInt64()))
209     {
210         types::UInt32 *pIn = in[0]->getAs<types::UInt32>();
211         l1 = (void*) pIn->get();
212         m1 = pIn->getRows();
213         n1 = pIn->getCols();
214         plottype = buildMatplotType(MATPLOT_UInt, MATPLOT_FORTRAN, MATPLOT_RGBA);
215     }
216
217     if (in.size() > 1)
218     {
219         if (in[1]->isString() == false)
220         {
221             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), "Matplot1", 2);
222             return types::Function::Error;
223         }
224
225         strf =  wide_string_to_UTF8(in[1]->getAs<types::String>()->get(0));
226         bFREE = true;
227         if (in.size() > 2)
228         {
229             if (in[2]->isDouble() == false)
230             {
231                 if (bFREE)
232                 {
233                     FREE(strf);
234                 }
235                 Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), "Matplot1", 3);
236                 return types::Function::Error;
237             }
238
239             rect =  in[2]->getAs<types::Double>()->get();
240             if (in.size() > 3)
241             {
242                 if (in[3]->isDouble() == false)
243                 {
244                     if (bFREE)
245                     {
246                         FREE(strf);
247                     }
248                     Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), "Matplot1", 4);
249                     return types::Function::Error;
250                 }
251
252                 types::Double* pDbl = in[3]->getAs<types::Double>();
253                 double* pdbl = pDbl->get();
254                 int iSize = pDbl->getSize();
255                 nax = new int[iSize];
256                 for (int i = 0; i < iSize; i++)
257                 {
258                     nax[i] = (int)pdbl[i];
259                 }
260
261                 flagNax = TRUE;
262             }
263         }
264     }
265
266     if (opt.size() > 4)
267     {
268         if (bFREE)
269         {
270             FREE(strf);
271         }
272
273         Scierror(999, _("%s: Wrong number of input argument(s): %d to %d expected.\n"), "Matplot", 1, 5);
274         return types::Function::Error;
275     }
276
277     // get optional argument if necessary
278     for (int i = 0; i < opt.size(); i++)
279     {
280         if (opt[i].first == L"strf")
281         {
282             if (opt[i].second->isString() == false)
283             {
284                 if (bFREE)
285                 {
286                     FREE(strf);
287                 }
288
289                 if (nax)
290                 {
291                     delete[] nax;
292                 }
293
294                 if (frameflag)
295                 {
296                     delete[] frameflag;
297                 }
298
299                 if (axesflag)
300                 {
301                     delete[] axesflag;
302                 }
303                 Scierror(999, _("%s: Wrong type for input argument #%ls: A string expected.\n"), "Matplot1", opt[i].first.c_str());
304                 return types::Function::Error;
305             }
306
307             if (strf)
308             {
309                 continue;
310             }
311
312             strf =  wide_string_to_UTF8(opt[i].second->getAs<types::String>()->get(0));
313             bFREE = true;
314         }
315         else
316         {
317             if (opt[i].second->isDouble() == false)
318             {
319                 if (bFREE)
320                 {
321                     FREE(strf);
322                 }
323
324                 if (nax)
325                 {
326                     delete[] nax;
327                 }
328
329                 if (frameflag)
330                 {
331                     delete[] frameflag;
332                 }
333
334                 if (axesflag)
335                 {
336                     delete[] axesflag;
337                 }
338                 Scierror(999, _("%s: Wrong type for input argument #%ls: A matrix expected.\n"), "Matplot1", opt[i].first.c_str());
339                 return types::Function::Error;
340             }
341
342             types::Double* pDbl = opt[i].second->getAs<types::Double>();
343             double* pdbl = pDbl->get();
344             int iSize = pDbl->getSize();
345
346             if (opt[i].first == L"rect" && rect == NULL)
347             {
348                 rect = pdbl;
349             }
350             else if (opt[i].first == L"nax" && nax == NULL)
351             {
352                 nax = new int[iSize];
353                 for (int i = 0; i < iSize; i++)
354                 {
355                     nax[i] = (int)pdbl[i];
356                 }
357                 flagNax = TRUE;
358             }
359             else if (opt[i].first == L"frameflag" && frameflag == NULL)
360             {
361                 frameflag = new int[iSize];
362                 for (int i = 0; i < iSize; i++)
363                 {
364                     frameflag[i] = (int)pdbl[i];
365                 }
366             }
367             else if (opt[i].first == L"axesflag" && axesflag == NULL)
368             {
369                 axesflag = new int[iSize];
370                 for (int i = 0; i < iSize; i++)
371                 {
372                     axesflag[i] = (int)pdbl[i];
373                 }
374             }
375         }
376     }
377
378     getOrCreateDefaultSubwin();
379
380     if (strf == NULL)
381     {
382         reinitDefStrfN();
383
384         strcpy(strfl, DEFSTRFN);
385         strf = strfl;
386
387         if (!isDefRect(rect))
388         {
389             strfl[1] = '7';
390         }
391
392         if (frameflag != &frame_def)
393         {
394             strfl[1] = (char)(*frame + 48);
395         }
396
397         if (axesflag != &axes_def)
398         {
399             strfl[2] = (char)(*axes + 48);
400         }
401     }
402
403     ObjmatplotImage(l1, &m1, &n1, strf, rect, nax, flagNax, plottype);
404
405     if (bFREE)
406     {
407         FREE(strf);
408     }
409
410     if (nax)
411     {
412         delete[] nax;
413     }
414
415     if (frameflag)
416     {
417         delete[] frameflag;
418     }
419
420     if (axesflag)
421     {
422         delete[] axesflag;
423     }
424
425     return types::Function::OK;
426 }
427 /*--------------------------------------------------------------------------*/