scilab/modules/graphic_objects/src/cpp/NgonGeneralData.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 "NgonGeneralData.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 NgonGeneralData::NgonGeneralData(void)
  27 {
  28     numGons = 0;
  29     numVerticesPerGon = 0;
  30
  31     coordinates = NULL;
  32
  33     colorValues = NULL;
  34     numColors = 0;
  35 }
  36
  37 NgonGeneralData::~NgonGeneralData(void)
  38 {
  39     if (numGons * numVerticesPerGon > 0)
  40     {
  41         delete [] coordinates;
  42     }
  43
  44     if (numColors > 0)
  45     {
  46         delete [] colorValues;
  47     }
  48 }
  49
  50 int NgonGeneralData::getPropertyFromName(int propertyName)
  51 {
  52     switch (propertyName)
  53     {
  54         case __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__ :
  55             return NUM_ELEMENTS_ARRAY;
  56         case __GO_DATA_MODEL_COORDINATES__ :
  57             return COORDINATES;
  58         case __GO_DATA_MODEL_X__ :
  59             return X_COORDINATES;
  60         case __GO_DATA_MODEL_Y__ :
  61             return Y_COORDINATES;
  62         case __GO_DATA_MODEL_Z__ :
  63             return Z_COORDINATES;
  64         case __GO_DATA_MODEL_COLORS__ :
  65             return COLORS;
  66         case __GO_DATA_MODEL_NUM_COLORS__ :
  67             return NUM_COLORS;
  68         default :
  69             return NgonData::getPropertyFromName(propertyName);
  70     }
  71 }
  72
  73 int NgonGeneralData::setDataProperty(int property, void const* value, int numElements)
  74 {
  75
  76     if (property == NUM_ELEMENTS_ARRAY)
  77     {
  78         return setNumElementsArray((int const*) value);
  79     }
  80     else if (property == COORDINATES)
  81     {
  82         setData((double const*) value, numElements);
  83     }
  84     else if (property == X_COORDINATES)
  85     {
  86         setDataX((double const*) value, numElements);
  87     }
  88     else if (property == Y_COORDINATES)
  89     {
  90         setDataY((double const*) value, numElements);
  91     }
  92     else if (property == Z_COORDINATES)
  93     {
  94         setDataZ((double const*) value, numElements);
  95     }
  96     else if (property == COLORS)
  97     {
  98         setColors((double const*) value, numElements);
  99     }
 100     else
 101     {
 102         return NgonData::setDataProperty(property, value, numElements);
 103     }
 104
 105     return 1;
 106 }
 107
 108 void NgonGeneralData::getDataProperty(int property, void **_pvData)
 109 {
 110     if (property == NUM_ELEMENTS_ARRAY)
 111     {
 112         /* Not implemented yet */
 113         //    getNumElementsArray();
 114     }
 115     else if (property == COORDINATES)
 116     {
 117         *_pvData = getData();
 118     }
 119     else if (property == X_COORDINATES)
 120     {
 121         *_pvData = getDataX();
 122     }
 123     else if (property == Y_COORDINATES)
 124     {
 125         *_pvData = getDataY();
 126     }
 127     else if (property == Z_COORDINATES)
 128     {
 129         *_pvData = getDataZ();
 130     }
 131     else if (property == COLORS)
 132     {
 133         *_pvData = getColors();
 134     }
 135     else if (property == NUM_COLORS)
 136     {
 137         ((int *) *_pvData)[0] = getNumColors();
 138     }
 139     else
 140     {
 141         NgonData::getDataProperty(property, _pvData);
 142     }
 143
 144 }
 145
 146 double* NgonGeneralData::getData()
 147 {
 148     return coordinates;
 149 }
 150
 151 double* NgonGeneralData::getDataX(void)
 152 {
 153     return coordinates;
 154 }
 155
 156 double* NgonGeneralData::getDataY(void)
 157 {
 158     return &coordinates[numGons * numVerticesPerGon];
 159 }
 160
 161 double* NgonGeneralData::getDataZ(void)
 162 {
 163     return &coordinates[2 * numGons * numVerticesPerGon];
 164 }
 165
 166 /*
 167  * Only partially implemented
 168  * Must be made consistent with setNumElementsArray
 169  */
 170 void NgonGeneralData::setData(double const* data, int numElements)
 171 {
 172     if (numElements != numGons * numVerticesPerGon)
 173     {
 174         delete [] coordinates;
 175
 176         numVerticesPerGon = numElements / numGons;
 177         coordinates = new double[3 * numElements];
 178     }
 179
 180     memcpy(coordinates, data, 3 * numElements * sizeof(double));
 181 }
 182
 183 void NgonGeneralData::setDataX(double const* data, int numElements)
 184 {
 185     double* xCoordinates = NULL;
 186
 187     xCoordinates = coordinates;
 188     memcpy(xCoordinates, data, numElements * sizeof(double));
 189 }
 190
 191 void NgonGeneralData::setDataY(double const* data, int numElements)
 192 {
 193     double* yCoordinates;
 194
 195     yCoordinates = &coordinates[numGons * numVerticesPerGon];
 196     memcpy(yCoordinates, data, numElements * sizeof(double));
 197 }
 198
 199 void NgonGeneralData::setDataZ(double const* data, int numElements)
 200 {
 201     double* zCoordinates = NULL;
 202
 203     zCoordinates = &coordinates[2 * numGons * numVerticesPerGon];
 204     memcpy(zCoordinates, data, numElements * sizeof(double));
 205 }
 206
 207 int NgonGeneralData::getNumElements(void)
 208 {
 209     return numGons;
 210 }
 211
 212 int NgonGeneralData::setNumElementsArray(int const* numElementsArray)
 213 {
 214     double* newCoordinates = NULL;
 215     double* newColorValues = NULL;
 216     int result = 1;
 217
 218     /* Test whether the number of colors is valid */
 219     if ((numElementsArray[2] != numElementsArray[0]*numElementsArray[1]) &&
 220             (numElementsArray[2] != numElementsArray[0]) &&
 221             (numElementsArray[2] != 0))
 222     {
 223         return 0;
 224     }
 225
 226     if (numGons * numVerticesPerGon != numElementsArray[0]*numElementsArray[1])
 227     {
 228         try
 229         {
 230             newCoordinates = new double[3 * numElementsArray[0]*numElementsArray[1]];
 231         }
 232         catch (const std::exception& e)
 233         {
 234             e.what();
 235             return 0;
 236         }
 237
 238         result = 1;
 239     }
 240
 241     if (numElementsArray[2] != this->numColors)
 242     {
 243         if (numElementsArray[2] > 0)
 244         {
 245             try
 246             {
 247                 newColorValues = new double[numElementsArray[2]];
 248             }
 249             catch (const std::exception& e)
 250             {
 251                 e.what();
 252                 result = 0;
 253             }
 254         }
 255
 256     }
 257
 258     if (result == 1)
 259     {
 260         if (newCoordinates != NULL)
 261         {
 262             if (numGons * numVerticesPerGon > 0)
 263             {
 264                 delete [] coordinates;
 265             }
 266
 267             coordinates = newCoordinates;
 268
 269             numGons = numElementsArray[0];
 270             numVerticesPerGon = numElementsArray[1];
 271         }
 272
 273         if (newColorValues != NULL || numElementsArray[2] == 0)
 274         {
 275             if (this->numColors > 0)
 276             {
 277                 delete [] colorValues;
 278             }
 279
 280             colorValues = newColorValues;
 281             this->numColors = numElementsArray[2];
 282         }
 283     }
 284     else
 285     {
 286         if (newCoordinates != NULL)
 287         {
 288             delete [] newCoordinates;
 289         }
 290
 291         if (newColorValues != NULL)
 292         {
 293             delete [] newColorValues;
 294         }
 295     }
 296
 297     return result;
 298 }
 299
 300 double* NgonGeneralData::getColors(void)
 301 {
 302     return colorValues;
 303 }
 304
 305 void NgonGeneralData::setColors(double const* colors, int numElements)
 306 {
 307     if (numElements > numColors)
 308     {
 309         return;
 310     }
 311     memcpy(colorValues, colors, numElements * sizeof(double));
 312 }
 313
 314 int NgonGeneralData::getNumColors(void)
 315 {
 316     return numColors;
 317 }
 318