如何在C ++
我正在对一个对象进行三角测量（最终，我想实现一个Delaunay三角测量，但三角测量甚至在合法化边缘之前也不起作用，所以我想首先关注一个简单的三角测量）。我在下面列出了相关代码。我正在实施类似于Mark de Berg的“Computation Geometry：Algorithms and Application Third Edition”中描述的三角测量方法等。给出的伪代码如下（如果需要，我将删除它）：
注意：我通过创建边界三角形来修改伪代码，而不是使用“词典的最高点P”，因为我不太确定如何定义p -1 和p -2 正如教科书所说的那样“象征性地”定义它们而不是定义确切的单位（我当然可能误解了它试图说的是公平的）。此外，合法化不是我的代码的一部分（但是）因为这对于Delaunay三角测量是必要的，但我想确保简单的三角测量按预期工作。
问题在于我得到了一些三角形，例如
，其中蓝线来自原始多边形。
这些行中的一些不会被添加，因为它们是点p0，p1和p2的三角形的一部分，我没有在findSmallest方法中添加它们。然而，如果我也添加这些三角形，我会得到这样的结果：
（注意p0，p1和p2超出了图片的范围）。来自原始多边形的一些线（此时为绿色）仍未添加到三角测量中。我不确定我哪里出错了。
我希望代码清楚但我会解释一些方法/结构以防万一：
TriPoint
是Point结构的子代。
p0, p1, p2
是三角形，形成多边形周围的边界三角形。我从this post得到了这个想法。
contains(Point p)
返回true。
findCommonTriangle(TriPoint *a, TriPoint *b, Triangle *t)
沿着边缘ab返回t的三角形事件。 （我不是用Edges来计算三角测量，所以我决定以这种方式得到事件三角形。）
isOnTriangle(Point s)
，如果该点在边缘ab上则返回1，如果该点在边缘bc上则返回2，如果该点在边缘cd上则返回3。如果它在三角形内，则返回0.
三角测量本身的代码位于：
#include <GL\glew.h>
#include <GL\freeglut.h>
#include <iostream>
#include <array>
#include <vector>
#include "predicates.h"
struct Point {
float x, y;
Point() { }
Point(float a, float b) {
x = a;
y = b;
}
};
struct Triangle;
struct Triangulation;
std::vector<Triangulation *> triangulations;
struct TriPoint : Point {
std::vector<Triangle *> triangles;
TriPoint() { };
int index;
TriPoint(Point a) {
x = a.x;
y = a.y;
}
TriPoint(float x, float y) : Point(x, y) {};
void removeTriangle(Triangle *t) {
for (size_t i = 0; i < triangles.size(); i++) {
if (triangles[i] == t) {
triangles.erase(triangles.begin() + i);
}
}
}
void addTriangle(Triangle *t) {
triangles.push_back(t);
}
};
double pointInLine(Point *a, Point *b, Point *p) {
REAL *A, *B, *P;
A = new REAL[2];
B = new REAL[2];
P = new REAL[2];
A[0] = a->x;
A[1] = a->y;
B[0] = b->x;
B[1] = b->y;
P[0] = p->x;
P[1] = p->y;
double orient = orient2d(A, B, P);
delete(A);
delete(B);
delete(P);
return orient;
}
struct Triangle {
TriPoint *a, *b, *c;
std::vector<Triangle *> children;
Triangle() { };
Triangle(TriPoint *x, TriPoint *y, TriPoint *z) {
a = x;
b = y;
c = z;
orientTri();
x->addTriangle(this);
y->addTriangle(this);
z->addTriangle(this);
}
bool hasChildren() {
return children.size() != 0;
}
void draw() {
glBegin(GL_LINE_STRIP);
glVertex2f(a->x, a->y);
glVertex2f(b->x, b->y);
glVertex2f(c->x, c->y);
glVertex2f(a->x, a->y);
glEnd();
}
bool contains(Point s) {
float as_x = s.x - a->x;
float as_y = s.y - a->y;
bool s_ab = (b->x - a->x)*as_y - (b->y - a->y)*as_x > 0;
if ((c->x - a->x)*as_y - (c->y - a->y)*as_x > 0 == s_ab) return false;
if ((c->x - b->x)*(s.y - b->y) - (c->y - b->y)*(s.x - b->x) > 0 != s_ab) return false;
return true;
}
int isOnTriangle(Point p) {
//Return -1 if outside
//Returns 1 if on AB
//Returns 2 if on BC
//Returns 3 if on CA
//Returns 4 if on B
//Returns 5 if on C
//Returns 6 if on A
double res1 = pointInLine(b, a, &p);
double res2 = pointInLine(c, b, &p);
double res3 = pointInLine(a, c, &p);
/*If triangles are counter-clockwise oriented then a point is inside
the triangle if the three 'res' are < 0, at left of each oriented edge
*/
if (res1 > 0 || res2 > 0 || res3 > 0)
return -1; //outside
if (res1 < 0) {
if (res2 < 0) {
if (res3 < 0) {
return 0; //inside
} else { //res3 == 0
return 3; //on edge3
}
} else { //res2 == 0
if (res3 == 0) {
return 5; //is point shared by edge2 and edge3
}
return 2; //on edge2
}
} else { //res1 == 0
if (res2 == 0) {
return 4; //is point shared by edge1 and edge2
} else if (res3 == 0) {
return 6; //is point shared by edge1 and 3
}
return 1; //on edge 1
}
}
TriPoint *getThirdPoint(TriPoint *x, TriPoint *y) {
if (a != x && a != y)
return a;
if (b != x && b != y)
return b;
return c;
}
bool hasPoint(TriPoint *p) {
return a == p || b == p || c == p;
}
void orientTri() {
REAL *A, *B, *C;
A = new REAL[2];
B = new REAL[2];
C = new REAL[2];
A[0] = a->x;
A[1] = a->y;
B[0] = b->x;
B[1] = b->y;
C[0] = c->x;
C[1] = c->y;
double orientation = orient2d(A, B, C);
if (orientation < 0) {
TriPoint *temp = a;
a = b;
b = temp;
}
delete(A);
delete(B);
delete(C);
}
};
struct Poly {
std::vector<Point> points;
bool selected = false;
};
Triangle *findCommonTriangle(TriPoint *a, TriPoint *b, Triangle *t) {
//Returns a triangle shared by a and b incident to t
for (Triangle *aTri : a->triangles) {
for (Triangle *bTri : b->triangles) {
if (aTri == bTri && aTri != t) {
return aTri;
}
}
}
return NULL;
}
struct Triangulation {
std::vector<Point> points;
std::vector<Triangle *> triangles;
float xMin = 9999;
float xMax = 0;
float yMin;
float yMax;
Triangulation() { };
Triangulation(Poly p) {
points = p.points;
sort();
triangulate();
}
void draw() {
for (Triangle *t : triangles) {
t->draw();
}
}
void sort() {
//Sort by y-value in ascending order.
//If y-values are equal, sort by x in ascending order.
for (size_t i = 0; i < points.size() - 1; i++) {
if (points[i].x < xMin) {
xMin = points[i].x;
}
if (points[i].x > xMax) {
xMax = points[i].x;
}
int index = i;
for (size_t j = i; j < points.size(); j++) {
if (points[index].y > points[j].y) {
index = j;
} else if (points[index].y == points[j].y) {
if (points[index].x > points[j].x) {
index = j;
}
}
}
std::swap(points[i], points[index]);
}
yMin = points[0].y;
yMax = points[points.size() - 1].y;
std::random_shuffle(points.begin(), points.end());
}
void triangulate() {
Triangle *root;
float dx = xMax - xMin;
float dy = yMax - yMin;
float deltaMax = std::max(dx, dy);
float midx = (xMin + xMax) / 2.f;
float midy = (yMin + yMax) / 2.f;
TriPoint *p0;
TriPoint *p1;
TriPoint *p2;
p0 = new TriPoint(midx - 2 * deltaMax, midy - deltaMax);
p1 = new TriPoint(midx, midy + 2 * deltaMax);
p2 = new TriPoint(midx + 2 * deltaMax, midy - deltaMax);
p0->index = 0;
p1->index = -1;
p2->index = -2;
root = new Triangle(p0, p1, p2);
for (size_t i = 0; i < points.size(); i++) {
TriPoint *p = new TriPoint(points[i]);
p->index = i + 1;
Triangle *temp = root;
double in;
while (temp->hasChildren()) {
for (size_t j = 0; j < temp->children.size(); j++) {
in = temp->children[j]->isOnTriangle(points[i]);
if (in >= 0) {
temp = temp->children[j];
break;
}
}
}
in = temp->isOnTriangle(points[i]);
if (in > 0 ) { //Boundary
if (in == 1) { //AB
Triangle *other = findCommonTriangle(temp->a, temp->b, temp);
TriPoint *l = other->getThirdPoint(temp->a, temp->b);
l->removeTriangle(other);
temp->a->removeTriangle(other);
temp->b->removeTriangle(other);
temp->a->removeTriangle(temp);
temp->b->removeTriangle(temp);
temp->c->removeTriangle(temp);
Triangle *n1 = new Triangle(temp->a, p, temp->c);
Triangle *n2 = new Triangle(temp->b, temp->c, p);
Triangle *n3 = new Triangle(temp->a, l, p);
Triangle *n4 = new Triangle(temp->b, p, l);
temp->children.push_back(n1);
temp->children.push_back(n2);
other->children.push_back(n3);
other->children.push_back(n4);
} else if (in == 2) { //BC
Triangle *other = findCommonTriangle(temp->b, temp->c, temp);
TriPoint *l = other->getThirdPoint(temp->b, temp->c);
l->removeTriangle(other);
temp->b->removeTriangle(other);
temp->c->removeTriangle(other);
temp->a->removeTriangle(temp);
temp->b->removeTriangle(temp);
temp->c->removeTriangle(temp);
Triangle *n1 = new Triangle(temp->a, p, temp->c);
Triangle *n2 = new Triangle(temp->b, temp->a, p);
Triangle *n3 = new Triangle(temp->c, p, l);
Triangle *n4 = new Triangle(temp->b, l, p);
temp->children.push_back(n1);
temp->children.push_back(n2);
other->children.push_back(n3);
other->children.push_back(n4);
} else if (in == 3) { //CA
Triangle *other = findCommonTriangle(temp->a, temp->c, temp);
TriPoint *l = other->getThirdPoint(temp->a, temp->c);
l->removeTriangle(other);
temp->a->removeTriangle(other);
temp->c->removeTriangle(other);
temp->a->removeTriangle(temp);
temp->b->removeTriangle(temp);
temp->c->removeTriangle(temp);
Triangle *n1 = new Triangle(temp->b, temp->c, p);
Triangle *n2 = new Triangle(temp->a, temp->b, p);
Triangle *n3 = new Triangle(temp->c, l, p);
Triangle *n4 = new Triangle(temp->a, p, l);
temp->children.push_back(n1);
temp->children.push_back(n2);
other->children.push_back(n3);
other->children.push_back(n4);
}
} else { //Point is inside of triangle
Triangle *t1 = new Triangle(temp->a, temp->b, p);
Triangle *t2 = new Triangle(temp->b, temp->c, p);
Triangle *t3 = new Triangle(temp->c, temp->a, p);
temp->a->removeTriangle(temp);
temp->b->removeTriangle(temp);
temp->c->removeTriangle(temp);
temp->children.push_back(t1);
temp->children.push_back(t2);
temp->children.push_back(t3);
}
} //Triangulation done
findSmallest(root, p0, p1, p2);
triangulations.push_back(this);
}
void findSmallest(Triangle *root, TriPoint *p0, TriPoint *p1, TriPoint *p2) {
bool include = true; //Controls drawing triangles with p0, p1, and p2
if (root->hasChildren()) {
for (Triangle *t : root->children) {
findSmallest(t, p0, p1, p2);
}
} else {
int i0 = root->hasPoint(p0);
int i1 = root->hasPoint(p1);
int i2 = root->hasPoint(p2);
if ((!i0 && !i1 && !i2) || include) {
triangles.push_back(root);
}
}
}
};
Poly polygon;
void changeViewPort(int w, int h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, glutGet(GLUT_WINDOW_WIDTH), 0, glutGet(GLUT_WINDOW_HEIGHT), -1, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.375, 0.375, 0.0);
}
void render() {
glClear(GL_COLOR_BUFFER_BIT);
glLineWidth(2.5);
changeViewPort(glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT));
glColor3f(0, 0, 1); //Blue
glBegin(GL_LINE_STRIP);
for (size_t j = 0; j < polygon.points.size(); j++) {
std::vector<Point> ps = polygon.points;
Point p1 = ps[j];
glVertex2i(p1.x, p1.y);
}
glVertex2i(polygon.points[0].x, polygon.points[0].y);
glEnd();
glColor3f(1, 0, 1);
for (Triangulation *t : triangulations) {
t->draw();
}
glutSwapBuffers();
}
int main(int argc, char* argv[]) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
glutInitWindowSize(800, 600);
glutCreateWindow("Stack Overflow Question");
glutReshapeFunc(changeViewPort);
glutDisplayFunc(render);
exactinit();
polygon.points.push_back(*new Point(300.0f, 300.0f));
polygon.points.push_back(*new Point(300.0f, 400.0f));
polygon.points.push_back(*new Point(400.0f, 400.0f));
polygon.points.push_back(*new Point(400.0f, 300.0f));
Triangulation t = *(new Triangulation(polygon));
glutMainLoop();
return 0;
}
注意：predicates.cpp和predicates.h是使用here中的代码创建的。
2 个答案:
答案 0 :(得分：3)
你的代码非常不理想，但现在没关系（你在学习，对吧？我会专注于三角测量问题。
已编辑：您在var processed;
fs.readFile(path, 'utf-8', function(err, data) {
processed = false;
//checking if text is in file and setting flag
processed = true;
});
if (processed == true) {
try {
var fname = path.substring(path.lastIndexOf("\\") + 1);
fs.moveSync(path, './processedxml/' + fname, {
overwrite: true
})
} catch (err) {
console.log("Error while moving file to processed folder " + err);
}
}
初始化yMin的{{1}}和yMax成员，稍后将其用于“大封闭”三角形。如果您决定不使用“sort（）”，您将使用初始值。在它上面放一些默认值。
构建三角测量不需要对点进行排序。你用它只是为了找到BB，付出太多的努力，并最终将它们洗得更加努力。
主要问题（在您的第一篇文章中，在您编辑它之前）我看到的是找到一个点是否在一个三角形内，在它的边界上，或者在它之外。
Triangulation太可怕了。你计算了几个sort()并返回'0'（三角形内部），它们都不等于'0'。你可能会争辩说你提前知道这一点不在外面因为你之前通过Triangle::isOnTriangle()进行了测试，但是这个功能也很可怕，但不是那么多。
找到点到线的相对位置的最佳（或至少最简单和最常用）方法是
crossproductTriangle::contains()位于res = (y2 - y1)*(px - x1) - (x2 - x1)*(py - y1)
行的右侧，则 res为正值。如果在左边则为负，如果在线则为零。
这里有两个重要的事情：
- a）交换方向（即行
{px,py}）会改变{x1,y1} to {x2,y2}的符号。 - b）如果
{x2,y2} to {x1,y1}真的为零，则由于数值问题而不容易告诉，就像任何其他浮点精度表示一样。
对于a），您必须确保所有三角形具有相同的方向（或者错误地使用前一个表达式）。您可以特别注意传递给三角形的点的顺序。或者您可以添加设置它们的“orientTri”功能。目前您的边界三角形是顺时针顺序。最常见的顺序（也用于OpenGL）是逆时针的;但你可以选择你喜欢的那个，只要注意它。
对于b）浮点数与'0'的比较不是一个好主意。在某些场景中，您可以使用res。但特别是三角测量还不够。 Classroom Examples of
Robustness Problems in Geometric Computations很好地解释了为什么你的计算必须“强大”。 Shewchuk Robust Predicates是一个非常好的解决方案。
一旦你解决了这两个问题，“三角形点”的问题就可以解决了：
res对于剩余的三角测量过程一些建议：
因为你想要一个Delaunay三角剖分，每次你添加一个新点你必须检查“inCircle”条件（没有其他三角形的外接圆包含这个新点）。它可以按照书中或我发布的链接中所示完成。同样，您需要健壮的谓词。
改变点的插入顺序可以提高定位新点所在三角形的性能。取决于用于定位部分的方法，这可能是真的。您使用三角形的层次结构，因此如果数据是否排序不影响。
顺便说一下，在CPU和RAM中维护添加/删除/更改的每个三角形的层次结构是昂贵的。当您获得网格划分经验时，也许您可能会在以后找到其他方法。
没有层次结构，随机输入的“走到点”方法（google for it）似乎更快。但是使用缓存（最后构建的三角形）会更有效率。
好好用网格划分。很难开始和调试，魔鬼生活在细节中。
答案 1 :(得分：0)
除了已经在Ripi2的回答中指出的问题，我想建议如下：
<强> 1。 random_shuffle ：
我看到你没有初始化随机生成器（通过调用main函数中的srand）。这意味着您将始终使用相同的伪随机序列，因此多次执行该程序将导致完全相同的结果。我测试了你的代码，而shuffling确实对代码产生了影响。正确初始化随机生成器后，您可以看到三角测量每次都会发生变化，产生不同的三角形。
<强> 2。比较
在您的代码中，您可以通过比较指针来比较点和三角形。这意味着，作为一个例子，当且仅当它们在内存中完全相同时，两个点才相等。具有相同坐标的两个点结构将被视为不同的点。我不确定这是否是你想要获得的，所以我建议考虑一下。
第3。多边形周围的三角形：
除了硬编码值（20）之外，我不明白为什么这段代码应该产生有效的三角测量。您可以在多边形上创建多个三角形，但它们全部共享三角形外的3个固定点之一。
下面是将硬编码参数减少为2的图片，以适合视口中的所有三角形：
相同的代码，不同的点顺序（在用时间（0）初始化srand之后）：
我无法访问算法的伪代码，但为了清楚起见，我建议您编辑您的答案以简要描述它。
祝你好好实施：）
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？