跨平台二维绘图程序（四）——多边形绘制

前三篇内容的基础上，可以绘制出如下的图形：



这一篇介绍如何绘制多边形。

（1）GDI通过API函数Polygon或者PolyPolygon就能够绘制不规则的多边形，包括自交带内洞，而GLES只能绘制三角形；

（2）多边形三角化有个开源的triangle.h，这里推荐下：http://compgeom.com/~piyush/scripts/triangle/triangle_8h-source.html

（3）三角化的时候要注意几个问题。多边形点中不可以有重复坐标点，否则会出错；多边形坐标点数不可过少，否则出错。

以下是多边形三角化的一个类：

struct Triangle
{
std::vector<Coor> cos;
void set(const std::vector<Coor>& polygon)
{
cos.clear();
cos.insert(cos.end(), polygon.begin(), polygon.end());
}

void set(const Coor& A, const Coor& B, const Coor& C)
{
cos.clear();
cos.push_back(A);
cos.push_back(B);
cos.push_back(C);
}
};

class WithInnerTriangulation
{// 2D Coor
public:
Coor getCenter(const std::vector<Coor>& cos)
{
Coor center;

if (cos.size() == 3)
{
for (size_t j = 0; j < 3; ++j)
{
center.x += cos[j].x;
center.y += cos[j].y;
}
}
else
{
struct triangulateio in, out;
triangulateioinit(&in);
triangulateioinit(&out);

int numPoints = cos.size();
int numSeg = cos.size();

in.numberofpoints = numPoints;
in.numberofpointattributes = 0;
in.pointlist = (REAL*)malloc(sizeof(REAL) * in.numberofpoints * 2);

for (size_t i = 0; i < cos.size(); i++)
{
in.pointlist[i * 2 + 0] = cos[i].x;
in.pointlist[i * 2 + 1] = cos[i].y;
}

in.numberofsegments = numSeg;
in.segmentlist = (int*)malloc(sizeof(int) * in.numberofsegments * 2);

size_t i = 0;
for (i = 0; i < cos.size() - 1; i++)
{
in.segmentlist[i * 2 + 0] = i;
in.segmentlist[i * 2 + 1] = i + 1;
}
in.segmentlist[i * 2 + 0] = i;
in.segmentlist[i * 2 + 1] = 0;

triangulate("pzFQ", &in, &out, NULL);

int count = out.numberoftriangles * 3;
if (count > 3)
count = 3;

for (int i = 0; i < count; i++)
{
int coor_index = out.trianglelist[i];
center.x += out.pointlist[coor_index * 2];
center.y += out.pointlist[coor_index * 2 + 1];
}

triangulateiofree(&out, 0);
triangulateiofree(&in, 1);
}

center.x /= 3;
center.y /= 3;

return center;
}

bool transform(const std::vector< std::vector<Coor> >& polys2,
std::vector<Triangle>& triangles)
{
struct triangulateio in, out;
triangulateioinit(&in);
triangulateioinit(&out);

std::vector< std::vector<Coor> > polys;
for (size_t i = 0; i < polys2.size(); ++i)
{
std::vector<Coor> temp;
GeoAlgorithm::kick_overlay_dot(polys2[i],
temp,
false);

if (temp.size() >= 3)
{
// 点数过少会导致后面的triangulate函数崩溃
polys.push_back(temp);
}
}

if (polys.size() == 0)
{
return false;
}

int numPoints = 0;
int numSeg = 0;
std::vector<Coor> centers;
for (size_t i = 0; i < polys.size(); i++)
{
numSeg += polys[i].size();
Coor center = getCenter(polys[i]);
centers.push_back(center);
}
numPoints = numSeg;

in.numberofpoints = numPoints;
in.numberofpointattributes = 0;
in.pointlist = (REAL*)malloc(sizeof(REAL) * in.numberofpoints * 2);

int pointc = 0;
for (size_t i = 0; i < polys.size(); i++)
{
for (size_t j = 0; j < polys[i].size(); j++, pointc++)
{
in.pointlist[pointc * 2 + 0] = polys[i][j].x;
in.pointlist[pointc * 2 + 1] = polys[i][j].y;
}
}

in.numberofsegments = numSeg;
in.segmentlist = (int*)malloc(sizeof(int) * in.numberofsegments * 2);
pointc = 0;
for (size_t i = 0; i < polys.size(); i++, pointc++)
{
int first = pointc;
for (size_t j = 0; j < polys[i].size() - 1; j++, pointc++)
{
in.segmentlist[pointc * 2 + 0] = pointc;
in.segmentlist[pointc * 2 + 1] = pointc + 1;
}
in.segmentlist[pointc * 2 + 0] = pointc;
in.segmentlist[pointc * 2 + 1] = first;
}

in.numberofregions = 0;
in.numberofholes = centers.size() - 1;
in.holelist = (REAL*)malloc(sizeof(REAL) * in.numberofholes * 2);

for (size_t i = 1; i < centers.size(); i++)
{
in.holelist[(i - 1) * 2 + 0] = centers[i].x;
in.holelist[(i - 1) * 2 + 1] = centers[i].y;
}

triangulate("pzFQ", &in, &out, NULL);
// verify the mesh a bit
if (out.numberofpoints - out.numberofedges + out.numberoftriangles !=
2 - centers.size())
{
cout << endl << "epc wrong" << endl;
}
std::vector<Coor> cos;
int numberofvertex, coor_index;
numberofvertex = out.numberoftriangles * 3;
for (int i = 0; i < numberofvertex; i++)
{
coor_index = out.trianglelist[i];
Coor co;
co.x = out.pointlist[coor_index * 2];
co.y = out.pointlist[coor_index * 2 + 1];

cos.push_back(co);
}

for (int i = 0; i < out.numberoftriangles; ++i)
{
Triangle tri;
tri.set(cos[3 * i], cos[3 * i + 1], cos[3 * i + 2]);
triangles.push_back(tri);
}

triangulateiofree(&out, 0);
triangulateiofree(&in, 1);

return true;
}
};


有了这样的三角化类，就可以将不规则多边形（如凹多边形，带内洞多边形）转换为三角形，然后将三角形传递到VBO中。
std::vector< std::vector<Coor> > polys;
int32_t idx = 0;
for (int32_t i = 0; i < pc; ++i)
{
std::vector<Coor> pts;
for (int32_t j = 0; j < ptsc[i]; ++j)
{
Coor cc;
cc.x = pco[idx].x - m_vo.s_left;
cc.y = pco[idx].y - m_vo.s_bottom;
cc.z = 0.f;

pts.push_back(cc);
idx++;
}
polys.push_back(pts);
}

{
WithInnerTriangulation wit;
std::vector<Triangle> triangles;
wit.transform(polys, triangles);
size_t tc = triangles.size();
if (tc)
{
auto tri = triangles.begin();
while (tri != triangles.end())
{
PointF cc;
cc.z = m_vo.s_zIndex;
cc.x = tri->cos[0].x; cc.y = tri->cos[0].y;
m_vo.polyBuffer.cos.push_back(cc);

cc.x = tri->cos[1].x; cc.y = tri->cos[1].y;
m_vo.polyBuffer.cos.push_back(cc);

cc.x = tri->cos[2].x; cc.y = tri->cos[2].y;
m_vo.polyBuffer.cos.push_back(cc);

m_vo.polyBuffer.cols.push_back(colF);
m_vo.polyBuffer.cols.push_back(colF);
m_vo.polyBuffer.cols.push_back(colF);

++tri;
}
}
}

这样多边形就能够渲染出来了！