From e96928e8bac56edf427984f362897e6a237ca781 Mon Sep 17 00:00:00 2001 From: curt Date: Mon, 5 Jun 2000 11:26:22 +0000 Subject: [PATCH] Continued work on polygon tesselation. --- src/Lib/Geometry/poly_support.cxx | 131 +++++++++++++++++++++++------- 1 file changed, 102 insertions(+), 29 deletions(-) diff --git a/src/Lib/Geometry/poly_support.cxx b/src/Lib/Geometry/poly_support.cxx index e7b3ac41..e0a6ea99 100644 --- a/src/Lib/Geometry/poly_support.cxx +++ b/src/Lib/Geometry/poly_support.cxx @@ -421,31 +421,66 @@ triele_list polygon_tesselate( const FGPolygon poly, const int contour ) { // basic triangulation of a polygon with out adding points or // splitting edges and without regard for holes -static triele_list contour_tesselate( const point_list contour ) { +static triele_list contour_tesselate( FGContourNode *node, const FGPolygon &p, + const FGPolygon &hole_polys, + const point_list &hole_pts ) { // triangle list triele_list elelist; struct triangulateio in, out, vorout; - int counter; + int counter, start, end; + + // list of points + int contour_num = node->get_contour_num(); + point_list contour = p.get_contour( contour_num ); - // point list double max_x = contour[0].x(); - in.numberofpoints = contour.size(); + + int total_pts = contour.size(); + for ( int i = 0; i < hole_polys.contours(); ++i ) { + total_pts += hole_polys.contour_size( i ); + } + + in.numberofpoints = total_pts; in.pointlist = (REAL *) malloc(in.numberofpoints * 2 * sizeof(REAL)); - for ( int i = 0; i < in.numberofpoints; ++i ) { - in.pointlist[2*i] = contour[i].x(); - in.pointlist[2*i + 1] = contour[i].y(); + counter = 0; + for ( int i = 0; i < (int)contour.size(); ++i ) { + in.pointlist[2*counter] = contour[i].x(); + in.pointlist[2*counter + 1] = contour[i].y(); if ( contour[i].x() > max_x ) { max_x = contour[i].x(); } + ++counter; + } + + for ( int i = 0; i < hole_polys.contours(); ++i ) { + point_list hole_contour = hole_polys.get_contour( i ); + for ( int j = 0; j < (int)hole_contour.size(); ++j ) { + in.pointlist[2*counter] = hole_contour[j].x(); + in.pointlist[2*counter + 1] = hole_contour[j].y(); + if ( hole_contour[j].x() > max_x ) { + max_x = hole_contour[j].x(); + } + ++counter; + } } in.numberofpointattributes = 1; in.pointattributelist = (REAL *) malloc(in.numberofpoints * in.numberofpointattributes * sizeof(REAL)); - for ( int i = 0; i < in.numberofpoints * in.numberofpointattributes; ++i) { - in.pointattributelist[i] = contour[i].z(); + counter = 0; + for ( int i = 0; i < (int)contour.size(); ++i ) { + in.pointattributelist[counter] = contour[i].z(); + ++counter; + } + + for ( int i = 0; i < hole_polys.contours(); ++i ) { + point_list hole_contour = hole_polys.get_contour( i ); + for ( int j = 0; j < (int)hole_contour.size(); ++j ) { + in.pointattributelist[counter] = hole_contour[j].z(); + ++counter; + } } in.pointmarkerlist = (int *) malloc(in.numberofpoints * sizeof(int)); @@ -457,27 +492,47 @@ static triele_list contour_tesselate( const point_list contour ) { in.numberoftriangles = 0; // segment list - in.numberofsegments = contour.size(); + in.numberofsegments = in.numberofpoints; in.segmentlist = (int *) malloc(in.numberofsegments * 2 * sizeof(int)); in.segmentmarkerlist = (int *) malloc(in.numberofsegments * sizeof(int)); counter = 0; - for ( int i = 0; i < in.numberofsegments - 1; ++i ) { + start = 0; + end = contour.size() - 1; + for ( int i = 0; i < end; ++i ) { in.segmentlist[counter++] = i; in.segmentlist[counter++] = i + 1; in.segmentmarkerlist[i] = 0; } - in.segmentlist[counter++] = in.numberofsegments - 1; - in.segmentlist[counter++] = 0; - in.segmentmarkerlist[in.numberofsegments - 1] = 0; + in.segmentlist[counter++] = end; + in.segmentlist[counter++] = start; + in.segmentmarkerlist[contour.size() - 1] = 0; + + for ( int i = 0; i < hole_polys.contours(); ++i ) { + point_list hole_contour = hole_polys.get_contour( i ); + start = end + 1; + end = start + hole_contour.size() - 1; + for ( int j = 0; j < (int)hole_contour.size() - 1; ++j ) { + in.segmentlist[counter++] = j + start; + in.segmentlist[counter++] = j + start + 1; + in.segmentmarkerlist[i] = 0; + } + in.segmentlist[counter++] = end; + in.segmentlist[counter++] = start; + in.segmentmarkerlist[contour.size() - 1] = 0; + } // hole list - in.numberofholes = 1; + in.numberofholes = hole_pts.size() + 1; in.holelist = (REAL *) malloc(in.numberofholes * 2 * sizeof(REAL)); // outside of polygon counter = 0; in.holelist[counter++] = max_x + 1.0; in.holelist[counter++] = 0.0; + for ( int i = 0; i < (int)hole_pts.size(); ++i ) { + in.holelist[counter++] = hole_pts[i].x(); + in.holelist[counter++] = hole_pts[i].y(); + } // region list in.numberofregions = 0; in.regionlist = (REAL *) NULL; @@ -505,7 +560,7 @@ static triele_list contour_tesselate( const point_list contour ) { vorout.normlist = (REAL *) NULL; // Needed only if -v switch used. // TEMPORARY - // write_tri_data(&in); + write_tri_data(&in); // Triangulate the points. Switches are chosen to read and write // a PSLG (p), number everything from zero (z), and produce an @@ -520,7 +575,7 @@ static triele_list contour_tesselate( const point_list contour ) { triangulate( (char *)tri_options.c_str(), &in, &out, &vorout ); // TEMPORARY - write_tri_data(&out); + // write_tri_data(&out); // now copy the results back into the corresponding FGTriangle // structures @@ -568,6 +623,7 @@ static triele_list contour_tesselate( const point_list contour ) { } +#if 0 // Find a point inside the polygon without regard for holes static Point3D point_inside_hole( point_list contour ) { @@ -589,31 +645,42 @@ static Point3D point_inside_hole( point_list contour ) { return center; } +#endif // Find a point inside a specific polygon contour taking holes into // consideration static Point3D point_inside_contour( FGContourNode *node, const FGPolygon &p ) { - point_list holes; - holes.clear(); + int contour_num; + + FGPolygon hole_polys; + hole_polys.erase(); + + point_list hole_pts; + hole_pts.clear(); // build list of hole points for ( int i = 0; i < node->get_num_kids(); ++i ) { - int contour_num = node->get_kid(i)->get_contour_num(); - holes.push_back( p.get_point_inside( contour_num ) ); + contour_num = node->get_kid(i)->get_contour_num(); + hole_pts.push_back( p.get_point_inside( contour_num ) ); + point_list contour = p.get_contour( contour_num ); + hole_polys.add_contour( contour, 1 ); } - triele_list elelist = polygon_tesselate( p, contour ); + triele_list elelist = contour_tesselate( node, p, hole_polys, hole_pts ); if ( elelist.size() <= 0 ) { cout << "Error polygon triangulated to zero triangles!" << endl; exit(-1); } - FGTriEle t = elelist[0]; - Point3D p1 = p.get_pt( contour, t.get_n1() ); - Point3D p2 = p.get_pt( contour, t.get_n2() ); - Point3D p3 = p.get_pt( contour, t.get_n3() ); +#error what is your point list here? + FGTriEle t = elelist[0]; + contour_num = node->get_contour_num(); + Point3D p1 = p.get_pt( contour_num, t.get_n1() ); + Point3D p2 = p.get_pt( contour_num, t.get_n2() ); + Point3D p3 = p.get_pt( contour_num, t.get_n3() ); + cout << " " << p1 << endl << " " << p2 << endl << " " << p3 << endl; Point3D m1 = ( p1 + p2 ) / 2; Point3D m2 = ( p1 + p3 ) / 2; @@ -633,7 +700,13 @@ static void calc_point_inside( FGContourNode *node, FGPolygon &p ) { } } - Point3D pi = point_inside_contour( node, p ); + int contour_num = node->get_contour_num(); + if ( contour_num >= 0 ) { + Point3D pi = point_inside_contour( node, p ); + cout << endl << "point inside(" << contour_num << ") = " << pi + << endl << endl; + p.set_point_inside( contour_num, pi ); + } } @@ -746,6 +819,7 @@ void calc_points_inside( FGPolygon& p ) { // contour/hole calc_point_inside( ct, p ); +#if 0 // first calculate an inside point for all holes cout << "calculating points for poly with contours = " << p.contours() << endl; @@ -765,8 +839,6 @@ void calc_points_inside( FGPolygon& p ) { } } - exit(0); - // next calculate an inside point for all non-hole contours taking // into consideration the holes for ( int i = 0; i < p.contours(); ++i ) { @@ -776,5 +848,6 @@ void calc_points_inside( FGPolygon& p ) { p.set_point_inside( i, inside_pt ); } } +#endif }