scilab/modules/graphic_objects/src/cpp/NgonPolylineData.cpp

   1 /*
   2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  *  Copyright (C) 2010 - 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 <iostream>
  14
  15 #include "NgonPolylineData.hxx"
  16 #include "DataProperties.hxx"
  17
  18 extern "C" {
  19 #include "BOOL.h"
  20
  21 #include <string.h>
  22
  23 #include "graphicObjectProperties.h"
  24 }
  25
  26 NgonPolylineData::NgonPolylineData(void)
  27 {
  28     xShift = NULL;
  29     yShift = NULL;
  30     zShift = NULL;
  31
  32     xShiftSet = 0;
  33     yShiftSet = 0;
  34     zShiftSet = 0;
  35
  36     coordinatesShift = NULL;
  37
  38     zCoordinatesSet = 0;
  39 }
  40
  41 NgonPolylineData::~NgonPolylineData(void)
  42 {
  43     if (xShiftSet)
  44     {
  45         delete [] xShift;
  46     }
  47
  48     if (yShiftSet)
  49     {
  50         delete [] yShift;
  51     }
  52
  53     if (zShiftSet)
  54     {
  55         delete [] zShift;
  56     }
  57 }
  58
  59 int NgonPolylineData::getPropertyFromName(int propertyName)
  60 {
  61     switch (propertyName)
  62     {
  63         case __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__ :
  64             return NUM_ELEMENTS_ARRAY;
  65         case __GO_DATA_MODEL_X_COORDINATES_SHIFT__ :
  66             return X_COORDINATES_SHIFT;
  67         case __GO_DATA_MODEL_Y_COORDINATES_SHIFT__ :
  68             return Y_COORDINATES_SHIFT;
  69         case __GO_DATA_MODEL_Z_COORDINATES_SHIFT__ :
  70             return Z_COORDINATES_SHIFT;
  71         case __GO_DATA_MODEL_NUM_ELEMENTS__ :
  72             return NUM_ELEMENTS;
  73         case __GO_DATA_MODEL_X_COORDINATES_SHIFT_SET__ :
  74             return X_COORDINATES_SHIFT_SET;
  75         case __GO_DATA_MODEL_Y_COORDINATES_SHIFT_SET__ :
  76             return Y_COORDINATES_SHIFT_SET;
  77         case __GO_DATA_MODEL_Z_COORDINATES_SHIFT_SET__ :
  78             return Z_COORDINATES_SHIFT_SET;
  79         case __GO_DATA_MODEL_Z_COORDINATES_SET__ :
  80             return Z_COORDINATES_SET;
  81         default :
  82             return NgonGeneralData::getPropertyFromName(propertyName);
  83     }
  84
  85 }
  86
  87
  88 int NgonPolylineData::setDataProperty(int property, void const* value, int numElements)
  89 {
  90     switch (property)
  91     {
  92         case NUM_ELEMENTS_ARRAY :
  93             return setNumElementsArray((int const*) value);
  94         case X_COORDINATES_SHIFT :
  95             return setXCoordinatesShift((double const*) value, numElements);
  96         case Y_COORDINATES_SHIFT :
  97             return setYCoordinatesShift((double const*) value, numElements);
  98         case Z_COORDINATES_SHIFT :
  99             return setZCoordinatesShift((double const*) value, numElements);
 100         case X_COORDINATES_SHIFT_SET :
 101             setXCoordinatesShiftSet(*((int const*) value));
 102             break;
 103         case Y_COORDINATES_SHIFT_SET :
 104             setYCoordinatesShiftSet(*((int const*) value));
 105             break;
 106         case Z_COORDINATES_SHIFT_SET :
 107             setZCoordinatesShiftSet(*((int const*) value));
 108             break;
 109         case Z_COORDINATES_SET :
 110             setZCoordinatesSet(*((int const*) value));
 111             break;
 112         default :
 113             return NgonGeneralData::setDataProperty(property, value, numElements);
 114     }
 115
 116     return 1;
 117 }
 118
 119 void NgonPolylineData::getDataProperty(int property, void **_pvData)
 120 {
 121     switch (property)
 122     {
 123         case X_COORDINATES_SHIFT :
 124             *_pvData = getXCoordinatesShift();
 125             break;
 126         case Y_COORDINATES_SHIFT :
 127             *_pvData = getYCoordinatesShift();
 128             break;
 129         case Z_COORDINATES_SHIFT :
 130             *_pvData = getZCoordinatesShift();
 131             break;
 132         case NUM_ELEMENTS :
 133             ((int *) *_pvData)[0] = getNumElements();
 134             break;
 135         case X_COORDINATES_SHIFT_SET :
 136             ((int *) *_pvData)[0] = getXCoordinatesShiftSet();
 137             break;
 138         case Y_COORDINATES_SHIFT_SET :
 139             ((int *) *_pvData)[0] = getYCoordinatesShiftSet();
 140             break;
 141         case Z_COORDINATES_SHIFT_SET :
 142             ((int *) *_pvData)[0] = getZCoordinatesShiftSet();
 143             break;
 144         case Z_COORDINATES_SET :
 145             ((int *) *_pvData)[0] = getZCoordinatesSet();
 146             break;
 147         default :
 148             NgonGeneralData::getDataProperty(property, _pvData);
 149     }
 150 }
 151
 152 int NgonPolylineData::getNumElements(void)
 153 {
 154     return numVerticesPerGon;
 155 }
 156
 157 void NgonPolylineData::setZCoordinatesSet(int zCoordinatesSet)
 158 {
 159     this->zCoordinatesSet = zCoordinatesSet;
 160 }
 161
 162 int NgonPolylineData::getZCoordinatesSet(void)
 163 {
 164     return this->zCoordinatesSet;
 165 }
 166
 167 double* NgonPolylineData::getXCoordinatesShift(void)
 168 {
 169     return xShift;
 170 }
 171
 172 int NgonPolylineData::setXCoordinatesShift(double const* data, int numElements)
 173 {
 174     if (xShiftSet == 0)
 175     {
 176
 177         try
 178         {
 179             xShift = new double[numVerticesPerGon];
 180         }
 181         catch (const std::exception& e)
 182         {
 183             e.what();
 184             return 0;
 185         }
 186
 187         xShiftSet = 1;
 188     }
 189
 190     for (int i = 0; i < numVerticesPerGon; i++)
 191     {
 192         xShift[i] = data[i];
 193     }
 194
 195     return 1;
 196 }
 197
 198 double* NgonPolylineData::getYCoordinatesShift()
 199 {
 200     return yShift;
 201 }
 202
 203 int NgonPolylineData::setYCoordinatesShift(double const* data, int numElements)
 204 {
 205     if (yShiftSet == 0)
 206     {
 207
 208         try
 209         {
 210             yShift = new double[numVerticesPerGon];
 211         }
 212         catch (const std::exception& e)
 213         {
 214             e.what();
 215             return 0;
 216         }
 217
 218         yShiftSet = 1;
 219     }
 220
 221     for (int i = 0; i < numVerticesPerGon; i++)
 222     {
 223         yShift[i] = data[i];
 224     }
 225
 226     return 1;
 227 }
 228
 229 double* NgonPolylineData::getZCoordinatesShift()
 230 {
 231     return zShift;
 232 }
 233
 234 int NgonPolylineData::getXCoordinatesShiftSet(void)
 235 {
 236     return xShiftSet;
 237 }
 238
 239 void NgonPolylineData::setXCoordinatesShiftSet(int xShiftSet)
 240 {
 241     if (xShiftSet == 0 && this->xShiftSet == 1)
 242     {
 243         delete [] xShift;
 244         xShift = NULL;
 245     }
 246
 247     this->xShiftSet = xShiftSet;
 248 }
 249
 250 int NgonPolylineData::getYCoordinatesShiftSet(void)
 251 {
 252     return yShiftSet;
 253 }
 254
 255 void NgonPolylineData::setYCoordinatesShiftSet(int yShiftSet)
 256 {
 257     if (yShiftSet == 0 && this->yShiftSet == 1)
 258     {
 259         delete [] yShift;
 260         yShift = NULL;
 261     }
 262
 263     this->yShiftSet = yShiftSet;
 264 }
 265
 266 int NgonPolylineData::getZCoordinatesShiftSet(void)
 267 {
 268     return zShiftSet;
 269 }
 270
 271 void NgonPolylineData::setZCoordinatesShiftSet(int zShiftSet)
 272 {
 273     if (zShiftSet == 0 && this->zShiftSet == 1)
 274     {
 275         delete [] zShift;
 276         zShift = NULL;
 277     }
 278
 279     this->zShiftSet = zShiftSet;
 280 }
 281
 282 int NgonPolylineData::setZCoordinatesShift(double const* data, int numElements)
 283 {
 284     if (zShiftSet == 0)
 285     {
 286
 287         try
 288         {
 289             zShift = new double[numVerticesPerGon];
 290         }
 291         catch (const std::exception& e)
 292         {
 293             e.what();
 294             return 0;
 295         }
 296
 297         zShiftSet = 1;
 298     }
 299
 300     for (int i = 0; i < numVerticesPerGon; i++)
 301     {
 302         zShift[i] = data[i];
 303     }
 304
 305     return 1;
 306 }
 307
 308 int NgonPolylineData::setNumElementsArray(int const* numElementsArray)
 309 {
 310     int newNumElements = 0;
 311     int previousNumElements = 0;
 312     int result = 1;
 313
 314     if (numElementsArray[0] != 1)
 315     {
 316         return 0;
 317     }
 318
 319     newNumElements = numElementsArray[0] * numElementsArray[1];
 320     previousNumElements = numGons * numVerticesPerGon;
 321
 322     if (newNumElements == 0 && previousNumElements > 0)
 323     {
 324         numVerticesPerGon = 0;
 325
 326         deleteCoordinatesArrays();
 327
 328         return 1;
 329     }
 330
 331     if (numGons * numVerticesPerGon != newNumElements)
 332     {
 333         double* newCoordinates = NULL;
 334         double* xShiftNew = NULL;
 335         double* yShiftNew = NULL;
 336         double* zShiftNew = NULL;
 337
 338         result = 1;
 339
 340         try
 341         {
 342             newCoordinates = new double[3 * newNumElements];
 343         }
 344         catch (const std::exception& e)
 345         {
 346             e.what();
 347             return 0;
 348         }
 349
 350         if (xShiftSet)
 351         {
 352             try
 353             {
 354                 xShiftNew = new double[newNumElements];
 355             }
 356             catch (const std::exception& e)
 357             {
 358                 e.what();
 359                 result = 0;
 360             }
 361         }
 362
 363         if (yShiftSet)
 364         {
 365             try
 366             {
 367                 yShiftNew = new double[newNumElements];
 368             }
 369             catch (const std::exception& e)
 370             {
 371                 e.what();
 372                 result = 0;
 373             }
 374         }
 375
 376         if (zShiftSet)
 377         {
 378             try
 379             {
 380                 zShiftNew = new double[newNumElements];
 381             }
 382             catch (const std::exception& e)
 383             {
 384                 e.what();
 385                 result = 0;
 386             }
 387         }
 388
 389         if (result)
 390         {
 391             if (numGons * numVerticesPerGon > 0)
 392             {
 393                 delete [] coordinates;
 394             }
 395
 396             /*
 397              * Initialize the new coordinates' z values to 0 in case
 398              * they are not set afterwards.
 399              */
 400             for (int i = 0; i < newNumElements; i++)
 401             {
 402                 newCoordinates[2 * newNumElements + i] = 0.0;
 403             }
 404
 405             coordinates = newCoordinates;
 406
 407             if (xShiftSet)
 408             {
 409                 copyShiftCoordinatesArray(xShiftNew, xShift, newNumElements);
 410                 delete [] xShift;
 411                 xShift = xShiftNew;
 412             }
 413
 414             if (yShiftSet)
 415             {
 416                 copyShiftCoordinatesArray(yShiftNew, yShift, newNumElements);
 417                 delete [] yShift;
 418                 yShift = yShiftNew;
 419             }
 420
 421             if (zShiftSet)
 422             {
 423                 copyShiftCoordinatesArray(zShiftNew, zShift, newNumElements);
 424                 delete [] zShift;
 425                 zShift = zShiftNew;
 426             }
 427
 428             numGons = numElementsArray[0];
 429             numVerticesPerGon = numElementsArray[1];
 430         }
 431         else
 432         {
 433             /* Delete the temporary arrays and don't set anything */
 434             if (newCoordinates != NULL)
 435             {
 436                 delete [] newCoordinates;
 437             }
 438
 439             if (xShiftNew != NULL)
 440             {
 441                 delete [] xShiftNew;
 442             }
 443
 444             if (yShiftNew != NULL)
 445             {
 446                 delete [] yShiftNew;
 447             }
 448
 449             if (zShiftNew != NULL)
 450             {
 451                 delete [] zShiftNew;
 452             }
 453
 454         }
 455
 456     }
 457
 458     return result;
 459 }
 460
 461 void NgonPolylineData::copyShiftCoordinatesArray(double * newShift, double const* oldShift, int numElementsNew)
 462 {
 463     int numElementsCopied = 0;
 464
 465     if (numElementsNew < numVerticesPerGon)
 466     {
 467         numElementsCopied = numElementsNew;
 468     }
 469     else
 470     {
 471         numElementsCopied = numVerticesPerGon;
 472     }
 473
 474     for (int i = 0; i < numElementsCopied; i++)
 475     {
 476         newShift[i] = oldShift[i];
 477     }
 478
 479     for (int i = numElementsCopied; i < numElementsNew; i++)
 480     {
 481         newShift[i] = 0.0;
 482     }
 483 }
 484
 485 void NgonPolylineData::deleteCoordinatesArrays(void)
 486 {
 487     if (coordinates != NULL)
 488     {
 489         delete [] coordinates;
 490         coordinates = NULL;
 491     }
 492
 493     if (xShiftSet)
 494     {
 495         delete [] xShift;
 496         xShift = NULL;
 497         xShiftSet = 0;
 498     }
 499
 500     if (yShiftSet)
 501     {
 502         delete [] yShift;
 503         yShift = NULL;
 504         yShiftSet = 0;
 505     }
 506
 507     if (zShiftSet)
 508     {
 509         delete [] zShift;
 510         zShift = NULL;
 511         zShiftSet = 0;
 512     }
 513 }
 514