intern/dualcon/intern/dualcon_c_api.cpp

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * Contributor(s): Nicholas Bishop
  19  *
  20  * ***** END GPL LICENSE BLOCK *****
  21  */
  22
  23 #include <cassert>
  24 #include "dualcon.h"
  25 #include "ModelReader.h"
  26 #include "octree.h"
  27
  28 #include <cstdio>
  29 #include <float.h>
  30
  31 #if defined(_WIN32)
  32 #define isnan(n) _isnan(n)
  33 #endif
  34
  35 static void veccopy(float dst[3], const float src[3])
  36 {
  37         dst[0] = src[0];
  38         dst[1] = src[1];
  39         dst[2] = src[2];
  40 }
  41
  42 #define GET_TRI(_mesh, _n) \
  43         (*(DualConTri)(((char *)(_mesh)->looptri) + ((_n) * (_mesh)->tri_stride)))
  44
  45 #define GET_CO(_mesh, _n) \
  46         (*(DualConCo)(((char *)(_mesh)->co) + ((_n) * (_mesh)->co_stride)))
  47
  48 #define GET_LOOP(_mesh, _n) \
  49         (*(DualConLoop)(((char *)(_mesh)->mloop) + ((_n) * (_mesh)->loop_stride)))
  50
  51 class DualConInputReader : public ModelReader
  52 {
  53 private:
  54 const DualConInput *input_mesh;
  55 int tottri, curtri;
  56 float min[3], max[3], maxsize;
  57 float scale;
  58 public:
  59 DualConInputReader(const DualConInput *mesh, float _scale)
  60         : input_mesh(mesh), scale(_scale)
  61 {
  62         reset();
  63 }
  64
  65 void reset()
  66 {
  67         curtri = 0;
  68         maxsize = 0;
  69         tottri = input_mesh->tottri;
  70
  71         veccopy(min, input_mesh->min);
  72         veccopy(max, input_mesh->max);
  73
  74         /* initialize maxsize */
  75         for (int i = 0; i < 3; i++) {
  76                 float d = max[i] - min[i];
  77                 if (d > maxsize)
  78                         maxsize = d;
  79         }
  80
  81         /* redo the bounds */
  82         for (int i = 0; i < 3; i++)
  83         {
  84                 min[i] = (max[i] + min[i]) / 2 - maxsize / 2;
  85                 max[i] = (max[i] + min[i]) / 2 + maxsize / 2;
  86         }
  87
  88         for (int i = 0; i < 3; i++)
  89                 min[i] -= maxsize * (1 / scale - 1) / 2;
  90         maxsize *= 1 / scale;
  91 }
  92
  93 Triangle *getNextTriangle()
  94 {
  95         if (curtri == input_mesh->tottri)
  96                 return NULL;
  97
  98         Triangle *t = new Triangle();
  99
 100         unsigned int *tr = GET_TRI(input_mesh, curtri);
 101         veccopy(t->vt[0], GET_CO(input_mesh, GET_LOOP(input_mesh, tr[0])));
 102         veccopy(t->vt[1], GET_CO(input_mesh, GET_LOOP(input_mesh, tr[1])));
 103         veccopy(t->vt[2], GET_CO(input_mesh, GET_LOOP(input_mesh, tr[2])));
 104
 105         curtri++;
 106
 107         /* remove triangle if it contains invalid coords */
 108         for (int i = 0; i < 3; i++) {
 109                 const float *co = t->vt[i];
 110                 if (isnan(co[0]) || isnan(co[1]) || isnan(co[2])) {
 111                         delete t;
 112                         return getNextTriangle();
 113                 }
 114         }
 115
 116         return t;
 117 }
 118
 119 int getNextTriangle(int t[3])
 120 {
 121         if (curtri == input_mesh->tottri)
 122                 return 0;
 123
 124         unsigned int *tr = GET_TRI(input_mesh, curtri);
 125         t[0] = tr[0];
 126         t[1] = tr[1];
 127         t[2] = tr[2];
 128
 129         curtri++;
 130
 131         return 1;
 132 }
 133
 134 int getNumTriangles()
 135 {
 136         return tottri;
 137 }
 138
 139 int getNumVertices()
 140 {
 141         return input_mesh->totco;
 142 }
 143
 144 float getBoundingBox(float origin[3])
 145 {
 146         veccopy(origin, min);
 147         return maxsize;
 148 }
 149
 150 /* output */
 151 void getNextVertex(float /*v*/[3])
 152 {
 153         /* not used */
 154 }
 155
 156 /* stubs */
 157 void printInfo() {
 158 }
 159 int getMemory() {
 160         return sizeof(DualConInputReader);
 161 }
 162
 163 #ifdef WITH_CXX_GUARDEDALLOC
 164         MEM_CXX_CLASS_ALLOC_FUNCS("DUALCON:DualConInputReader")
 165 #endif
 166
 167 };
 168
 169 void *dualcon(const DualConInput *input_mesh,
 170               /* callbacks for output */
 171               DualConAllocOutput alloc_output,
 172               DualConAddVert add_vert,
 173               DualConAddQuad add_quad,
 174
 175               DualConFlags flags,
 176               DualConMode mode,
 177               float threshold,
 178               float hermite_num,
 179               float scale,
 180               int depth)
 181 {
 182         DualConInputReader r(input_mesh, scale);
 183         Octree o(&r, alloc_output, add_vert, add_quad,
 184                  flags, mode, depth, threshold, hermite_num);
 185         o.scanConvert();
 186         return o.getOutputMesh();
 187 }