FFillPolygonObj* TopoFace::polygon() {
int npt = npts();
float* xp = (float*)xpoints();
float* yp = (float*)ypoints();
FFillPolygonObj* poly = new FFillPolygonObj(xp, yp, npt);
return poly;
}
/** Get the i-th parameter.
* @param i :: The parameter index
* @return the value of the requested parameter
*/
double ChFun::getParameter(size_t i)const
{
if (i >= nParams())
{
throw std::out_of_range("ChFun parameter index out of range.");
}
return ypoints()[i];
}
double TopoFace::area() {
int i,j;
double area = 0;
int N = npts();
const float* x = xpoints();
const float* y = ypoints();
for (i=0;i<N;i++) {
j = (i + 1) % N;
area += x[i] * y[j];
area -= y[i] * x[j];
}
area /= 2;
return(area < 0 ? -area : area);
}
int delaunayTriang(const vector<Vector2d> &points,
vector<Triangle> &triangles,
double z)
{
#define PTRIANGULATOR 0
#if PTRIANGULATOR
vector<Vector2d> spoints = simplified(points, 1);
uint npoints = spoints.size();
vector<double> xpoints(npoints);
vector<double> ypoints(npoints);
for (uint i = 0; i < npoints; i++) {
xpoints[i] = spoints[npoints-i-1].x();
ypoints[i] = spoints[npoints-i-1].y();
}
polytri::PolygonTriangulator pt(xpoints, ypoints);
const polytri::PolygonTriangulator::Triangles * tr = pt.triangles();
uint ntr = tr->size();
cerr << npoints << " -> " << ntr << endl;
triangles.resize(ntr);
uint itri=0;
for (polytri::PolygonTriangulator::Triangles::const_iterator itr = tr->begin();
itr != tr->end(); ++itr) {
const polytri::PolygonTriangulator::Triangle t = *itr;
triangles[itri] = Triangle(Vector3d(xpoints[t[0]], ypoints[t[0]], z),
Vector3d(xpoints[t[1]], ypoints[t[1]], z),
Vector3d(xpoints[t[2]], ypoints[t[2]], z));
itri++;
}
return ntr;
#endif
// struct triangulateio in;
// in.numberofpoints = npoints;
// in.numberofpointattributes = (int)0;
// in.pointlist =
// in.pointattributelist = NULL;
// in.pointmarkerlist = (int *) NULL;
// in.numberofsegments = 0;
// in.numberofholes = 0;
// in.numberofregions = 0;
// in.regionlist = (REAL *) NULL;
// delclass = new piyush;
// piyush *pdelclass = (piyush *)delclass;
// triswitches.push_back('\0');
// char *ptris = &triswitches[0];
// pmesh = new piyush::__pmesh;
// pbehavior = new piyush::__pbehavior;
// piyush::__pmesh * tpmesh = (piyush::__pmesh *) pmesh;
// piyush::__pbehavior * tpbehavior = (piyush::__pbehavior *) pbehavior;
// pdelclass->triangleinit(tpmesh);
// pdelclass->parsecommandline(1, &ptris, tpbehavior);
// pdelclass->transfernodes(tpmesh, tpbehavior, in.pointlist,
// in.pointattributelist,
// in.pointmarkerlist, in.numberofpoints,
// in.numberofpointattributes);
// tpmesh->hullsize = pdelclass->delaunay(tpmesh, tpbehavior);
// /* Ensure that no vertex can be mistaken for a triangular bounding */
// /* box vertex in insertvertex(). */
// tpmesh->infvertex1 = (piyush::vertex) NULL;
// tpmesh->infvertex2 = (piyush::vertex) NULL;
// tpmesh->infvertex3 = (piyush::vertex) NULL;
// /* Calculate the number of edges. */
// tpmesh->edges = (3l * tpmesh->triangles.items + tpmesh->hullsize) / 2l;
// pdelclass->numbernodes(tpmesh, tpbehavior);
/////////////////////////////////////////////// triangle++ crap
// typedef reviver::dpoint <double, 2> Point;
// vector<Point> p(points.size());
// for (uint i = 0; i < p.size(); i++) {
// p[i] = Point(points[i].x(),points[i].y());
// }
// tpp::Delaunay del(p);
// /*
// -p Triangulates a Planar Straight Line Graph (.poly file).
// -r Refines a previously generated mesh.
// -q Quality mesh generation. A minimum angle may be specified.
// -a Applies a maximum triangle area constraint.
// -u Applies a user-defined triangle constraint.
// -A Applies attributes to identify triangles in certain regions.
// -c Encloses the convex hull with segments.
// -D Conforming Delaunay: all triangles are truly Delaunay.
// -j Jettison unused vertices from output .node file.
// -e Generates an edge list.
// -v Generates a Voronoi diagram.
// -n Generates a list of triangle neighbors.
// -g Generates an .off file for Geomview.
// -B Suppresses output of boundary information.
// -P Suppresses output of .poly file.
// -N Suppresses output of .node file.
// -E Suppresses output of .ele file.
// -I Suppresses mesh iteration numbers.
// -O Ignores holes in .poly file.
// -X Suppresses use of exact arithmetic.
// -z Numbers all items starting from zero (rather than one).
// -o2 Generates second-order subparametric elements.
// -Y Suppresses boundary segment splitting.
// -S Specifies maximum number of added Steiner points.
// -i Uses incremental method, rather than divide-and-conquer.
// -F Uses Fortune's sweepline algorithm, rather than d-and-c.
// -l Uses vertical cuts only, rather than alternating cuts.
// -s Force segments into mesh by splitting (instead of using CDT).
// -C Check consistency of final mesh.
// -Q Quiet: No terminal output except errors.
// */
// string switches = "pq0DzQ";
// del.Triangulate(switches);
// int ntri = del.ntriangles();
// if (ntri>0) {
// triangles.resize(ntri);
// uint itri=0;
// for (tpp::Delaunay::fIterator dit = del.fbegin(); dit != del.fend(); ++dit) {
// Point pA = del.point_at_vertex_id(del.Org (dit));
// Point pB = del.point_at_vertex_id(del.Dest(dit));
// Point pC = del.point_at_vertex_id(del.Apex(dit));
// triangles[itri] = Triangle(Vector3d(pA[0],pA[1],z),
// Vector3d(pB[0],pB[1],z),
// Vector3d(pC[0],pC[1],z));
// // Vector2d vA = points[del.Org (dit)];
// // Vector2d vB = points[del.Dest(dit)];
// // Vector2d vC = points[del.Apex(dit)];
// // triangles[itri] = Triangle(Vector3d(vA.x(),vA.y(),z),
// // Vector3d(vB.x(),vB.y(),z),
// // Vector3d(vC.x(),vC.y(),z));
// itri++;
// }
// }
// return ntri;
return 0;
}
