private void InitVertexInfo()
{
this.dataGridViewVertex.Rows.Clear();
foreach (TriMesh.Vertex vertex in Mesh.Vertices)
{
this.dataGridViewVertex.Rows.Add(vertex.Index, vertex.Traits.Position.x, vertex.Traits.Position.y, vertex.Traits.Position.z);
}
foreach (TriMesh.Face face in Mesh.Faces)
{
this.dataGridViewFace.Rows.Add(face.Index, face.GetVertex(0).Index, face.GetVertex(1).Index, face.GetVertex(2).Index, TriMeshUtil.ComputeAreaFace(face));
}
foreach (TriMesh.Edge edge in Mesh.Edges)
{
string face0 = "null";
string face1 = "null";
if (edge.Face0 != null)
{
face0 = edge.Face0.Index.ToString();
}
if (edge.Face1 != null)
{
face1 = edge.Face1.Index.ToString();
}
this.dataGridViewEdge.Rows.Add(edge.Index,
edge.Vertex0.Index,
edge.Vertex1.Index, face0,
face1, TriMeshUtil.ComputeEdgeLength(edge),
TriMeshUtil.ComputeDihedralAngle(edge) / 3.14 * 180);
}
}
public static double[] ComputeEdgeLength(TriMesh mesh)
{
double[] edgeLength = new double[mesh.Edges.Count];
for (int i = 0; i < mesh.Edges.Count; i++)
{
edgeLength[i] = TriMeshUtil.ComputeEdgeLength(mesh.Edges[i]);
}
return(edgeLength);
}
public override void Run()
{
Vector3D[] Av = new Vector3D[this.mesh.Faces.Count];
Vector3D[] E = new Vector3D[this.mesh.Faces.Count];
double[] D = new double[this.mesh.Faces.Count];
Vector3D[] AI = new Vector3D[this.mesh.Faces.Count];
List <Region> region = new List <Region>();
Vector3D max;
Vector3D min;
double[] s = new double[this.mesh.Faces.Count];
int k = 0;
int[] facenum = new int[this.mesh.Faces.Count];
for (int i = 0; i < this.mesh.Faces.Count; i++)
{
facenum[i] = -1;
foreach (TriMesh.Face face in mesh.Faces[i].Faces)
{
double a = TriMeshUtil.ComputeEdgeLength(face.GetVertex(0), face.GetVertex(1));
double b = TriMeshUtil.ComputeEdgeLength(face.GetVertex(0), face.GetVertex(2));
double c = TriMeshUtil.ComputeEdgeLength(face.GetVertex(2), face.GetVertex(1));
double p = (a + b + c) / 2;
s[i] = Math.Pow(p * (p - a) * (p - b) * (p - c), 0.5);
Av[k] = (face.Traits.Normal - mesh.Faces[i].Traits.Normal) * s[i];
k++;
E[i] = E[i] + Av[i] / (s[i] * k);
}
max = Av[0];
min = Av[0];
for (int j = 1; j < k; j++)
{
if (max.Length() < Av[j].Length())
{
max = Av[j];
}
if (min.Length() > Av[j].Length())
{
min = Av[j];
}
}
AI[i] = max - min;
for (int j = 1; j <= k; j++)
{
E[i] = E[i] + Av[i] / (s[i] * j);
D[i] = (Av[i] - E[i]).Length() / j;
}
k = 0;
}
for (int i = 0; i < this.mesh.Faces.Count; i++)
{
if ((Av[i].Length() < 0.86) && (D[i] < 0.098))
{
facenum[k] = i;
k++;
}
}
for (int i = 0; i < k - 1; i++)
{
int j;
int index = i;
for (int m = i + 1; m < k; m++)
{
if (E[facenum[m]].Length() < E[facenum[index]].Length())
{
j = facenum[m];
facenum[m] = facenum[index];
facenum[index] = j;
}
}
}
// int j = 0;
byte color = 1;
for (int m = 0; m < k; m++)
{
int test = 0;
Vector3D Normal;
Region mutiface = new Region(this.mesh);
double sum;
if (mesh.Faces[facenum[m]].Traits.SelectedFlag == 0)
{
mesh.Faces[facenum[m]].Traits.SelectedFlag = color;
mutiface.SetSeedFaces(facenum[m]);
mutiface.AddBoundaryFaces(mesh.Faces[facenum[m]]);
mutiface.SetColor(color);
Normal = mesh.Faces[facenum[m]].Traits.Normal;
sum = s[facenum[m]];
}
else
{
continue;
}
Boolean n = true;
for (; n;)
{
// n = true;
test = mutiface.Getallfacenumber();
List <TriMesh.Face> selectedFaces = new List <TriMesh.Face>();
for (int i = 0; i < mutiface.getBoundaryFaces().Count; i++)
{
selectedFaces.Add(mutiface.getBoundaryFaces()[i]);
}
for (int i = 0; i < selectedFaces.Count; i++)
{
int test2 = 0;
foreach (TriMesh.Face face in selectedFaces[i].Faces)
{
if (face.Traits.SelectedFlag == 0 && (Normal - selectedFaces[i].Traits.Normal).Length() * s[facenum[0]] < 0.481 && (face.Traits.Normal - Normal).Length() * sum < 0.72)
{
mutiface.AddFaces(selectedFaces[i], i);
mutiface.AddBoundaryFaces(face);
face.Traits.SelectedFlag = selectedFaces[i].Traits.SelectedFlag;
Normal = Normal + face.Traits.Normal;
sum = sum + s[face.Index];
test2++;
}
}
Normal = Normal / (test + 1);
sum = sum / (test + 1);
if (test2 == 0)
{
mutiface.AddFinalBoundaryFaces(selectedFaces[i]);
}
}
if (test == mutiface.Getallfacenumber())
{
n = false;
}
else if (mutiface.Getallfacenumber() >= 2200)
{
n = false;
}
}
region.Add(mutiface);
color++;
}
}
void UpdateLength(TriMesh.Edge edge)
{
this.EdgeLength[edge.Index] = TriMeshUtil.ComputeEdgeLength(edge);
}
public double Dijkstra(TriMesh.Vertex source, TriMesh.Vertex destination)
{
List <TriMesh.Vertex> S = new List <TriMesh.Vertex>(); //以求出最短路径的点的集合
List <TriMesh.Vertex> T = new List <TriMesh.Vertex>(); //未求出最短路径的点的集合
double minDistance = 0;
PathD[] minPath = new PathD[mesh.Vertices.Count];//每个点的最短路径过程
for (int i = 0; i < mesh.Vertices.Count; i++)
{
minPath[i] = new PathD();
}
#region STEP1 初始化两组点的集合
S.Add(source);
minPath[source.Index].path = 0;
minPath[source.Index].vertex = source;
minPath[source.Index].pathNumber.Add(source.Index);
for (int i = 0; i < mesh.Vertices.Count; i++)
{
if (mesh.Vertices[i] != source)
{
T.Add(mesh.Vertices[i]);
minPath[mesh.Vertices[i].Index].path = double.MaxValue;
minPath[mesh.Vertices[i].Index].vertex = mesh.Vertices[i];
}
}
int count = 0;
foreach (TriMesh.Vertex vertex in source.Vertices)
{
if (vertex == destination)
{
return(minDistance = TriMeshUtil.ComputeEdgeLength(source.FindEdgeTo(vertex)));
}
count++;
if (count == source.VertexCount)
{
minDistance = double.MaxValue;
}
}
#endregion
#region STEP2 遍历所有点，计算source到destination的最短路径的点的集合
while (true)
{
for (int i = 0; i < S.Count; i++)
{
foreach (TriMesh.Vertex v in S[i].Vertices)
{
for (int j = 0; j < T.Count; j++)
{
if (T[j] == v)
{
if (S.Contains(T[j]) == true)
{
continue;
}
if (TriMeshUtil.ComputeEdgeLength(S[i].FindEdgeTo(T[j])) < minPath[T[j].Index].path)
{
minPath[T[j].Index].path = TriMeshUtil.ComputeEdgeLength(S[i].FindEdgeTo(T[j]));
minPath[T[j].Index].pathNumber.Clear();
for (int k = 0; k < minPath[S[i].Index].pathNumber.Count; k++)
{
minPath[T[j].Index].pathNumber.Add(minPath[S[i].Index].pathNumber[k]);
}
minPath[T[j].Index].pathNumber.Add(T[j].Index);
S.Add(T[j]);
}
}
}
}
}
if (S.Count == mesh.Vertices.Count)
{
break;
}
}
#endregion
#region 计算出最短路径以及为最短路径染色
minDistance = 0;
for (int i = 0; i < minPath[destination.Index].pathNumber.Count - 1; i++)
{
minDistance += TriMeshUtil.ComputeEdgeLength(mesh.Vertices[minPath[destination.Index].pathNumber[i]].FindEdgeTo(
mesh.Vertices[minPath[destination.Index].pathNumber[i + 1]]));
}
for (int i = 0; i < minPath[destination.Index].pathNumber.Count - 1; i++)
{
mesh.Vertices[minPath[destination.Index].pathNumber[i]].FindEdgeTo(mesh.Vertices[minPath[destination.Index].pathNumber[i + 1]]).Traits.SelectedFlag = 1;
}
#endregion
return(minDistance);
}
protected override double GetValue(HalfEdgeMesh.Edge target)
{
return(TriMeshUtil.ComputeEdgeLength(target));
}
