RefineConstants.h

Go to the documentation of this file.

#ifndef RefineConstants_HEADER
#define RefineConstants_HEADER

#include <stdio.h>
#include <math.h>
#include <algorithm> // min
#include <string>    // string

/***************************************************************************
  Constants for the refinement.
 ***************************************************************************/
struct RefineConstants {
  double rho; 
  double rhoprime; 

  double k;   

  bool useOffcenters; 

  int bbox_points;
  double bbox_buffer;
  bool cleanup;

  double sigma; 
  double sliverGrowth; 
  double perturbFactor; 

  enum OutputStyle { NO_OUTPUT, QUAKE } outputStyle;
  enum InputStyle { NODE, POLY, AUTOMATIC } inputStyle;
  std::string filename;

  enum NodeOrder { ID_ORDER, INSERTION_ORDER_RENUMBER, INSERTION_ORDER_NORENUMBER };
  NodeOrder nodeOrder;

  RefineConstants() {
    rho = 0.0;
    rhoprime = 0.0;
    k = 0.0;

    useOffcenters = true;

    bbox_points = -1;
    bbox_buffer = -1;

    cleanup = false;

    sigma = 0.0;
    sliverGrowth = 3;
    perturbFactor = 0.1;

    outputStyle = QUAKE;
    inputStyle = AUTOMATIC;

    nodeOrder = ID_ORDER;
  }

  void regularize(size_t d, bool pointcloud) {

    /*
     * We need rho > 1; a value of rho = 1.0 will deterministically fail.
     * For PLC inputs, we also need that rho > 2^d.
     */
    const double minrho = pointcloud
      ? 1.0
      : pow(2.0, d);

    if (rho == 0.0) {
      rho = pointcloud ? sqrt(2.0) : minrho;
    } else if (rho < minrho - 1e-8) {
      fprintf(stderr, "Warning: rho small; we may not terminate (we need %g > %g)\n", rho, minrho);
    } else if (rho <= 1.0) {
      fprintf(stderr, "Error: rho (%g) must be strictly greater than 1.0\n", rho);
      exit(1);
    }

    if (k == 0.0) {
      k = 0.9; // published experiments indicate 0.9 is a good choice.
    }

    /*
     * When points are present, we have stricter requirements:
     * For every possible warp, the effective rho is reduced by a factor of k,
     * or 1-k, whichever is a bigger reduction.
     * For point clouds, we can warp once.  For PLCs, we can warp d times.
     */
    const double kprime = std::min(k, 1.0-k);
    const double denominator = pointcloud ? kprime : pow(kprime, d);
    const double minrhoprime = minrho / denominator;

    if (rhoprime == 0.0) {
      rhoprime = std::max(rho, minrhoprime);
    } else {
      if (rhoprime < minrhoprime - 1e-8) {
        fprintf(stderr, "Warning: rhoprime small (%g); we may not terminate"
            " (we need %g*%g > %g)\n", rhoprime, k, rhoprime, minrho);
      }
    }

    // TODO: find appropriate values for slivers
    // Certainly, slivers are ignored in 2d.
    if (d < 3) {
      sigma = 0.0;
    }
  }
};

#endif

---