$search

genmesh.cc

Go to the documentation of this file.

/*
  James R. Diebel
  Stanford University

  Started: 30 August 2004
  Last revised: 31 Sugust 2004

  genmesh.cc - program to generate synthetic meshes

  Depends on:
  - Mesh class (mesh.hh)
  -- Vec3d class (vec3d.hh)
  -- Vert class (vert.hh)
  -- Edge class (edge.hh)
  -- Face class (face.hh)
  - Timer class (timer.hh)
*/

#include <iostream>
#include <fstream>
#include <stdlib.h>
#include <time.h>
#include "bmtk/mesh.hh"
#include "bmtk/timer.hh"
#include "bmtk/uspline.hh"

using namespace std;
using namespace bmtk;

// prototypes
float grand(float mean, float std);
Mesh* genPlane(int n, float s2);
Mesh* genCorner(int n, float s2);

int main (int argc, char *argv[]) {
  // variable declarations
  int type;
  int paramCount[] = {2,2};
  float* params;
  float temp;
  Mesh* m;

  // if bad command line args, give usage instructions and exit
  if (argc < 3) {
    cout << endl
         << "Usage: genmesh <parameter file> <output.msh>" << endl;
    exit(1);
  }

  // seed random number generator
  srand(int(clock()));

  // read parameter file
  ifstream fin(argv[1]);
  if (!fin) exit(1);
  fin >> type;
  params = new float[paramCount[type]];
  for (int i=0;i<paramCount[type];i++) {fin >> temp; params[i] = temp;}

  // generate mesh by calling appropriate function
  switch(type) {
  case 0: m = genPlane(int(params[0]),params[1]); break;
  case 1: m = genCorner(int(params[0]),params[1]); break;
  default:
    cout << "Mesh type " << type << " is not defined, exiting..." << endl;
    exit(1);
  }

  delete params;

  // save mesh to output file
  m->writeMesh(argv[2]);
}

float grand(float mean, float std) {
  const double norm = 1.0 / (RAND_MAX + 1.0);
  double u = 1.0 - rand() * norm;                  /* can't let u == 0 */
  double v = rand() * norm;
  double z = sqrt(-2.0 * log(u)) * cos(2.0 * M_PI * v);
  return mean + std * z;
}

Mesh* genPlane(int n, float s2) {
  cout << "Generating planar square with " << n
       << " vertices along each edge" << endl;
  Mesh* m = new Mesh();

  // allocate memory for vertex and face lists
  float* v = new float[3*n*n];
  int* f = new int[6*(n-1)*(n-1)];

  // create vertex and triangle lists
  for (int i=0,k=0,l=0;i<n;i++) {
    for (int j=0;j<n;j++,k++) {
      // create array of vertices on x-y plane
      v[3*k] = float(i);
      v[3*k+1] = float(j);
      v[3*k+2] = grand(0,s2);

      // create faces for current square
      if (i<(n-1) && j<(n-1)) {
        f[3*l] = k;
        f[3*l+1] = k+n;
        f[3*l+2] = k+1;
        l++;
        f[3*l] = k+1;
        f[3*l+1] = k+n;
        f[3*l+2] = k+n+1;
        l++;
      }

      if (i==n-1 && j==n-1) cout << k << " " << l << endl;
    }
  }

  // generate mesh from those lists
  m->buildFrom(v,n*n,f,2*(n-1)*(n-1));

  delete [] v;
  delete [] f;
  return m;
}

Mesh* genCorner(int n, float s2) {
  cout << "Generating simple corner with " << n
       << " vertices along each edge" << endl;
  Mesh* m = new Mesh();

  // allocate memory for vertex and face lists
  int nv = (2*n-1)*n + (n-1)*(n-1);
  int nf = 2*(2*n-2)*(n-1) + 2*(n-1)*(n-1);
  float* v = new float[3*nv];
  int* f = new int[3*nf];

  // create vertex and triangle lists
  int k=0,l=0;
  for (int i=0;i<(2*n-1);i++) {
    // create walls
    for (int j=0;j<n;j++,k++) {
      // create array of vertices on x-y plane
      if (i<n) {
        v[3*k] = float(i);
        v[3*k+1] = float(j);
        v[3*k+2] = grand(0,s2);
      } else {
        v[3*k] =  float(n-1) + grand(0,s2);
        v[3*k+1] = float(j);
        v[3*k+2] = float(i-n+1);
      }

      // create faces for current square
      if (i<(2*n-2) && j<(n-1)) {
        f[3*l] = k;
        f[3*l+1] = k+n;
        f[3*l+2] = k+1;
        l++;
        f[3*l] = k+1;
        f[3*l+1] = k+n;
        f[3*l+2] = k+n+1;
        l++;
      }
    }
  }

  // create floor
  for (int i=0;i<(n-1);i++) {
    for (int j=1;j<n;j++,k++) {
      v[3*k] = float(i);
      v[3*k+1] = grand(0,s2);
      v[3*k+2] = float(j);

      if (j==1 && i<(n-2)) {
        f[3*l] = k;
        f[3*l+1] = k+n-1;
        f[3*l+2] = i*n;
        l++;
        f[3*l] = k+n-1;
        f[3*l+1] = (i+1)*n;
        f[3*l+2] = i*n;
        l++;
      }
      if (j==1 && i==(n-2)){
        f[3*l] = k;
        f[3*l+1] = n*n;
        f[3*l+2] = (n-2)*n;
        l++;
        f[3*l] = n*n;
        f[3*l+1] = (n-1)*n;
        f[3*l+2] = (n-2)*n;
        l++;
      }
      if (j>1 && i==(n-2)) {
        f[3*l] = k;
        f[3*l+1] = (n+j-1)*n;
        f[3*l+2] = k-1;
        l++;
        f[3*l] = (n+j-1)*n;
        f[3*l+1] = (n+j-2)*n;
        f[3*l+2] = k-1;
        l++;
      }
      if (j>1 && i<(n-2)) {
        f[3*l] = k;
        f[3*l+1] = k+(n-1);
        f[3*l+2] = k-1;
        l++;
        f[3*l] = k+(n-1);
        f[3*l+1] = k+(n-1)-1;
        f[3*l+2] = k-1;
        l++;
      }
      /*if (i==n-2 && j==n-1)
        cout <<"("<<i<<","<<j<<") -> "<<k<<"/"<< nv<<", "<<l<<"/"<<nf<<endl;*/
    }
  }

  // generate mesh from those lists
  m->buildFrom(v,nv,f,nf);

  // fix covariances to agree with noise
  float big = 100;
  k=0,l=0;
  for (int i=0;i<(2*n-1);i++) {
    for (int j=0;j<n;j++,k++) {
      if (i<n) {
        Vec3d temp(big,big,0.1);
        m->v[k].iCov = Mat3x3(temp);
      } else if (i==n) {
        Vec3d temp(1,big,1);
        m->v[k].iCov = Mat3x3(temp);
      } else {
        Vec3d temp(0.1,big,big);
        m->v[k].iCov = Mat3x3(temp);
      }
    }
  }

  for (int i=0;i<(n-1);i++) {
    for (int j=1;j<n;j++,k++) {
      Vec3d temp(big,0.1,big);
      m->v[k].iCov = Mat3x3(temp);
    }
  }

  delete [] v;
  delete [] f;
  return m;
}

---

bmtk
Author(s): Benjamin Pitzer
autogenerated on Mon Mar 4 11:05:51 2013