modules using java in nwni mode fixed.
[scilab.git] / scilab / modules / graphics / sci_gateway / cpp / sci_matplot1.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) 2012 - DIGITEO - Manuel Juliachs
6  * Copyright (C) 2014 - Scilab Enterprises - Anais AUBERT
7  *
8  * Copyright (C) 2012 - 2016 - Scilab Enterprises
9  *
10  * This file is hereby licensed under the terms of the GNU GPL v2.0,
11  * pursuant to article 5.3.4 of the CeCILL v.2.1.
12  * This file was originally licensed under the terms of the CeCILL v2.1,
13  * and continues to be available under such terms.
14  * For more information, see the COPYING file which you should have received
15  * along with this program.
16  *
17  */
18
19 /*------------------------------------------------------------------------*/
20 /* file: sci_matplot1.c                                                   */
21 /* desc : interface for matplot1 routine                                  */
22 /*------------------------------------------------------------------------*/
23
24 #include "graphics_gw.hxx"
25 #include "function.hxx"
26 #include "double.hxx"
27 #include "string.hxx"
28 #include "graphichandle.hxx"
29 #include "overload.hxx"
30 #include "int.hxx"
31
32 extern "C"
33 {
34 #include <string.h>
35 #include "gw_graphics.h"
36 #include "GetCommandArg.h"
37 #include "DefaultCommandArg.h"
38 #include "BuildObjects.h"
39 #include "sciCall.h"
40 #include "api_scilab.h"
41 #include "localization.h"
42 #include "Scierror.h"
43 #include "Matplot.h"
44 }
45
46 /*--------------------------------------------------------------------------*/
47 types::Function::ReturnValue sci_matplot1(types::typed_list &in, int _iRetCount, types::typed_list &out)
48 {
49     int m1 = 0, n1 = 0, m2 = 0, n2 = 0;
50     int* piAddr1 = NULL;
51     int* piAddr2 = NULL;
52     int plottype = -1;
53     int *dims = NULL;
54
55     double* l1 = NULL;
56     double* l2 = NULL;
57
58
59     if (in.size() < 1)
60     {
61         return Overload::call(L"%_Matplot1", in, _iRetCount, out);
62     }
63     else if (in.size() != 2)
64     {
65         Scierror(999, _("%s: Wrong number of input argument(s): %d expected.\n"), "Matplot1", 2);
66         return types::Function::Error;
67     }
68
69     if (in[0]->isDouble())
70     {
71         types::Double *pDbl = in[0]->getAs<types::Double>();
72         l1 = pDbl->get();
73         if (pDbl->getDims() > 2)
74         {
75             dims = pDbl->getDimsArray();
76             if (pDbl->getDims() > 3 || (dims[2] != 1 && dims[2] != 3 && dims[2] != 4))
77             {
78                 Scierror(999, _("%s: Wrong type for input argument #%d: A real or integer expected.\n"), "Matplot1", 1);
79                 return types::Function::Error;
80             }
81
82             m1 = dims[0];
83             n1 = dims[1];
84             if (dims[2] == 1)
85             {
86                 plottype = buildMatplotType(MATPLOT_HM1_Double, MATPLOT_FORTRAN, MATPLOT_GRAY);
87             }
88             else if (dims[2] == 3)
89             {
90                 plottype = buildMatplotType(MATPLOT_HM3_Double, MATPLOT_FORTRAN, MATPLOT_RGB);
91             }
92             else
93             {
94                 plottype = buildMatplotType(MATPLOT_HM4_Double, MATPLOT_FORTRAN, MATPLOT_RGBA);
95             }
96         }
97         else
98         {
99             m1 = pDbl->getRows();
100             n1 = pDbl->getCols();
101             plottype = buildMatplotType(MATPLOT_Double, MATPLOT_FORTRAN, MATPLOT_INDEX);
102         }
103     }
104     else if (in[0]->isInt8())
105     {
106         types::Int8 *pDbl = in[0]->getAs<types::Int8>();
107         l1 = (double *)pDbl->get();
108         if (pDbl->getDims() > 2)
109         {
110
111             dims = pDbl->getDimsArray();
112             if (pDbl->getDims() > 3 || (dims[2] != 1 && dims[2] != 3 && dims[2] != 4))
113             {
114                 Scierror(999, _("%s: Wrong type for input argument #%d: A real or integer expected.\n"), "Matplot1", 1);
115                 return types::Function::Error;
116             }
117
118             m1 = dims[0];
119             n1 = dims[1];
120             if (dims[2] == 1)
121             {
122                 plottype = buildMatplotType(MATPLOT_HM1_Char, MATPLOT_FORTRAN, MATPLOT_GRAY);
123             }
124             else if (dims[2] == 3)
125             {
126                 plottype = buildMatplotType(MATPLOT_HM1_Char, MATPLOT_FORTRAN, MATPLOT_RGB);
127             }
128             else
129             {
130                 plottype = buildMatplotType(MATPLOT_HM1_Char, MATPLOT_FORTRAN, MATPLOT_RGBA);
131             }
132         }
133         else
134         {
135             m1 = pDbl->getRows();
136             n1 = pDbl->getCols();
137             plottype = buildMatplotType(MATPLOT_Char, MATPLOT_FORTRAN, MATPLOT_INDEX);
138         }
139     }
140     else if (in[0]->isUInt8())
141     {
142         types::UInt8 *pDbl = in[0]->getAs<types::UInt8>();
143         l1 = (double *)pDbl->get();
144         if (pDbl->getDims() > 2)
145         {
146
147             dims = pDbl->getDimsArray();
148             if (pDbl->getDims() > 3 || (dims[2] != 1 && dims[2] != 3 && dims[2] != 4))
149             {
150                 Scierror(999, _("%s: Wrong type for input argument #%d: A real or integer expected.\n"), "Matplot1", 1);
151                 return types::Function::Error;
152             }
153
154             m1 = dims[0];
155             n1 = dims[1];
156             if (dims[2] == 1)
157             {
158                 plottype = buildMatplotType(MATPLOT_HM1_UChar, MATPLOT_FORTRAN, MATPLOT_GRAY);
159             }
160             else if (dims[2] == 3)
161             {
162                 plottype = buildMatplotType(MATPLOT_HM1_UChar, MATPLOT_FORTRAN, MATPLOT_RGB);
163             }
164             else
165             {
166                 plottype = buildMatplotType(MATPLOT_HM1_UChar, MATPLOT_FORTRAN, MATPLOT_RGBA);
167             }
168         }
169         else
170         {
171             m1 = pDbl->getRows();
172             n1 = pDbl->getCols();
173             plottype = buildMatplotType(MATPLOT_UChar, MATPLOT_FORTRAN, MATPLOT_INDEX);
174         }
175     }
176     else if (in[0]->isInt16())
177     {
178         types::Int16 *pDbl = in[0]->getAs<types::Int16>();
179         l1 = (double *)pDbl->get();
180         m1 = pDbl->getRows();
181         n1 = pDbl->getCols();
182         plottype = buildMatplotType(MATPLOT_Short, MATPLOT_FORTRAN, MATPLOT_INDEX);
183     }
184     else if (in[0]->isUInt16())
185     {
186         types::UInt16 *pDbl = in[0]->getAs<types::UInt16>();
187         l1 = (double *)pDbl->get();
188         m1 = pDbl->getRows();
189         n1 = pDbl->getCols();
190         plottype = buildMatplotType(MATPLOT_UShort, MATPLOT_FORTRAN, MATPLOT_INDEX);
191     }
192     else if ((in[0]->isInt32()) || (in[0]->isInt64()))
193     {
194         types::Int32 *pDbl = in[0]->getAs<types::Int32>();
195         l1 = (double *)pDbl->get();
196         m1 = pDbl->getRows();
197         n1 = pDbl->getCols();
198         plottype = buildMatplotType(MATPLOT_Int, MATPLOT_FORTRAN, MATPLOT_INDEX);
199     }
200     else if ((in[0]->isUInt32()) || (in[0]->isUInt64()))
201     {
202         types::UInt32 *pDbl = in[0]->getAs<types::UInt32>();
203         l1 = (double *)pDbl->get();
204         m1 = pDbl->getRows();
205         n1 = pDbl->getCols();
206         plottype = buildMatplotType(MATPLOT_UInt, MATPLOT_FORTRAN, MATPLOT_INDEX);
207     }
208
209     if (!(in[1]->isDouble()))
210     {
211         Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), "Matplot1", 2);
212         return types::Function::Error;
213
214     }
215     types::Double *pDbl1 = in[1]->getAs<types::Double>();
216     if (pDbl1->getDims() > 2)
217     {
218         Scierror(999, _("%s: Wrong size for input argument #%d: Row vector expected.\n"), "Matplot1", 2);
219         return types::Function::Error;
220     }
221
222     l2 = pDbl1->get();
223     m2 = pDbl1->getRows();
224     n2 = pDbl1->getCols();
225
226     //CheckLength
227     if (m2 * n2 != 4)
228     {
229         Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), "Matplot1", 2, m2 * n2);
230         return types::Function::Error;
231     }
232
233     getOrCreateDefaultSubwin();
234
235     /* NG beg */
236     Objmatplot1 ((l1), &m1, &n1, (l2), plottype);
237
238
239     return types::Function::OK;
240 }
241 /*--------------------------------------------------------------------------*/