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; }