463225d2f6035a08f6ad05cf8ff3e8e2be32f5ed
[scilab.git] / scilab / modules / graphic_objects / src / cpp / NgonGridData.cpp
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2010-2012 - DIGITEO - Manuel Juliachs
4  *
5  *  This file must be used under the terms of the CeCILL.
6  *  This source file is licensed as described in the file COPYING, which
7  *  you should have received as part of this distribution.  The terms
8  *  are also available at
9  *  http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
10  *
11  */
12
13 #include "NgonGridData.hxx"
14
15 extern "C" {
16 #include <string.h>
17 #include <stdlib.h>
18
19 #include "graphicObjectProperties.h"
20 }
21
22 NgonGridData::NgonGridData(void)
23 {
24     numGons = 0;
25
26     /* Grid: must be set to 4 */
27     numVerticesPerGon = 4;
28
29     xCoordinates = NULL;
30     yCoordinates = NULL;
31     zCoordinates = NULL;
32
33     xSize = 0;
34     ySize = 0;
35
36     xDimensions[0] = 0;
37     xDimensions[1] = 0;
38
39     yDimensions[0] = 0;
40     yDimensions[1] = 0;
41
42     /* Set to 0 as a default */
43     zCoordinatesShift = 0.0;
44 }
45
46 NgonGridData::~NgonGridData(void)
47 {
48     if (xSize > 0)
49     {
50         delete [] xCoordinates;
51     }
52
53     if (ySize > 0)
54     {
55         delete [] yCoordinates;
56     }
57
58     if (xSize > 0 && ySize > 0)
59     {
60         delete [] zCoordinates;
61     }
62 }
63
64 int NgonGridData::getPropertyFromName(int propertyName)
65 {
66     switch (propertyName)
67     {
68         case __GO_DATA_MODEL_NUM_X__ :
69             return NUM_X;
70         case __GO_DATA_MODEL_NUM_Y__ :
71             return NUM_Y;
72         case __GO_DATA_MODEL_NUM_Z__ :
73             return NUM_Z;
74         case __GO_DATA_MODEL_X_DIMENSIONS__ :
75             return X_DIMENSIONS;
76         case __GO_DATA_MODEL_Y_DIMENSIONS__ :
77             return Y_DIMENSIONS;
78         case __GO_DATA_MODEL_GRID_SIZE__ :
79             return GRID_SIZE;
80         case __GO_DATA_MODEL_X__ :
81             return X_COORDINATES;
82         case __GO_DATA_MODEL_Y__ :
83             return Y_COORDINATES;
84         case __GO_DATA_MODEL_Z__ :
85             return Z_COORDINATES;
86         case __GO_DATA_MODEL_Z_COORDINATES_SHIFT__ :
87             return Z_COORDINATES_SHIFT;
88         default :
89             return NgonData::getPropertyFromName(propertyName);
90     }
91
92 }
93
94 int NgonGridData::setDataProperty(int property, void const* value, int numElements)
95 {
96     if (property == GRID_SIZE)
97     {
98         return setGridSize((int const*) value);
99     }
100     else if (property == X_COORDINATES)
101     {
102         setDataX((double const*) value, numElements);
103     }
104     else if (property == Y_COORDINATES)
105     {
106         setDataY((double const*) value, numElements);
107     }
108     else if (property == Z_COORDINATES)
109     {
110         setDataZ((double const*) value, numElements);
111     }
112     else if (property == Z_COORDINATES_SHIFT)
113     {
114         setZCoordinatesShift((double const*) value);
115     }
116     else
117     {
118         return NgonData::setDataProperty(property, value, numElements);
119     }
120
121     return 1;
122 }
123
124 void NgonGridData::getDataProperty(int property, void **_pvData)
125 {
126     if (property == NUM_X)
127     {
128         ((int *) *_pvData)[0] = getNumX();
129     }
130     else if (property == NUM_Y)
131     {
132         ((int *) *_pvData)[0] = getNumY();
133     }
134     else if (property == NUM_Z)
135     {
136         ((int *) *_pvData)[0] = getNumZ();
137     }
138     else if (property == X_DIMENSIONS)
139     {
140         *_pvData = getXDimensions();
141     }
142     else if (property == Y_DIMENSIONS)
143     {
144         *_pvData = getYDimensions();
145     }
146     else if (property == X_COORDINATES)
147     {
148         *_pvData = getDataX();
149     }
150     else if (property == Y_COORDINATES)
151     {
152         *_pvData = getDataY();
153     }
154     else if (property == Z_COORDINATES)
155     {
156         *_pvData = getDataZ();
157     }
158     else if (property == Z_COORDINATES_SHIFT)
159     {
160         ((double *) *_pvData)[0] = getZCoordinatesShift();
161     }
162     else
163     {
164         NgonData::getDataProperty(property, _pvData);
165     }
166
167 }
168
169 int NgonGridData::setGridSize(int const* gridSize)
170 {
171     int newXSize = 0;
172     int newYSize = 0;
173     int xModified = 0;
174     int yModified = 0;
175     int zModified = 0;
176     int result = 0;
177
178     double* newXCoordinates = NULL;
179     double* newYCoordinates = NULL;
180     double* newZCoordinates = NULL;
181
182     result = 1;
183
184     xModified = 0;
185     yModified = 0;
186     zModified = 0;
187
188     if ((gridSize[0] != 1) && (gridSize[1] != 1))
189     {
190         return 0;
191     }
192
193     if ((gridSize[2] != 1) && (gridSize[3] != 1))
194     {
195         return 0;
196     }
197
198     newXSize = gridSize[0] * gridSize[1];
199     newYSize = gridSize[2] * gridSize[3];
200
201
202     if (newXSize != xSize)
203     {
204         xModified = 1;
205
206         try
207         {
208             newXCoordinates = new double[newXSize];
209         }
210         catch (const std::exception& e)
211         {
212             e.what();
213             result = 0;
214         }
215     }
216
217     if (newYSize != ySize)
218     {
219         yModified = 1;
220
221         try
222         {
223             newYCoordinates = new double[newYSize];
224         }
225         catch (const std::exception& e)
226         {
227             e.what();
228             result = 0;
229         }
230     }
231
232     if (newXSize*newYSize != xSize * ySize)
233     {
234         zModified = 1;
235
236         try
237         {
238             newZCoordinates = new double[newXSize * newYSize];
239         }
240         catch (const std::exception& e)
241         {
242             e.what();
243             result = 0;
244         }
245     }
246
247     if (result)
248     {
249         if (xModified)
250         {
251             if (xSize > 0)
252             {
253                 delete [] xCoordinates;
254             }
255
256             xCoordinates = newXCoordinates;
257             xSize = newXSize;
258         }
259
260         xDimensions[0] = gridSize[0];
261         xDimensions[1] = gridSize[1];
262
263         if (yModified)
264         {
265             if (ySize > 0)
266             {
267                 delete [] yCoordinates;
268             }
269
270             yCoordinates = newYCoordinates;
271             ySize = newYSize;
272         }
273
274         yDimensions[0] = gridSize[2];
275         yDimensions[1] = gridSize[3];
276
277         if (zModified)
278         {
279             if (xSize * ySize > 0)
280             {
281                 delete [] zCoordinates;
282             }
283
284             zCoordinates = newZCoordinates;
285
286             numGons = (xSize - 1) * (ySize - 1);
287         }
288
289     }
290     else
291     {
292         /* Failed allocation(s) */
293
294         if (xModified && (newXCoordinates != NULL))
295         {
296             delete [] newXCoordinates;
297         }
298
299         if (yModified && (newYCoordinates != NULL))
300         {
301             delete [] newYCoordinates;
302         }
303
304         if (zModified && (newZCoordinates != NULL))
305         {
306             delete [] newZCoordinates;
307         }
308
309     }
310
311     return result;
312 }
313
314 int NgonGridData::getNumX(void)
315 {
316     return xSize;
317 }
318
319 int NgonGridData::getNumY(void)
320 {
321     return ySize;
322 }
323
324 int NgonGridData::getNumZ(void)
325 {
326     return xSize * ySize;
327 }
328
329 int* NgonGridData::getXDimensions(void)
330 {
331     return xDimensions;
332 }
333
334 int* NgonGridData::getYDimensions(void)
335 {
336     return yDimensions;
337 }
338
339 void NgonGridData::setDataX(double const* data, int numElements)
340 {
341     if (numElements > xSize)
342     {
343         return;
344     }
345
346     for (int i = 0; i < numElements; i++)
347     {
348         xCoordinates[i] = data[i];
349     }
350 }
351
352 void NgonGridData::setDataY(double const* data, int numElements)
353 {
354     if (numElements > ySize)
355     {
356         return;
357     }
358
359     for (int i = 0; i < numElements; i++)
360     {
361         yCoordinates[i] = data[i];
362     }
363 }
364
365 void NgonGridData::setDataZ(double const* data, int numElements)
366 {
367     if (numElements > xSize * ySize)
368     {
369         return;
370     }
371
372     for (int i = 0; i < numElements; i++)
373     {
374         zCoordinates[i] = data[i];
375     }
376 }
377
378 void NgonGridData::setZCoordinatesShift(double const* data)
379 {
380     zCoordinatesShift = *data;
381 }
382
383 double* NgonGridData::getDataX(void)
384 {
385     return xCoordinates;
386 }
387
388 double* NgonGridData::getDataY(void)
389 {
390     return yCoordinates;
391 }
392
393 double* NgonGridData::getDataZ(void)
394 {
395     return zCoordinates;
396 }
397
398 double NgonGridData::getZCoordinatesShift(void)
399 {
400     return zCoordinatesShift;
401 }