bloomenthal.h

Go to the documentation of this file.

#ifndef BLOOMENTHAL_H
#define BLOOMENTHAL_H

#include "Implicit/Implicit.h"
#include "jbvertices.h"

#define RES     10 /* # converge iterations    */

#define JB_L       0  /* left direction:   -x, -i */
#define JB_R       1  /* right direction:  +x, +i */
#define JB_B       2  /* bottom direction: -y, -j */
#define JB_T       3  /* top direction:    +y, +j */
#define JB_N       4  /* near direction:   -z, -k */
#define JB_F       5  /* far direction:    +z, +k */
#define JB_LBN     0  /* left bottom near corner  */
#define JB_LBF     1  /* left bottom far corner   */
#define JB_LTN     2  /* left top near corner     */
#define JB_LTF     3  /* left top far corner      */
#define JB_RBN     4  /* right bottom near corner */
#define JB_RBF     5  /* right bottom far corner  */
#define JB_RTN     6  /* right top near corner    */
#define JB_RTF     7  /* right top far corner     */

/* the LBN corner of cube (i, j, k), corresponds with location
 * (start.x+(i-.5)*size, start.y+(j-.5)*size, start.z+(k-.5)*size) */

#define RAND()    ((rand()&32767)/32767.)  /* random number, 0--1 */
#define HASHBIT   (5)
#define HSIZE     (size_t)(1<<(3*HASHBIT)) /* hash table size (32768) */
#define MASK      ((1<<HASHBIT)-1)
#define HASH(i,j,k) \
((((((i)&MASK)<<HASHBIT)|((j)&MASK))<<HASHBIT)|((k)&MASK))
#define BIT(i, bit) (((i)>>(bit))&1)
#define FLIP(i,bit) ((i)^1<<(bit)) /* flip the given bit of i */

class jbTest {                   /* test the function for a signed value */
public:
    gmVector3 pt;                       /* location of test */
    double value;                   /* function value at p */
    int ok;                        /* if value is of correct sign */
};

class jbCornerlist {        /* list of corners */
public:
    int i, j, k;                   /* corner id */
    double value;                   /* corner value */
    jbCornerlist *next;       /* remaining elements */
};

class jbCube {                   /* partitioning cell (cube) */
public:
    int i, j, k;                   /* lattice location of cube */
    jbCornerlist *corners[8];        /* eight corners */
};

class jbCubes {             /* linked list (stack) of cubes */
public:
    jbCube cube;                     /* a single cube */
    jbCubes *next;            /* remaining elements */
};

class jbCenterlist {        /* list of cube locations */
public:
    int i, j, k;                   /* cube location */
    jbCenterlist *next;       /* remaining elements */
};

class jbEdgelist {          /* list of edges */
public:
    int i1, j1, k1, i2, j2, k2;    /* edge corner ids */
    int vid;                       /* vertex id */
    jbEdgelist *next;         /* remaining elements */
};

class jbIntlist {           /* list of integers */
public:
    int i;                         /* an integer */
    jbIntlist *next;          /* remaining elements */
};

class jbIntlists {          /* list of list of integers */
public:
    jbIntlist *list;                 /* a list of integers */
    jbIntlists *next;         /* remaining elements */
};

class jbProcess {           /* parameters, function, storage */
public:
//    double (*function)(gmVector3 x); /* implicit surface function */
        Implicit *f;
    int (*triproc)(int i1, int i2,
      int i3, jbVertices vertices);  /* triangle output function */
    double size, delta;             /* cube size, normal delta */
    int bounds;                    /* cube range within lattice */
    gmVector3 start;                   /* start point on surface */
    jbCubes *cubes;                  /* active cubes */
    jbVertices vertices;             /* surface vertices */
    jbCenterlist **centers;          /* cube center hash table */
    jbCornerlist **corners;          /* corner value hash table */
    jbEdgelist **edges;              /* edge and vertex id hash table */

        char *polygonize (
//              double (*function)(gmVector3 x),
                Implicit *f,
                double size,
                int bounds,
                gmVector3 x,
                int (*triproc)(int i1, int i2, int i3, jbVertices vertices)
        );
        char *marchingcubes (
                Implicit *f,
                double size,
                gmVector3 x0, gmVector3 x1,
                int (*triproc)(int i1, int i2, int i3, jbVertices vertices)
        );
        void freeprocess();
        void testface (int i, int j, int k, jbCube *old, int face, int c1, int c2, int c3, int c4);
        gmVector3 setpoint (int i, int j, int k);
        jbCornerlist *setcorner (int i, int j, int k);
        jbTest find(int sign, gmVector3 x);
        int dotet (jbCube *cube, int c1, int c2, int c3, int c4);
        int setcenter(int i, int j, int k);
        void setedge (int i1, int j1, int k1, int i2, int j2, int k2, int vid);
        int getedge (int i1, int j1, int k1, int i2, int j2, int k2);
        int vertid (jbCornerlist *c1, jbCornerlist *c2);
        gmVector3 converge (gmVector3 p1, gmVector3 p2, double v);

};

char *mycalloc (int nitems, int nbytes);

#endif

---