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