scilab/modules/graphic_objects/src/cpp/TriangleMeshData.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 "TriangleMeshData.hxx"
  14 #include "DataProperties.hxx"
  15
  16 extern "C" {
  17 #include <string.h>
  18 #include "BOOL.h"
  19
  20 #include "graphicObjectProperties.h"
  21 }
  22
  23 TriangleMeshData::TriangleMeshData(void)
  24 {
  25     vertices = NULL;
  26     indices = NULL;
  27     values = NULL;
  28
  29     numberVertices = 0;
  30     numberTriangles = 0;
  31 }
  32
  33 /* To be correctly implemented */
  34 TriangleMeshData::TriangleMeshData(unsigned int numberVertices, unsigned int numberTriangles)
  35 {
  36     vertices = new double[3 * numberVertices];
  37
  38     indices = new unsigned int[3 * numberTriangles];
  39
  40     this->numberVertices = numberVertices;
  41     this->numberTriangles = numberTriangles;
  42 }
  43
  44 /* To be correctly implemented */
  45 TriangleMeshData::~TriangleMeshData(void)
  46 {
  47     if (numberVertices > 0)
  48     {
  49         delete [] vertices;
  50         delete [] values;
  51     }
  52
  53     if (numberTriangles > 0)
  54     {
  55         delete [] indices;
  56     }
  57
  58 }
  59
  60 int TriangleMeshData::getPropertyFromName(int propertyName)
  61 {
  62     switch (propertyName)
  63     {
  64         case __GO_DATA_MODEL_NUM_VERTICES__ :
  65             return NUM_VERTICES;
  66         case __GO_DATA_MODEL_NUM_INDICES__ :
  67             return NUM_INDICES;
  68         case __GO_DATA_MODEL_X__ :
  69             return X_COORDINATES;
  70         case __GO_DATA_MODEL_Y__ :
  71             return Y_COORDINATES;
  72         case __GO_DATA_MODEL_Z__ :
  73             return Z_COORDINATES;
  74         case __GO_DATA_MODEL_COORDINATES__ :
  75             return COORDINATES;
  76         case __GO_DATA_MODEL_INDICES__ :
  77             return INDICES;
  78         case __GO_DATA_MODEL_VALUES__ :
  79             return VALUES;
  80         default :
  81             return Data3D::getPropertyFromName(propertyName);
  82     }
  83
  84 }
  85
  86
  87 int TriangleMeshData::setDataProperty(int property, void const* value, int numElements)
  88 {
  89     switch (property)
  90     {
  91         case NUM_VERTICES :
  92             return setNumVertices(*((unsigned int const*) value));
  93         case NUM_INDICES :
  94             return setNumIndices(*((unsigned int const*) value));
  95         case X_COORDINATES :
  96             setDataX((double const*) value, numElements);
  97             break;
  98         case Y_COORDINATES :
  99             setDataY((double const*) value, numElements);
 100             break;
 101         case Z_COORDINATES :
 102             setDataZ((double const*) value, numElements);
 103             break;
 104         case COORDINATES :
 105             setVertices((double const*) value, numElements);
 106             break;
 107         case INDICES :
 108             setIndices((unsigned int const*) value, numElements);
 109             break;
 110         case VALUES :
 111             setValues((double const*) value, numElements);
 112             break;
 113         default :
 114             return Data3D::setDataProperty(property, value, numElements);
 115     }
 116
 117     return 1;
 118 }
 119
 120 void TriangleMeshData::getDataProperty(int property, void **_pvData)
 121 {
 122     switch (property)
 123     {
 124         case NUM_VERTICES :
 125             ((int *)*_pvData)[0] = getNumVertices();
 126             break;
 127         case NUM_INDICES :
 128             ((int *)*_pvData)[0] = getNumIndices();
 129             break;
 130         case COORDINATES :
 131             *_pvData = getVertices();
 132             break;
 133         case INDICES :
 134             *_pvData = getIndices();
 135             break;
 136         case VALUES :
 137             *_pvData = getValues();
 138             break;
 139         default :
 140             Data3D::getDataProperty(property, _pvData);
 141     }
 142 }
 143
 144 unsigned int TriangleMeshData::getNumVertices(void)
 145 {
 146     return numberVertices;
 147 }
 148
 149 /*
 150  * Values are considered as being specified per-vertex for now
 151  * To be corrected
 152  */
 153 int TriangleMeshData::setNumVertices(unsigned int numVertices)
 154 {
 155     int result = 1;
 156
 157     if (numVertices == 0 && numberVertices > 0)
 158     {
 159         numberVertices = 0;
 160
 161         delete [] vertices;
 162         delete [] values;
 163
 164         return 1;
 165     }
 166
 167     if (numVertices != this->numberVertices)
 168     {
 169         double* newVertices = NULL;
 170         double* newValues = NULL;
 171
 172         try
 173         {
 174             newVertices = new double[3 * numVertices];
 175         }
 176         catch (const std::exception& e)
 177         {
 178             e.what();
 179             result = 0;
 180         }
 181
 182         try
 183         {
 184             newValues = new double[numVertices];
 185         }
 186         catch (const std::exception& e)
 187         {
 188             e.what();
 189             result = 0;
 190         }
 191
 192         if (result)
 193         {
 194             if (this->numberVertices > 0)
 195             {
 196                 delete [] vertices;
 197                 delete [] values;
 198             }
 199
 200             vertices = newVertices;
 201             values = newValues;
 202
 203             this->numberVertices =  numVertices;
 204
 205             resetCoordinates();
 206         }
 207         else
 208         {
 209             /* Failed allocation, nothing is set */
 210             if (newVertices != NULL)
 211             {
 212                 delete [] newVertices;
 213             }
 214
 215             if (newValues != NULL)
 216             {
 217                 delete [] newValues;
 218             }
 219         }
 220
 221     }
 222
 223     return result;
 224 }
 225
 226 unsigned int TriangleMeshData::getNumIndices(void)
 227 {
 228     return numberTriangles;
 229 }
 230
 231 int TriangleMeshData::setNumIndices(unsigned int numIndices)
 232 {
 233     int result = 1;
 234
 235     if (numIndices != this->numberTriangles)
 236     {
 237         unsigned int* newIndices = NULL;
 238
 239         try
 240         {
 241             newIndices = new unsigned int[3 * numIndices];
 242         }
 243         catch (const std::exception& e)
 244         {
 245             e.what();
 246             result = 0;
 247         }
 248
 249         if (result)
 250         {
 251             if (this->numberTriangles > 0)
 252             {
 253                 delete [] indices;
 254             }
 255
 256             indices = newIndices;
 257
 258             this->numberTriangles =  numIndices;
 259         }
 260         else
 261         {
 262             /* Failed allocation, nothing is set */
 263             if (newIndices != NULL)
 264             {
 265                 delete [] newIndices;
 266             }
 267         }
 268
 269     }
 270
 271     return result;
 272 }
 273
 274 double* TriangleMeshData::getVertices(void)
 275 {
 276     return vertices;
 277 }
 278
 279 void TriangleMeshData::setVertices(double const* vertices, unsigned int numElements)
 280 {
 281     if (numElements <= numberVertices)
 282     {
 283         memcpy(this->vertices, vertices, numElements * 3 * sizeof(double));
 284     }
 285 }
 286
 287 unsigned int* TriangleMeshData::getIndices(void)
 288 {
 289     return indices;
 290 }
 291
 292 void TriangleMeshData::setIndices(unsigned int const* indices, unsigned int numElements)
 293 {
 294     if (numElements <= numberTriangles)
 295     {
 296         memcpy(this->indices, indices, numElements * 3 * sizeof(unsigned int));
 297     }
 298 }
 299
 300 void TriangleMeshData::setDataX(double const* data, unsigned int numElements)
 301 {
 302     if (numElements <= numberVertices)
 303     {
 304         for (unsigned int i = 0 ; i < numElements ; i++)
 305         {
 306             vertices[3 * i] = data[i];
 307         }
 308     }
 309 }
 310
 311 void TriangleMeshData::setDataY(double const* data, unsigned int numElements)
 312 {
 313     if (numElements <= numberVertices)
 314     {
 315         for (unsigned int i = 0 ; i < numElements ; i++)
 316         {
 317             vertices[3 * i + 1] = data[i];
 318         }
 319     }
 320 }
 321
 322 void TriangleMeshData::setDataZ(double const* data, unsigned int numElements)
 323 {
 324     if (numElements <= numberVertices)
 325     {
 326         for (unsigned int i = 0; i < numElements; i++)
 327         {
 328             vertices[3 * i + 2] = data[i];
 329         }
 330     }
 331 }
 332
 333 void TriangleMeshData::setValues(double const* data, unsigned int numElements)
 334 {
 335     if (numElements <= numberVertices)
 336     {
 337         memcpy(this->values, data, numElements * sizeof(double));
 338     }
 339 }
 340
 341 double* TriangleMeshData::getValues(void)
 342 {
 343     return values;
 344 }
 345
 346 unsigned int TriangleMeshData::scilabIndexToIndex(unsigned int scilabIndex)
 347 {
 348     return (scilabIndex - 1);
 349 }
 350
 351 void TriangleMeshData::resetCoordinates(void)
 352 {
 353     for (unsigned int i = 0; i < numberVertices; i++)
 354     {
 355         vertices[3 * i] = 0.0;
 356         vertices[3 * i + 1] = 0.0;
 357         vertices[3 * i + 2] = 0.0;
 358     }
 359 }
 360