DelaunayHelpers.h

Go to the documentation of this file.

#ifndef DelaunayHelpers_HEADER
#define DelaunayHelpers_HEADER

/***************************************************************************
 * \file
 * Benoit Hudson (C) 2007.
 *
 * A series of helpers for Delaunay meshes.
 ***************************************************************************/

#include <vector>
#include <topology/SimplicialHelpers.h>

namespace Delaunay {
  using namespace std;

  /***************************************************************************
   * Print the triangulation to EPS.
   *
   * The topological triangulation must be in two dimension.  If it is in
   * higher ambient dimension, it will project.
   ***************************************************************************/
  template <class Del> void printToEPS(const Del *del, FILE *out) {
    // TODO: take that out of there.
    del->printToEPS(out);
  }


#define printTuple(out, f, d, tup, id) \
do { \
  switch(d) { \
    case 0: \
      fprintf(out, "%lu\n", id); \
      break; \
    case 1: \
      fprintf(out, "%lu "f"\n", id, tup[0]); \
      break; \
    case 2: \
      fprintf(out, "%lu "f" "f"\n", id, tup[0], tup[1]); \
      break; \
    case 3: \
      fprintf(out, "%lu "f" "f" "f"\n", id, tup[0], tup[1], tup[2]); \
      break; \
    case 4: \
      fprintf(out, "%lu "f" "f" "f" "f"\n", id, tup[0], tup[1], tup[2], tup[3]); \
      break; \
    default: \
      /* There must be at least 5, so print them out (no newline). */ \
      fprintf(out, "%lu "f" "f" "f" "f" "f, id, \
          tup[0], tup[1], tup[2], tup[3], tup[4]); \
      /* Excrutiatingly slowly print out the remainder. */ \
      for(size_t j = 4; j < d; ++j) { \
        fprintf(out, " "f, tup[j]); \
      } \
      fputs("\n", out); \
  } \
} while(0)

  template <class Point> void printPoint(unsigned long id, const Point& p, FILE *out) {
    printTuple(out, "%g", Point::dimension, p, id);
  }

  template <class IntVect> void printEle(unsigned long id, const IntVect& v, FILE *out) {
    size_t len = v.size();
    printTuple(out, "%u", len, (unsigned)v, id);
  }
#undef printTuple



  template <class Vertex> void printToNode(const std::vector<Vertex*>& verts, FILE *out) {
    assert(verts.size() > 0);
    unsigned d = verts[0]->dim();

    fprintf(out, "%lu %u 0 0\n", (unsigned long)verts.size(), d);
    for(unsigned i = 0 ; i < verts.size(); ++i) {
      printPoint(i, verts[i]->toPoint(), out);
    }
  }

  template <class Del> void printToNode(const Del *del, FILE *out) {
    vector<typename Del::Vertex*> verts;
    Simplicial::collectVertices(del->getComplex(), verts);
    printToNode(verts, out);
  }

  template <class Del> void printToNodeEle(const Del *del, FILE *node, FILE *ele) {
    vector<typename Del::Vertex*> verts;
    // TODO: speed this up (don't use vector<vector> )
    vector<vector<size_t> > elements;

    Simplicial::serialize(del->getComplex(), verts, elements);
    assert(verts.size() > 0);
    unsigned d = verts[0]->dim();
    printToNode(verts, node);

    fprintf(ele, "%lu %u 0\n", (unsigned long)elements.size(), d + 1);
    for(size_t i = 0; i < elements.size(); i++) {
      printEle(i, elements[i], ele);
    }
  }
}


#endif

---