---

polygonize.h

/*
  File: polygonize.h

  Ported to C++/STL expression framework by C. Kotterink

  Original file (implicit.c) authored by Jules Bloomenthal, Xerox PARC.
  Copyright (c) Xerox Corporation, 1991.  All rights reserved.
  Permission is granted to reproduce, use and distribute this code for
  any and all purposes, provided that this notice appears in all copies.
*/
#ifndef POLYGONIZE_H
#define POLYGONIZE_H

#include<ImplicitShape.h>

#include<slist>
#include<vector>

class polygonize;

class polygonize
{
public:
    polygonize(ImplicitShape *s, float s, int b);
    ~polygonize();

    void operator()(float x = 0.0, float y = 0.0, float z = 0.0);
    vector<Vertex3> &getVertex() {
      return vertex;
    }
    vector<uint16> &getFace() {
      return face;
    }

private:
    class Test {
    public:
        Vertex3 p;
        float value;
        bool ok;
    };
    class Corner {
    public:
        Corner(int ii = 0, int jj = 0, int kk = 0, float v = 0.0)
            : i(ii), j(jj), k(kk), value(v) {}
        int i, j, k;
        float value;
    };
    typedef slist<Corner> CornerList;
    class Cube {
    public:
        Cube(int ii = 0, int jj = 0, int kk = 0) : i(ii), j(jj), k(kk) {
            // Corners not initialized!
        }
        int i, j, k;
        CornerList *corners[8];
    };
    class Center {
    public:
        Center(int ii, int jj, int kk) : i(ii), j(jj), k(kk) {}
        int i, j, k;
    };
    class Edge {
    public:
        Edge(int ii1, int jj1, int kk1, int ii2, int jj2, int kk2, int v) :
            i1(ii1), j1(jj1), k1(kk1), i2(ii2), j2(jj2), k2(kk2), vid(v) {}
        int i1, j1, k1, i2, j2, k2;
        int vid;
    };
    typedef slist<int> IntList;
    typedef slist<Cube> CubeList;
    typedef slist<Center> CenterList;
    typedef slist<Edge> EdgeList;
    typedef slist<IntList> IntLists;

    // testface: given cube at lattice (i, j, k), and four corners of face,
    // if surface crosses face, compute other four corners of adjacent cube
    // and add new cube to cube stack
    void testface (
        int i, int j, int k,
        Cube &oldCube,
        int face, int c1, int c2, int c3, int c4);

    // setpoint: set point location given lattice location
    void setpoint(Vertex3 &pt, int i, int j, int k);

    // setcenter: set (i,j,k) entry centers\
    // return true if already set; otherwise, set and return false
    bool setcenter(int i, int j, int k);

    // setcorner: return corner with the given lattice location
    // set (and cache) its function value
    CornerList *setcorner(int i, int j, int k);

    // setedge: set vertex id for edge
    void setedge(
      int i1, int j1, int k1, int i2, int j2, int k2, int vid);

    // getedge: return vertex id for edge; return -1 if not set
    int polygonize::getedge(
      int i1, int j1, int k1, int i2, int j2, int k2);

    // find: search for point with value of given sign (0: neg, 1: pos)
    Test find(int sign, float x, float y, float z);

    // dotet: triangulate the tetrahedron
    void dotet(Cube &cube, int c1, int c2, int c3, int c4);

    // converge: from two points of differing sign, converge to surface
    void converge(const Vertex3 &p1, const Vertex3 &p2, float v, Vertex3 &p);

    // vertid: return index for vertex on edge
    uint16 vertid (Corner &c1, Corner &c2);

    void triproc(uint16 a, uint16 b, uint16 c);

    static const unsigned int convergeDepth = 10;
    static const unsigned int hashBit = 5;
    static const size_t hashSize = 1<<(3*hashBit);
    static const unsigned int hashMask = (1<<hashBit)-1;

    int hashValue(int i,int j,int k) {
      return ((((i&hashMask)<<hashBit)|(j&hashMask))<<hashBit)|(k&hashMask);
    }
    float random() {
      return (rand()&32767)/32767.0;
    }

    float size;
    float delta;
    int bounds;
    Vertex3 start;
    ImplicitShape *shape;

    vector<Vertex3> vertex;
    vector<uint16> face;

    CubeList cubes;
    CenterList centers[hashSize];
    CornerList corners[hashSize]; 
    EdgeList edges[2*hashSize];
};
#endif

---

This documentation was generated using doxygen. If you have any comments or additions please mail me.