public static void InverseFace(TriMesh mesh)
{
List <TriMesh.Vertex[]> faces = new List <HalfEdgeMesh.Vertex[]>();
foreach (TriMesh.Face face in mesh.Faces)
{
TriMesh.HalfEdge hf = face.HalfEdge;
TriMesh.Vertex[] arr = new TriMesh.Vertex[] {
hf.Next.ToVertex,
hf.ToVertex,
hf.FromVertex
};
faces.Add(arr);
}
TriMesh.Vertex[] vertices = new TriMesh.Vertex[mesh.Vertices.Count];
for (int i = 0; i < mesh.Vertices.Count; i++)
{
vertices[i] = mesh.Vertices[i];
vertices[i].HalfEdge = null;
}
mesh.Clear();
foreach (var v in vertices)
{
mesh.AppendToVertexList(v);
}
foreach (var face in faces)
{
mesh.Faces.AddTriangles(face);
}
}
private TriMesh.HalfEdge[] FindSaddleExtreme(TriMesh.Vertex v, bool maxOrMin)
{
List <TriMesh.HalfEdge> all = new List <HalfEdgeMesh.HalfEdge>();
TriMesh.HalfEdge n2p = this.FindN2P(v);
v.HalfEdge = n2p;
List <TriMesh.HalfEdge> part = new List <HalfEdgeMesh.HalfEdge>();
double mid = this.function[v.Index];
foreach (TriMesh.HalfEdge hf in v.HalfEdges)
{
double round = this.function[hf.ToVertex.Index];
if (this.Compare(round, mid, maxOrMin))
{
part.Add(hf);
}
else
{
if (part.Count != 0)
{
all.Add(this.FindExtreme(part, maxOrMin));
}
part.Clear();
}
}
if (part.Count != 0)
{
all.Add(this.FindExtreme(part, maxOrMin));
}
return(all.ToArray());
}
public PrincipalCurvature ComputePrincipalCurvature(TriMesh.Vertex v)
{
Vector3D sum = Vector3D.Zero;
Vector3D mid = v.Traits.Position;
foreach (var hf in v.HalfEdges)
{
Vector3D buttom = hf.ToVertex.Traits.Position;
Vector3D left = hf.Opposite.Next.ToVertex.Traits.Position;
Vector3D right = hf.Next.ToVertex.Traits.Position;
double cota = (mid - left).Dot(buttom - left) / (mid - left).Cross(buttom - left).Length();
double cotb = (mid - right).Dot(buttom - right) / (mid - right).Cross(buttom - right).Length();
sum += (cota + cotb) * (this.Normal[v.Index] - this.Normal[hf.ToVertex.Index]);
}
double mixedArea = TriMeshUtil.ComputeAreaMixed(v);
Vector3D laplace = sum / mixedArea / 2d;
double square = -laplace.Dot(this.Normal[v.Index]);
double k = this.K[v.Index].Length();
double delta = -k * k + 2d * square;
if (delta < 0d)
{
delta = 0d;
}
PrincipalCurvature pc = new PrincipalCurvature();
pc.max = (k + Math.Pow(delta, 0.5)) / 2d;
pc.min = (k - Math.Pow(delta, 0.5)) / 2d;
return(pc);
}
public TriMesh CreateSquareSpoke(int length, int width)
{
TriMesh mesh = new TriMesh();
double x0 = -this.GridSizeX * length / 2d;
double y0 = -this.GridSizeX * width / 2d;
double z0 = 0;
double d = this.GridSizeX / 2;
int t = 4;
TriMesh.Vertex[,] v = new TriMesh.Vertex[length + 1, width + 1];
for (int i = 0; i < length + 1; i++)
{
for (int j = 0; j < width + 1; j++)
{
double x = x0 + this.GridSizeX * i;
double y = y0 + this.GridSizeX * j;
int r = i % t == j % t ? i % t : 0;
double z = z0 - (Math.Abs(r - t / 2) - t / 2) * d;
v[i, j] = mesh.Vertices.Add(new VertexTraits(x, y, z));
}
}
for (int i = 0; i < length; i++)
{
for (int j = 0; j < width; j++)
{
mesh.Faces.AddTriangles(v[i, j], v[i + 1, j], v[i + 1, j + 1], v[i, j + 1]);
}
}
TriMeshUtil.SetUpNormalVertex(mesh);
return(mesh);
}
public static void InverseFace(TriMesh mesh)
{
List<TriMesh.Vertex[]> faces = new List<HalfEdgeMesh.Vertex[]>();
foreach (TriMesh.Face face in mesh.Faces)
{
TriMesh.HalfEdge hf = face.HalfEdge;
TriMesh.Vertex[] arr = new TriMesh.Vertex[]{
hf.Next.ToVertex,
hf.ToVertex,
hf.FromVertex
};
faces.Add(arr);
}
TriMesh.Vertex[] vertices = new TriMesh.Vertex[mesh.Vertices.Count];
for (int i = 0; i < mesh.Vertices.Count; i++)
{
vertices[i] = mesh.Vertices[i];
vertices[i].HalfEdge = null;
}
mesh.Clear();
foreach (var v in vertices)
{
mesh.AppendToVertexList(v);
}
foreach (var face in faces)
{
mesh.Faces.AddTriangles(face);
}
}
public TriMesh CreateSquare(int length, int width)
{
TriMesh mesh = new TriMesh();
double x0 = -this.GridSizeX * length / 2d;
double y0 = -this.GridSizeX * width / 2d;
double z0 = 0;
double d = this.GridSizeX / 2;
TriMesh.Vertex[,] v = new TriMesh.Vertex[length + 1, width + 1];
for (int i = 0; i < length + 1; i++)
{
for (int j = 0; j < width + 1; j++)
{
double x = x0 + this.GridSizeX * i;
double y = y0 + this.GridSizeX * j;
double z = i % 2 == 1 && j % 2 == 1 ? d : z0;
v[i, j] = mesh.Vertices.Add(new VertexTraits(x, y, z));
}
}
for (int i = 0; i < length; i++)
{
for (int j = 0; j < width; j++)
{
mesh.Faces.AddTriangles(v[i, j], v[i + 1, j], v[i + 1, j + 1], v[i, j + 1]);
}
}
TriMeshUtil.SetUpNormalVertex(mesh);
return(mesh);
}
public static void GrowByVertexArea(TriMesh mesh)
{
Queue <TriMesh.Vertex> queue = new Queue <HalfEdgeMesh.Vertex>();
double[] avgArea = new double[mesh.Vertices.Count];
foreach (var v in mesh.Vertices)
{
avgArea[v.Index] = TriMeshUtil.ComputeAreaOneRing(v);
if (v.Traits.SelectedFlag != 0)
{
queue.Enqueue(v);
}
}
double k = 0.896;
while (queue.Count != 0)
{
TriMesh.Vertex center = queue.Dequeue();
foreach (var round in center.Vertices)
{
if (round.Traits.SelectedFlag == 0)
{
if (Math.Abs(avgArea[center.Index] -
avgArea[round.Index]) < k * avgArea[center.Index])
{
round.Traits.SelectedFlag = center.Traits.SelectedFlag;
queue.Enqueue(round);
}
}
}
}
}
TriMesh.Edge CreateNewEdge(TriMesh.Vertex from, TriMesh.Vertex to)
{
TriMesh mesh = (TriMesh)from.Mesh;
// Create new edge
TriMesh.Edge edge = new TriMesh.Edge();
mesh.AppendToEdgeList(edge);
// Create new halfedges
TriMesh.HalfEdge hf0 = new TriMesh.HalfEdge();
mesh.AppendToHalfedgeList(hf0);
hf0.Opposite = new TriMesh.HalfEdge();
mesh.AppendToHalfedgeList(hf0.Opposite);
// Connect opposite halfedge to inner halfedge
hf0.Opposite.Opposite = hf0;
// Connect edge to halfedges
edge.HalfEdge0 = hf0;
// Connect halfedges to edge
hf0.Edge = edge;
hf0.Opposite.Edge = edge;
// Connect halfedges to vertices
hf0.ToVertex = to;
hf0.Opposite.ToVertex = from;
// Connect vertex to outgoing halfedge if it doesn't have one yet
if (from.HalfEdge == null)
{
from.HalfEdge = hf0;
}
return(edge);
}
public bool Forward()
{
if (this.index < this.method.Logs.Count)
{
EdgeContext ctx = this.method.Logs[this.index];
TriMesh.Vertex left = null;
TriMesh.Vertex right = null;
foreach (var v in this.Mesh.Vertices)
{
if (v.Index == ctx.Left)
{
left = v;
}
else if (v.Index == ctx.Right)
{
right = v;
}
}
TriMesh.Edge edge = left.FindEdgeTo(right);
MergeEdge.Merge(edge, ctx.MidPos);
index++;
return(true);
}
else
{
int r = this.method.Run(this.Mesh.Faces.Count - 1);
index += r;
return(false);
}
}
public static void Split(TriMesh mesh, EdgeContext ctx)
{
TriMesh.Vertex left = null;
TriMesh.Vertex top = null;
TriMesh.Vertex bottom = null;
foreach (var v in mesh.Vertices)
{
if (v.Index == ctx.Left)
{
left = v;
}
else if (v.Index == ctx.Top)
{
top = v;
}
else if (v.Index == ctx.Bottom)
{
bottom = v;
}
}
TriMesh.Vertex right = TriMeshModify.VertexSplit(left, top, bottom, ctx.LeftPos, ctx.RightPos);
TriMesh.HalfEdge hf = left.FindHalfedgeTo(right);
right.Index = ctx.Right;
hf.Next.ToVertex.Index = ctx.Top;
hf.Opposite.Next.ToVertex.Index = ctx.Bottom;
}
/// <summary>
/// 两端点都在边界上
/// </summary>
/// <param name="edge"></param>
void CutBothBoundary(TriMesh.Edge edge)
{
TriMesh.HalfEdge hf = edge.HalfEdge0;
TriMesh.HalfEdge[] leftArr = this.GetToBoundaryAntiClockWise(hf);
TriMesh.HalfEdge[] rightArr = this.GetToBoundaryClockWise(hf.Next);
for (int i = 1; i < leftArr.Length; i++)
{
TriMeshModify.RemoveEdge(leftArr[i].Edge);
}
for (int i = 0; i < rightArr.Length; i++)
{
TriMeshModify.RemoveEdge(rightArr[i].Edge);
}
Vector3D vec = this.GetMoveVector(hf.Opposite);
TriMesh.Vertex left = this.Clone(hf.FromVertex, vec);
TriMesh.Vertex right = this.Clone(hf.ToVertex, vec);
for (int i = 2; i < leftArr.Length; i++)
{
this.mesh.Faces.AddTriangles(left, leftArr[i - 1].ToVertex, leftArr[i].ToVertex);
}
for (int i = 1; i < rightArr.Length; i++)
{
this.mesh.Faces.AddTriangles(right, rightArr[i].ToVertex, rightArr[i - 1].ToVertex);
}
this.mesh.Faces.AddTriangles(left, right, leftArr[1].ToVertex);
}
public TriMesh CreateSquare(int length, int width)
{
TriMesh mesh = new TriMesh();
double x0 = -this.GridSizeX * length / 2d;
double y0 = -this.GridSizeX * width / 2d;
double z0 = 0;
double d = this.GridSizeX / 2;
TriMesh.Vertex[,] v = new TriMesh.Vertex[length + 1, width + 1];
for (int i = 0; i < length + 1; i++)
{
for (int j = 0; j < width + 1; j++)
{
double x=x0 + this.GridSizeX * i;
double y=y0 + this.GridSizeX * j;
double z = i % 2 == 1 && j % 2 == 1 ? d : z0;
v[i, j] = mesh.Vertices.Add(new VertexTraits(x, y, z));
}
}
for (int i = 0; i < length; i++)
{
for (int j = 0; j < width; j++)
{
mesh.Faces.AddTriangles(v[i, j], v[i + 1, j], v[i + 1, j + 1], v[i, j + 1]);
}
}
TriMeshUtil.SetUpNormalVertex(mesh);
return mesh;
}
public static void RepaireHoleTwo(List <TriMesh.Vertex> hole)
{
TriMesh mesh = (TriMesh)hole[0].Mesh;
Vector3D center = Vector3D.Zero;
for (int i = 0; i < hole.Count; i++)
{
center += hole[i].Traits.Position;
}
center /= hole.Count;
TriMesh.Vertex vertex = mesh.Vertices.Add(new VertexTraits(center));
if (hole.Count >= 3)
{
TriMesh.Vertex[] faceVertices = new TriMesh.Vertex[3];
for (int i = 0; i < hole.Count; i++)
{
faceVertices[0] = vertex;
faceVertices[1] = hole[i];
faceVertices[2] = hole[(i + 1) % hole.Count];
mesh.Faces.AddTriangles(faceVertices);
}
}
TriMeshUtil.FixIndex(mesh);
}
public double Distance(TriMesh.Vertex c, TriMesh.Vertex d) //利用距离公式计算点到中心集的点的距离
{
double average;
average = Math.Sqrt(Math.Pow((c.Traits.Position.x - d.Traits.Position.x), 2) + Math.Pow((c.Traits.Position.y - d.Traits.Position.y), 2) + Math.Pow((c.Traits.Position.z - d.Traits.Position.z), 2));
return(average);
}
void OuterHalfedgeBothNew(TriMesh.HalfEdge cur, TriMesh.HalfEdge next, bool vertexIsUsed)
{
if (vertexIsUsed) // Both edges are new and vertex has faces connected already
{
TriMesh.Vertex vertex = cur.ToVertex;
TriMesh.HalfEdge closeHalfedge = null;
// Find the closing halfedge of the first available opening
foreach (TriMesh.HalfEdge h in vertex.HalfEdges)
{
if (h.Face == null)
{
closeHalfedge = h;
break;
}
}
TriMesh.HalfEdge openHalfedge = closeHalfedge.Previous;
// Link new outer halfedges into this opening
cur.Opposite.Previous = openHalfedge;
openHalfedge.Next = cur.Opposite;
next.Opposite.Next = closeHalfedge;
closeHalfedge.Previous = next.Opposite;
}
else
{
cur.Opposite.Previous = next.Opposite;
next.Opposite.Next = cur.Opposite;
}
}
public static TriMesh Clone(TriMesh mesh)
{
TriMesh newMesh = new TriMesh();
for (int i = 0; i < mesh.Vertices.Count; i++)
{
VertexTraits traits = new VertexTraits(mesh.Vertices[i].Traits.Position.x,
mesh.Vertices[i].Traits.Position.y,
mesh.Vertices[i].Traits.Position.z);
newMesh.Vertices.Add(traits);
}
TriMesh.Vertex[] faceVetices = new TriMesh.Vertex[3];
for (int i = 0; i < mesh.Faces.Count; i++)
{
int faceVertexIndex1 = mesh.Faces[i].GetVertex(0).Index;
int faceVertexIndex2 = mesh.Faces[i].GetVertex(1).Index;
int faceVertexIndex3 = mesh.Faces[i].GetVertex(2).Index;
faceVetices[0] = newMesh.Vertices[faceVertexIndex1];
faceVetices[1] = newMesh.Vertices[faceVertexIndex2];
faceVetices[2] = newMesh.Vertices[faceVertexIndex3];
newMesh.Faces.AddTriangles(faceVetices);
}
newMesh.TrimExcess();
return newMesh;
}
public static TriMesh.Vertex MergeEdge(TriMesh.Edge edge, Vector3D position)
{
TriMesh mesh = (TriMesh)edge.Mesh;
TriMesh.Vertex v0 = edge.Vertex0;
TriMesh.Vertex v1 = edge.Vertex1;
TriMesh.HalfEdge hf0 = edge.HalfEdge0;
TriMesh.HalfEdge hf1 = edge.HalfEdge1;
v0.Traits.Position = position;
foreach (var item in v1.HalfEdges)
{
//if (item.ToVertex != v0)
{
item.Opposite.ToVertex = v0;
}
}
MergeOneSide(hf0);
MergeOneSide(hf1);
mesh.RemoveVertex(v1);
mesh.RemoveEdge(edge);
v1.HalfEdge = null;
edge.HalfEdge0 = null;
return(v0);
}
public void PlaneCut(TriMesh.HalfEdge above, Vector3D normal, double maxAngle)
{
Plane plane = new Plane(above.Next.ToVertex.Traits.Position, normal);
Nullable <Vector3D> point = this.Intersect(plane, above.Edge);
double angle = this.GetAngle(plane, above);
while (point != null && angle > maxAngle)
{
TriMesh.Vertex left = above.FromVertex;
TriMesh.Vertex right = above.ToVertex;
TriMesh.Vertex buttom = above.Opposite.Next.ToVertex;
this.Cut(above, point.Value);
if (above.Opposite.OnBoundary)
{
break;
}
TriMesh.HalfEdge[] below = new[] { left.FindHalfedgeTo(buttom), buttom.FindHalfedgeTo(right) };
foreach (var hf in below)
{
point = this.Intersect(plane, hf.Edge);
if (point != null)
{
angle = this.GetAngle(plane, hf);
above = hf;
break;
}
}
}
}
public bool Backward()
{
if (this.index == 0)
{
return(false);
}
else
{
index--;
EdgeContext ctx = this.method.Logs[this.index];
SplitVertex.Split(this.Mesh, ctx);
TriMesh.Vertex left = null;
TriMesh.Vertex right = null;
foreach (var v in this.Mesh.Vertices)
{
if (v.Index == ctx.Left)
{
left = v;
}
else if (v.Index == ctx.Right)
{
right = v;
}
}
TriMesh.HalfEdge hf = left.FindHalfedgeTo(right);
hf.Face.Traits.Normal = TriMeshUtil.ComputeNormalFace(hf.Face);
hf.Opposite.Face.Traits.Normal = TriMeshUtil.ComputeNormalFace(hf.Opposite.Face);
left.Traits.Normal = TriMeshUtil.ComputeNormalAreaWeight(left);
right.Traits.Normal = TriMeshUtil.ComputeNormalAreaWeight(right);
return(true);
}
}
protected override void BeforeMerge(TriMesh.Edge edge)
{
base.BeforeMerge(edge);
TriMesh.Vertex v1 = edge.Vertex0;
TriMesh.Vertex v2 = edge.Vertex1;
vertexMatrix[v1] += vertexMatrix[v2];
}
private static double[] SimplifyComputePlane(TriMesh.Vertex vertexA,
TriMesh.Vertex vertexB, TriMesh.Vertex vertexC)
{
double x1 = vertexA.Traits.Position.x;
double x2 = vertexB.Traits.Position.x;
double x3 = vertexC.Traits.Position.x;
double y1 = vertexA.Traits.Position.y;
double y2 = vertexB.Traits.Position.y;
double y3 = vertexC.Traits.Position.y;
double z1 = vertexA.Traits.Position.z;
double z2 = vertexB.Traits.Position.z;
double z3 = vertexC.Traits.Position.z;
double[] plane = new double[4];
double a = (y2 - y1) * (z3 - z1) - (z2 - z1) * (y3 - y1);
double b = (z2 - z1) * (x3 - x1) - (x2 - x1) * (z3 - z1);
double c = (x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1);
double M = Math.Sqrt(a * a + b * b + c * c);
a = a / M;
b = b / M;
c = c / M;
double d = -1 * (a * x1 + b * y1 + c * z1);
plane[0] = a;
plane[1] = b;
plane[2] = c;
plane[3] = d;
return(plane);
}
public static bool EdgeSwap(TriMesh.Edge edge)
{
if (edge.OnBoundary)
{
return(false);
}
//逆时针90度，左右变为下上
TriMesh.HalfEdge hf1 = edge.HalfEdge0;
TriMesh.HalfEdge hf2 = edge.HalfEdge1;
TriMesh.Vertex top = hf1.ToVertex;
TriMesh.Vertex buttom = hf2.ToVertex;
TriMesh.HalfEdge topLeft = hf1.Next;
TriMesh.HalfEdge buttomLeft = hf1.Previous;
TriMesh.HalfEdge topRight = hf2.Previous;
TriMesh.HalfEdge buttomRight = hf2.Next;
top.HalfEdge = topLeft;
buttom.HalfEdge = buttomRight;
hf1.ToVertex = topLeft.ToVertex;
hf2.ToVertex = buttomRight.ToVertex;
hf1.Face.HalfEdge = hf1;
hf2.Face.HalfEdge = hf2;
topLeft.Face = hf2.Face;
buttomRight.Face = hf1.Face;
ConnectHalfEdge(topLeft, hf2, topRight);
ConnectHalfEdge(buttomRight, hf1, buttomLeft);
return(true);
}
public static TriMesh Clone(TriMesh mesh)
{
TriMesh newMesh = new TriMesh();
for (int i = 0; i < mesh.Vertices.Count; i++)
{
VertexTraits traits = new VertexTraits(mesh.Vertices[i].Traits.Position.x,
mesh.Vertices[i].Traits.Position.y,
mesh.Vertices[i].Traits.Position.z);
newMesh.Vertices.Add(traits);
}
TriMesh.Vertex[] faceVetices = new TriMesh.Vertex[3];
for (int i = 0; i < mesh.Faces.Count; i++)
{
int faceVertexIndex1 = mesh.Faces[i].GetVertex(0).Index;
int faceVertexIndex2 = mesh.Faces[i].GetVertex(1).Index;
int faceVertexIndex3 = mesh.Faces[i].GetVertex(2).Index;
faceVetices[0] = newMesh.Vertices[faceVertexIndex1];
faceVetices[1] = newMesh.Vertices[faceVertexIndex2];
faceVetices[2] = newMesh.Vertices[faceVertexIndex3];
newMesh.Faces.AddTriangles(faceVetices);
}
newMesh.TrimExcess();
return(newMesh);
}
public static void RepaireHoleTwo(List<TriMesh.Vertex> hole)
{
TriMesh mesh = (TriMesh)hole[0].Mesh;
Vector3D center = Vector3D.Zero;
for (int i = 0; i < hole.Count; i++)
{
center += hole[i].Traits.Position;
}
center /= hole.Count;
TriMesh.Vertex vertex = mesh.Vertices.Add(new VertexTraits(center));
if (hole.Count >= 3)
{
TriMesh.Vertex[] faceVertices = new TriMesh.Vertex[3];
for (int i = 0; i < hole.Count; i++)
{
faceVertices[0] = vertex;
faceVertices[1] = hole[i];
faceVertices[2] = hole[(i + 1) % hole.Count];
mesh.Faces.AddTriangles(faceVertices);
}
}
TriMeshUtil.FixIndex(mesh);
}
public static void RemoveVertex(TriMesh.Vertex vertex)
{
TriMesh mesh = (TriMesh)vertex.Mesh;
foreach (TriMesh.HalfEdge halfEdge in vertex.HalfEdges)
{
if (halfEdge.Next != null)
{
halfEdge.Next.Face = null;
halfEdge.Opposite.Previous.Next = halfEdge.Next;
halfEdge.Next.Previous = halfEdge.Opposite.Previous;
}
if (halfEdge.ToVertex.HalfEdge == halfEdge.Opposite)
{
halfEdge.ToVertex.HalfEdge = halfEdge.Next;
}
mesh.RemoveHalfedge(halfEdge.Opposite);
mesh.RemoveHalfedge(halfEdge);
}
foreach (TriMesh.Face face in vertex.Faces)
{
mesh.RemoveFace(face);
}
foreach (TriMesh.Edge edge in vertex.Edges)
{
mesh.RemoveEdge(edge);
}
mesh.RemoveVertex(vertex);
}
public static TriMesh Combine(List <TriMesh> meshes)
{
TriMesh combine = new TriMesh();
foreach (TriMesh mesh in meshes)
{
if (mesh != null)
{
TriMesh.Vertex[] arr = new TriMesh.Vertex[mesh.Vertices.Count];
foreach (TriMesh.Vertex v in mesh.Vertices)
{
arr[v.Index] = combine.Vertices.Add(new VertexTraits(v.Traits.Position));
arr[v.Index].Traits = v.Traits;
}
foreach (TriMesh.Face face in mesh.Faces)
{
TriMesh.Face faceNew = combine.Faces.Add(arr[face.GetVertex(0).Index],
arr[face.GetVertex(1).Index],
arr[face.GetVertex(2).Index]);
faceNew.Traits = face.Traits;
}
}
}
return(combine);
}
public static TriMesh ToTriMesh(QuadMesh mesh)
{
TriMesh trimesh = new TriMesh();
for (int i = 0; i < mesh.Vertices.Count; i++)
{
Vector3D position = mesh.Vertices[i].Traits.Position;
trimesh.Vertices.Add(new VertexTraits(position.x, position.y, position.z));
}
foreach (QuadMesh.Face face in mesh.Faces)
{
int v0 = face.GetVertex(0).Index;
int v1 = face.GetVertex(1).Index;
int v2 = face.GetVertex(2).Index;
int v3 = face.GetVertex(3).Index;
TriMesh.Vertex[] faceVertices = new TriMesh.Vertex[3];
faceVertices[0] = trimesh.Vertices[v0];
faceVertices[1] = trimesh.Vertices[v1];
faceVertices[2] = trimesh.Vertices[v2];
trimesh.Faces.AddTriangles(faceVertices);
faceVertices[0] = trimesh.Vertices[v2];
faceVertices[1] = trimesh.Vertices[v3];
faceVertices[2] = trimesh.Vertices[v0];
trimesh.Faces.AddTriangles(faceVertices);
}
return(trimesh);
}
public static void WriteToObjFile(string filePath, TriMesh mesh)
{
FileStream fs = new FileStream(filePath, FileMode.Create);
StreamWriter sw = new StreamWriter(fs);
sw.WriteLine("#Vertices:" + mesh.Vertices.Count);
sw.WriteLine("#Faces:" + mesh.Faces.Count);
foreach (TriMesh.Vertex item in mesh.Vertices)
{
sw.WriteLine("v {0} {1} {2}", item.Traits.Position.x, item.Traits.Position.y, item.Traits.Position.z);
}
sw.WriteLine();
foreach (TriMesh.Face item in mesh.Faces)
{
TriMesh.Vertex v1 = item.GetVertex(0);
TriMesh.Vertex v2 = item.GetVertex(1);
TriMesh.Vertex v3 = item.GetVertex(2);
sw.WriteLine("f {0} {1} {2}", v1.Index + 1, v2.Index + 1, v3.Index + 1);
}
sw.Close();
fs.Close();
}
public static PrincipalCurvature ComputePricipalCurvature(TriMesh.Vertex v)
{
double mean = ComputeMeanCurvature(v);
double gauss = ComputeGaussianCurvature(v);
return(ComputePricipalCurvature(mean, gauss));
}
public TriMesh CreateCylinder(int length, int width, int height)
{
TriMesh mesh = new TriMesh();
double x0 = -this.GridSizeX * length / 2d;
double y0 = -this.GridSizeY * width / 2d;
double z0 = -this.GridSizeZ * height / 2d;
TriMesh.Vertex[,] top = new TriMesh.Vertex[length + 1, width + 1];
TriMesh.Vertex[,] btm = new TriMesh.Vertex[length + 1, width + 1];
for (int i = 0; i < length + 1; i++)
{
for (int j = 0; j < width + 1; j++)
{
double x = x0 + this.GridSizeX * i;
double y = y0 + this.GridSizeY * j;
top[i, j] = mesh.Vertices.Add(new VertexTraits(x, y, -z0));
btm[i, j] = mesh.Vertices.Add(new VertexTraits(x, y, z0));
}
}
for (int i = 0; i < length; i++)
{
for (int j = 0; j < width; j++)
{
mesh.Faces.AddTriangles(top[i, j], top[i + 1, j], top[i + 1, j + 1], top[i, j + 1]);
mesh.Faces.AddTriangles(btm[i, j], btm[i, j + 1], btm[i + 1, j + 1], btm[i + 1, j]);
}
}
int round = (length + width) * 2;
TriMesh.Vertex[,] side = new TriMesh.Vertex[round, height + 1];
int s = 0, t = 0;
for (int i = 0; i < round; i++)
{
int ol = i < length ? 1 : i >= round / 2d && i < round - width ? -1 : 0;
int ow = i >= round - width ? -1 : i >= length && i < round / 2d ? 1 : 0;
Vector3D v = btm[s, t].Traits.Position;
side[i, 0] = btm[s, t];
for (int j = 1; j < height; j++)
{
side[i, j] = mesh.Vertices.Add(new VertexTraits(v.x, v.y, z0 + this.GridSizeZ * j));
}
side[i, height] = top[s, t];
s += ol; t += ow;
}
for (int i = 0; i < round; i++)
{
for (int j = 0; j < height; j++)
{
mesh.Faces.AddTriangles(side[i, j], side[(i + 1) % round, j], side[(i + 1) % round, j + 1], side[i, j + 1]);
}
}
TriMeshUtil.SetUpNormalVertex(mesh);
return(mesh);
}
private static void BulidSphereFace(int v1, int v2, int v3, TriMesh mesh)//添加面
{
TriMesh.Vertex[] faceVertices = new TriMesh.Vertex[3];
faceVertices[0] = mesh.Vertices[v1];
faceVertices[1] = mesh.Vertices[v2];
faceVertices[2] = mesh.Vertices[v3];
TriMesh.Face[] addedFaces = mesh.Faces.AddTriangles(faceVertices);
}
private void BulidBoneFace(int v1, int v2, int v3)//为正方形添加面
{
TriMesh.Vertex[] faceVertices = new TriMesh.Vertex[3];
faceVertices[0] = this.Vertices[v1];
faceVertices[1] = this.Vertices[v2];
faceVertices[2] = this.Vertices[v3];
TriMesh.Face[] addedFaces = this.Faces.AddTriangles(faceVertices);
}
public static void ShowOneRingEdgeOfVertex(TriMesh.Vertex vertex)
{
foreach (TriMesh.HalfEdge neighbors in vertex.HalfEdges)
{
neighbors.Next.Edge.Traits.SelectedFlag = 10;
neighbors.Next.Edge.Traits.Color = RetrieveResult.Instance.EdgeResult;
}
}
public static void ShowOneRingVertexOfVertex(TriMesh.Vertex vertex)
{
foreach (TriMesh.Vertex neighbors in vertex.Vertices)
{
neighbors.Traits.SelectedFlag = 8;
neighbors.Traits.Color = RetrieveResult.Instance.VertexResult;
}
}
public TriMesh CreateCylinder(int length, int width, int height)
{
TriMesh mesh = new TriMesh();
double x0 = -this.GridSizeX * length / 2d;
double y0 = -this.GridSizeY * width / 2d;
double z0 = -this.GridSizeZ * height / 2d;
TriMesh.Vertex[,] top = new TriMesh.Vertex[length + 1, width + 1];
TriMesh.Vertex[,] btm = new TriMesh.Vertex[length + 1, width + 1];
for (int i = 0; i < length + 1; i++)
{
for (int j = 0; j < width + 1; j++)
{
double x = x0 + this.GridSizeX * i;
double y = y0 + this.GridSizeY * j;
top[i, j] = mesh.Vertices.Add(new VertexTraits(x, y, -z0));
btm[i, j] = mesh.Vertices.Add(new VertexTraits(x, y, z0));
}
}
for (int i = 0; i < length; i++)
{
for (int j = 0; j < width; j++)
{
mesh.Faces.AddTriangles(top[i, j], top[i + 1, j], top[i + 1, j + 1], top[i, j + 1]);
mesh.Faces.AddTriangles(btm[i, j], btm[i, j + 1], btm[i + 1, j + 1], btm[i + 1, j]);
}
}
int round = (length + width) * 2;
TriMesh.Vertex[,] side = new TriMesh.Vertex[round, height + 1];
int s = 0, t = 0;
for (int i = 0; i < round; i++)
{
int ol = i < length ? 1 : i >= round / 2d && i < round - width ? -1 : 0;
int ow = i >= round - width ? -1 : i >= length && i < round / 2d ? 1 : 0;
Vector3D v = btm[s, t].Traits.Position;
side[i, 0] = btm[s, t];
for (int j = 1; j < height; j++)
{
side[i, j] = mesh.Vertices.Add(new VertexTraits(v.x, v.y, z0 + this.GridSizeZ * j));
}
side[i, height] = top[s, t];
s += ol; t += ow;
}
for (int i = 0; i < round; i++)
{
for (int j = 0; j < height; j++)
{
mesh.Faces.AddTriangles(side[i, j], side[(i + 1) % round, j], side[(i + 1) % round, j + 1], side[i, j + 1]);
}
}
TriMeshUtil.SetUpNormalVertex(mesh);
return mesh;
}
public void ComputeGeometryB(PolygonMesh dualMesh)
{
TriMesh.Vertex[] edgeVertices = new TriMesh.Vertex[mesh.Faces.Count * 3];
foreach (TriMesh.Edge e in mesh.Edges)
{
Vector3D midVertex0 = TriMeshUtil.GetMidPoint(e);
dualMesh.Vertices.Add(new VertexTraits(midVertex0.x, midVertex0.y, midVertex0.z));
}
foreach (TriMesh.Face f in mesh.Faces)
{
Vector3D baryCenter = TriMeshUtil.GetMidPoint(f);
dualMesh.Vertices.Add(new VertexTraits(baryCenter.x, baryCenter.y, baryCenter.z));
}
}
public void CutHalfEdge(TriMesh.HalfEdge hf)
{
Vector3D p1 = hf.FromVertex.Traits.Position;
Vector3D p2 = hf.ToVertex.Traits.Position;
double d1 = TriMeshUtil.GetDistance(plane, p1);
double d2 = TriMeshUtil.GetDistance(plane, p2);
if (d1 < 0 && d2 > 0)
{
d1 = Math.Abs(d1);
d2 = Math.Abs(d2);
Vector3D pos = p1 + (p2 - p1) * d1 / (d1 + d2);
TriMesh.Vertex v1 = new TriMesh.Vertex(new VertexTraits(pos));
this.mesh.AppendToVertexList(v1);
TriMesh.Vertex v2 = new TriMesh.Vertex(new VertexTraits(pos));
this.mesh.AppendToVertexList(v2);
this.cutPoint[hf.Index] = new CutPoint { Left = v1, Right = v2 };
}
}
public static TriMesh Combine(List<TriMesh> meshes)
{
TriMesh combine = new TriMesh();
foreach (TriMesh mesh in meshes)
{
if (mesh != null)
{
TriMesh.Vertex[] arr = new TriMesh.Vertex[mesh.Vertices.Count];
foreach (TriMesh.Vertex v in mesh.Vertices)
{
arr[v.Index] = combine.Vertices.Add(new VertexTraits(v.Traits.Position));
arr[v.Index].Traits = v.Traits;
}
foreach (TriMesh.Face face in mesh.Faces)
{
TriMesh.Face faceNew=combine.Faces.Add(arr[face.GetVertex(0).Index],
arr[face.GetVertex(1).Index],
arr[face.GetVertex(2).Index]);
faceNew.Traits = face.Traits;
}
}
}
return combine;
}
private void BulidBoneFace(int v1, int v2, int v3)//为正方形添加面
{
TriMesh.Vertex[] faceVertices = new TriMesh.Vertex[3];
faceVertices[0] = this.Vertices[v1];
faceVertices[1] = this.Vertices[v2];
faceVertices[2] = this.Vertices[v3];
TriMesh.Face[] addedFaces = this.Faces.AddTriangles(faceVertices);
}
DenseMatrixQuaternion BuildOmega(DenseMatrixQuaternion lamda)
{
DenseMatrixQuaternion Omega = new DenseMatrixQuaternion(mesh.Vertices.Count, 1);
TriMesh.Vertex[] index = new TriMesh.Vertex[3];
foreach (TriMesh.Face face in mesh.Faces)
{
index[0] = face.GetVertex(2);
index[1] = face.GetVertex(0);
index[2] = face.GetVertex(1);
for (int i = 0; i < 3; i++)
{
Quaternion f0 = new Quaternion(index[(i + 0) % 3].Traits.Position, 0);
Quaternion f1 = new Quaternion(index[(i + 1) % 3].Traits.Position, 0);
Quaternion f2 = new Quaternion(index[(i + 2) % 3].Traits.Position, 0);
//Setting Orientation Swap it
TriMesh.Vertex aI = index[(i + 1) % 3];
TriMesh.Vertex bI = index[(i + 2) % 3];
if (aI.Index > bI.Index)
{
aI = index[(i + 2) % 3];
bI = index[(i + 1) % 3];
}
Quaternion aLamda = lamda[aI.Index, 0];
Quaternion bLamda = lamda[bI.Index, 0];
Quaternion e = new Quaternion(bI.Traits.Position, 0) - new Quaternion(aI.Traits.Position, 0);
Quaternion conj = aLamda.Conjugate();
Quaternion bconj = bLamda.Conjugate();
Quaternion partA = conj * e * aLamda;
Quaternion eTilde = (1f / 3f) * partA +
(1f / 6f) * aLamda.Conjugate() * e * bLamda +
(1f / 6f) * bLamda.Conjugate() * e * aLamda +
(1f / 3f) * bLamda.Conjugate() * e * bLamda;
Vector3D u1 = index[(i + 1) % 3].Traits.Position - index[(i + 0) % 3].Traits.Position;
Vector3D u2 = index[(i + 2) % 3].Traits.Position - index[(i + 0) % 3].Traits.Position;
double cotAlpha = u1.Dot(u2) / u1.Cross(u2).Length();
Quaternion q = cotAlpha * eTilde / 2;
Omega[aI.Index, 0] -= q;
Omega[bI.Index, 0] += q;
}
}
RemoveMean(ref Omega);
return Omega;
}
public static TriMesh ToTriMesh(QuadMesh mesh)
{
TriMesh trimesh = new TriMesh();
for (int i = 0; i < mesh.Vertices.Count; i++)
{
Vector3D position = mesh.Vertices[i].Traits.Position;
trimesh.Vertices.Add(new VertexTraits(position.x, position.y, position.z));
}
foreach (QuadMesh.Face face in mesh.Faces)
{
int v0 = face.GetVertex(0).Index;
int v1 = face.GetVertex(1).Index;
int v2 = face.GetVertex(2).Index;
int v3 = face.GetVertex(3).Index;
TriMesh.Vertex[] faceVertices = new TriMesh.Vertex[3];
faceVertices[0] = trimesh.Vertices[v0];
faceVertices[1] = trimesh.Vertices[v1];
faceVertices[2] = trimesh.Vertices[v2];
trimesh.Faces.AddTriangles(faceVertices);
faceVertices[0] = trimesh.Vertices[v2];
faceVertices[1] = trimesh.Vertices[v3];
faceVertices[2] = trimesh.Vertices[v0];
trimesh.Faces.AddTriangles(faceVertices);
}
return trimesh;
}
private static void ProcessPlyLine(TriMesh mesh, string line, PlyFileProcessorState state)
{
// Trim out comments (allow comments trailing on a line)
int commentStart = line.IndexOf("ply");
if (commentStart != -1)
{
line = line.Substring(0, commentStart);
}
// Tokenize line
string[] tokens = line.Split((char[])null, StringSplitOptions.RemoveEmptyEntries);
// Process line based on the keyword used
if (tokens.Length > 0)
{
int? v;
float x, y, z;
TriMesh.Vertex[] faceVertices;
int?[] vt, vn;
if (tokens[0] == "element" && tokens[1] == "vertex")
{
state.Vnum = Int32.Parse(tokens[2]);
}
else if (tokens[0] == "element" && tokens[1] == "face")
{
state.Fnum = Int32.Parse(tokens[2]);
}
else if (tokens[0] == "end_header")
{
state.startv = true;
}
else if (state.startv == true )
{
x = Single.Parse(tokens[0]);
y = Single.Parse(tokens[1]);
z = Single.Parse(tokens[2]);
double r = Single.Parse(tokens[3]);
double g = Single.Parse(tokens[4]);
double b = Single.Parse(tokens[5]);
double nx = Single.Parse(tokens[6]);
double ny = Single.Parse(tokens[7]);
double nz = Single.Parse(tokens[8]);
int sel = int.Parse(tokens[9]);
double tx = Single.Parse(tokens[10]);
double ty = Single.Parse(tokens[11]);
TriMesh.Vertex vertex= mesh.Vertices.Add(new VertexTraits(x, y, z));
vertex.Traits.Color = new Color4(r, g, b);
vertex.Traits.SelectedFlag = (byte)sel;
vertex.Traits.UV.x = tx;
vertex.Traits.UV.y = ty;
state.countv += 1;
if (state.countv == state.Vnum)
{
state.startf = true;
state.startv = false;
}
}
else if (state.startf == true)
{
int vCount = int.Parse(tokens[0]);
faceVertices = new TriMesh.Vertex[vCount];
// Parse vertex/texture coordinate/normal indices
for (int i = 0; i < faceVertices.Length; ++i)
{
//string[] vertexTokens = tokens[i + 1].Split("/".ToCharArray());
v = Int32.Parse(tokens[i + 1]);
faceVertices[i] = mesh.Vertices[v.Value];
}
TriMesh.Face[] addedFaces = mesh.Faces.AddTriangles(faceVertices);
double r = Single.Parse(tokens[vCount+1]);
double g = Single.Parse(tokens[vCount + 2]);
double b = Single.Parse(tokens[vCount + 3]);
int sel = int.Parse(tokens[vCount + 4]);
//double vx = Single.Parse(tokens[vCount + 5]);
//double vy = Single.Parse(tokens[vCount + 6]);
addedFaces[0].Traits.SelectedFlag = (byte)sel;
addedFaces[0].Traits.Color = new Color4(r, g, b);
state.countf+= 1;
if (state.countf== state.Fnum)
{
state.starte = true;
state.startf = false;
}
}
else if (state.starte == true)
{
int sel = int.Parse(tokens[0]);
mesh.Edges[state.counte].Traits.SelectedFlag =(byte)sel;
state.counte += 1;
}
}
}
public TriMesh CreateSquareSpoke(int length, int width)
{
TriMesh mesh = new TriMesh();
double x0 = -this.GridSizeX * length / 2d;
double y0 = -this.GridSizeX * width / 2d;
double z0 = 0;
double d = this.GridSizeX / 2;
int t = 4;
TriMesh.Vertex[,] v = new TriMesh.Vertex[length + 1, width + 1];
for (int i = 0; i < length + 1; i++)
{
for (int j = 0; j < width + 1; j++)
{
double x = x0 + this.GridSizeX * i;
double y = y0 + this.GridSizeX * j;
int r = i % t == j % t ? i % t : 0;
double z = z0 - (Math.Abs(r - t / 2) - t / 2) * d;
v[i, j] = mesh.Vertices.Add(new VertexTraits(x, y, z));
}
}
for (int i = 0; i < length; i++)
{
for (int j = 0; j < width; j++)
{
mesh.Faces.AddTriangles(v[i, j], v[i + 1, j], v[i + 1, j + 1], v[i, j + 1]);
}
}
TriMeshUtil.SetUpNormalVertex(mesh);
return mesh;
}
public TriMesh.Vertex VertexSplit1(TriMesh.Vertex v, TriMesh.Vertex vshard1, TriMesh.Vertex vshard2, Vector3D v1Position, Vector3D v2Position, int v2FixedIndex)
{
//1.Get two group of verties
TriMesh.HalfEdge[] processGroup = FindGroup(v, vshard1, vshard2);
TriMesh mesh = (TriMesh)v.Mesh;
TriMesh.Vertex v1 = null;
TriMesh.Vertex v2 = null;
TriMesh.Vertex newVertex = null;
v1 = v;
v.Traits.Position = v1Position;
v2 = new TriMesh.Vertex();
v2.Traits = new VertexTraits(Vector3D.Zero);
newVertex = v2;
newVertex.Traits.FixedIndex = v2FixedIndex;
v2.Mesh = v.Mesh;
v2.Traits.Position = v2Position;
//2.Process the Topology
TriMesh.HalfEdge hf1Origin = processGroup[0];
TriMesh.HalfEdge hf2Origin = processGroup[processGroup.Length - 1];
//Add new edge
TriMesh.HalfEdge hf3 = new TriMesh.HalfEdge();
TriMesh.HalfEdge hf3Oppsite = new TriMesh.HalfEdge();
TriMesh.Edge edge = new TriMesh.Edge();
hf3.Opposite = hf3Oppsite;
hf3Oppsite.Opposite = hf3;
edge.HalfEdge0 = hf3;
edge.HalfEdge1 = hf3Oppsite;
hf3.Edge = edge;
hf3Oppsite.Edge = edge;
hf3.ToVertex = v2;
hf3Oppsite.ToVertex = v1;
//Handle hf1Origin which is outter hafledge [INNER]
TriMesh.HalfEdge hf1 = new TriMesh.HalfEdge();
hf1.Opposite = hf1Origin;
hf1.ToVertex = v1;
TriMesh.HalfEdge hf1Other = new TriMesh.HalfEdge();
hf1Other.Opposite = hf1Origin.Opposite;
hf1Other.ToVertex = hf1Origin.ToVertex;
hf1.Previous = hf1Other;
hf1Other.Next = hf1;
hf1.Next = hf3;
hf3.Previous = hf1;
hf1Other.Previous = hf3;
hf3.Next = hf1Other;
//Handle hf2Origin which is inner hafledge [INNER]
TriMesh.HalfEdge hf2 = new TriMesh.HalfEdge();
hf2.Opposite = hf2Origin;
hf2.ToVertex = v2;
TriMesh.HalfEdge hf2Other = new TriMesh.HalfEdge();
hf2Other.Opposite = hf2Origin.Opposite;
hf2Other.ToVertex = hf2Origin.ToVertex;
hf2.Previous = hf2Other;
hf2Other.Next = hf2;
hf2.Next = hf3Oppsite;
hf3Oppsite.Previous = hf2;
hf2Other.Previous = hf3Oppsite;
hf3Oppsite.Next = hf2Other;
TriMesh.Face face1 = new TriMesh.Face();
TriMesh.Face face2 = new TriMesh.Face();
face1.HalfEdge = hf3;
hf3.Face = face1;
hf1.Face = face1;
hf1Other.Face = face1;
face2.HalfEdge = hf3Oppsite;
hf3Oppsite.Face = face2;
hf2.Face = face2;
hf2Other.Face = face2;
//Process the outside
TriMesh.Edge edge1 = new TriMesh.Edge();
TriMesh.HalfEdge hf1OriginOppsite = hf1Origin.Opposite;
hf1Origin.Opposite = hf1;
hf1.Edge = hf1Origin.Edge;
hf1OriginOppsite.Opposite = hf1Other;
hf1OriginOppsite.ToVertex = v2;
hf1OriginOppsite.Edge = edge1;
hf1Other.Edge = edge1;
edge1.HalfEdge0 = hf1Other;
edge1.HalfEdge1 = hf1OriginOppsite;
TriMesh.Edge edge2 = new TriMesh.Edge();
TriMesh.HalfEdge hf2OriginOppsite = hf2Origin.Opposite;
hf2Origin.Opposite = hf2;
hf2.Edge = hf2Origin.Edge;
hf2OriginOppsite.Opposite = hf2Other;
hf2OriginOppsite.ToVertex = v1;
hf2OriginOppsite.Edge = edge2;
hf2Other.Edge = edge2;
edge2.HalfEdge0 = hf2Other;
edge2.HalfEdge1 = hf2OriginOppsite;
v1.HalfEdge = hf1Origin;
v2.HalfEdge = hf2Origin;
mesh.AppendToEdgeList(edge);
mesh.AppendToEdgeList(edge1);
mesh.AppendToEdgeList(edge2);
mesh.AppendToFaceList(face1);
mesh.AppendToFaceList(face2);
mesh.AppendToHalfedgeList(hf1);
mesh.AppendToHalfedgeList(hf1Other);
mesh.AppendToHalfedgeList(hf2);
mesh.AppendToHalfedgeList(hf2Other);
mesh.AppendToHalfedgeList(hf3);
mesh.AppendToHalfedgeList(hf3Oppsite);
mesh.AppendToVertexList(newVertex);
for (int i = 1; i < processGroup.Length - 1; i++)
{
processGroup[i].Opposite.ToVertex = newVertex;
}
//mesh.FixIndex();
return newVertex;
}
/// <summary>
/// Computes vertex normals.
/// </summary>
/// <param name="cornerArea">A halfedge dynamic trait with face vertex angular areas.</param>
/// <param name="pointArea">A vertex dynamic trait with vertex angular areas.</param>
public void ComputeFaceVertexNormals(TriMesh mesh, TriMesh.HalfedgeDynamicTrait<float> cornerArea, TriMesh.VertexDynamicTrait<float> pointArea)
{
TriMesh.FaceDynamicTrait<Vector3D> normal = new TriMesh.FaceDynamicTrait<Vector3D>(mesh);
TriMesh.Vertex[] fv = new TriMesh.Vertex[3];
// Compute normal for each face
foreach (TriMesh.Face f in mesh.Faces)
{
int i = 0;
foreach (TriMesh.Vertex v in f.Vertices)
{
fv[i] = v;
++i;
}
// Compute normal for this face
normal[f] = (fv[2].Traits.Position - fv[1].Traits.Position).Cross(fv[0].Traits.Position - fv[2].Traits.Position);
normal[f] = normal[f].Normalize();
f.Traits.Normal = normal[f];
}
// Compute normal for each vertex
foreach (TriMesh.HalfEdge h in mesh.HalfEdges)
{
if (!h.OnBoundary) // Ignore halfedges that don't have a face
{
float weight = cornerArea[h] / pointArea[h.ToVertex];
h.ToVertex.Traits.Normal += weight * normal[h.Face];
}
}
// Normalize normals
foreach (TriMesh.Vertex v in mesh.Vertices)
{
if (Math.Sqrt(v.Traits.Normal.Length()) > 0.0f) // Ignore isolated points
{
v.Traits.Normal.Normalize();
}
}
}
private static void ProcessOffLine(TriMesh mesh, string line, OffFileProcessorState state, ref bool ignoreFirstThreeNum)
{
// Trim out comments (allow comments trailing on a line)
int commentStart = line.IndexOf("OFF");
if (commentStart != -1)
{
line = line.Substring(0, commentStart);
}
// Tokenize line
string[] tokens = line.Split((char[])null, StringSplitOptions.RemoveEmptyEntries);
// Process line based on the keyword used
if (tokens.Length > 0)
{
int? v;
float x, y, z;
TriMesh.Vertex[] faceVertices;
int?[] vt, vn;
if (tokens.Length == 3)
{
if (!ignoreFirstThreeNum)
{
x = Single.Parse(tokens[0]);
y = Single.Parse(tokens[1]);
z = Single.Parse(tokens[2]);
mesh.Vertices.Add(new VertexTraits(x, y, z));
}
ignoreFirstThreeNum = false;
}
else if (tokens.Length == 4 || tokens.Length == 5)
{
faceVertices = new TriMesh.Vertex[tokens.Length - 1];
vt = new int?[tokens.Length - 1];
vn = new int?[tokens.Length - 1];
// Parse vertex/texture coordinate/normal indices
for (int i = 0; i < faceVertices.Length; ++i)
{
//string[] vertexTokens = tokens[i + 1].Split("/".ToCharArray());
v = Int32.Parse(tokens[i + 1]);
faceVertices[i] = mesh.Vertices[v.Value];
}
TriMesh.Face[] addedFaces = mesh.Faces.AddTriangles(faceVertices);
// Set texture coordinates and normals if any are given
for (int i = 0; i < faceVertices.Length; ++i)
{
TriMesh.HalfEdge faceVertex;
if (vt[i].HasValue || vn[i].HasValue)
{
foreach (TriMesh.Face f in addedFaces)
{
faceVertex = f.FindHalfedgeTo(faceVertices[i]);
if (faceVertex != null) // Make sure vertex belongs to face if triangularization is on
{
if (vt[i].HasValue)
{
faceVertex.Traits.TextureCoordinate = state.VertexTextureCoords[vt[i].Value - 1];
}
if (vn[i].HasValue)
{
faceVertex.Traits.Normal = state.VertexNormals[vn[i].Value - 1];
}
}
}
}
}
}
}
}
public void MakeTheTopologyB(PolygonMesh dualMesh)
{
List<TriMesh.Vertex> boundaryVertices = new List<TriMesh.Vertex>();
boundaryVertices = TriMeshUtil.RetrieveAllBoundaryVertex(mesh);
foreach (TriMesh.Face face in mesh.Faces)
{
int index = face.Index;
int baryVertexIndex = mesh.Edges.Count;
int edgeVertexIndex;
int faceIndex = index;
TriMesh.Edge boundaryEdge = new TriMesh.Edge();
TriMesh.HalfEdge tempHalfedge = new TriMesh.HalfEdge();
TriMesh.Vertex vertex0 = mesh.Faces[index].GetVertex(0);
TriMesh.Vertex vertex1 = mesh.Faces[index].GetVertex(1);
TriMesh.Vertex vertex2 = mesh.Faces[index].GetVertex(2);
TriMesh.HalfEdge halfedge0 = vertex0.FindHalfedgeTo(vertex1);
TriMesh.HalfEdge halfedge1 = vertex1.FindHalfedgeTo(vertex2);
TriMesh.HalfEdge halfedge2 = vertex2.FindHalfedgeTo(vertex0);
TriMesh.HalfEdge boundaryHalfedge = new TriMesh.HalfEdge();
tempHalfedge = halfedge0;
edgeVertexIndex = halfedge0.Edge.Index;
TriMesh.Vertex firstVertex = dualMesh.Vertices[baryVertexIndex + faceIndex];
TriMesh.Vertex secondVertex = dualMesh.Vertices[edgeVertexIndex];
if (firstVertex.FindHalfedgeTo(secondVertex) == null)
{
List<TriMesh.Vertex> ringVertices = new List<TriMesh.Vertex>();
do
{
ringVertices.Add(dualMesh.Vertices[baryVertexIndex + faceIndex]);
ringVertices.Add(dualMesh.Vertices[edgeVertexIndex]);
if (tempHalfedge.Opposite.Next.Face != null)
{
tempHalfedge = tempHalfedge.Opposite.Next;
faceIndex = tempHalfedge.Face.Index;
edgeVertexIndex = tempHalfedge.Edge.Index;
}
else
{
tempHalfedge = tempHalfedge.Opposite.Next;
edgeVertexIndex = tempHalfedge.Edge.Index;
faceIndex = tempHalfedge.Opposite.Next.Face.Index;
}
} while (tempHalfedge != halfedge0);
TriMesh.Vertex[] newFaceVertices = new TriMesh.Vertex[ringVertices.Count];
for (int i = 0; i < ringVertices.Count; i++)
{
newFaceVertices[i] = ringVertices[i];
}
dualMesh.Faces.Add(newFaceVertices);
}
tempHalfedge = halfedge1;
edgeVertexIndex = halfedge1.Edge.Index;
firstVertex = dualMesh.Vertices[baryVertexIndex + faceIndex];
secondVertex = dualMesh.Vertices[edgeVertexIndex];
if (firstVertex.FindHalfedgeTo(secondVertex) == null)
{
List<TriMesh.Vertex> ringVertices = new List<TriMesh.Vertex>();
do
{
ringVertices.Add(dualMesh.Vertices[baryVertexIndex + faceIndex]);
ringVertices.Add(dualMesh.Vertices[edgeVertexIndex]);
if (tempHalfedge.Opposite.Next != null)
{
tempHalfedge = tempHalfedge.Opposite.Next;
faceIndex = tempHalfedge.Face.Index;
edgeVertexIndex = tempHalfedge.Edge.Index;
}
else
{
continue;
}
} while (tempHalfedge != halfedge1);
TriMesh.Vertex[] newFaceVertices = new TriMesh.Vertex[ringVertices.Count];
for (int i = 0; i < ringVertices.Count; i++)
{
newFaceVertices[i] = ringVertices[i];
}
dualMesh.Faces.Add(newFaceVertices);
}
tempHalfedge = halfedge2;
edgeVertexIndex = halfedge2.Edge.Index;
firstVertex = dualMesh.Vertices[baryVertexIndex + faceIndex];
secondVertex = dualMesh.Vertices[edgeVertexIndex];
if (firstVertex.FindHalfedgeTo(secondVertex) == null)
{
List<TriMesh.Vertex> ringVertices = new List<TriMesh.Vertex>();
do
{
ringVertices.Add(dualMesh.Vertices[baryVertexIndex + faceIndex]);
ringVertices.Add(dualMesh.Vertices[edgeVertexIndex]);
if (tempHalfedge.Opposite.Next != null)
{
tempHalfedge = tempHalfedge.Opposite.Next;
faceIndex = tempHalfedge.Face.Index;
edgeVertexIndex = tempHalfedge.Edge.Index;
}
else
{
continue;
}
} while (tempHalfedge != halfedge2);
TriMesh.Vertex[] newFaceVertices = new TriMesh.Vertex[ringVertices.Count];
for (int i = 0; i < ringVertices.Count; i++)
{
newFaceVertices[i] = ringVertices[i];
}
dualMesh.Faces.Add(newFaceVertices);
}
}
}
public void ComputeGeometryC(PolygonMesh dualMesh)
{
//get the mid-Vertex of each edges
TriMesh.Vertex[] edgeVertices = new TriMesh.Vertex[mesh.Faces.Count * 3];
foreach (TriMesh.Edge e in mesh.Edges)
{
Vector3D midVertex0 = TriMeshUtil.GetMidPoint(e);
dualMesh.Vertices.Add(new VertexTraits(midVertex0.x,
midVertex0.y,
midVertex0.z));
}
//get circumcentre of each faces
foreach (TriMesh.Face f in mesh.Faces)
{
TriMesh.Vertex vertex0 = f.GetVertex(0);
TriMesh.Vertex vertex1 = f.GetVertex(1);
TriMesh.Vertex vertex2 = f.GetVertex(2);
Triangle triangle = new Triangle(vertex0.Traits.Position, vertex1.Traits.Position, vertex2.Traits.Position);
Vector3D circumCenter = triangle.ComputeCircumCenter();
dualMesh.Vertices.Add(new VertexTraits(circumCenter.x,
circumCenter.y,
circumCenter.z));
}
}
public static TriMesh ConvertToTriMesh(NonManifoldMesh mesh)
{
TriMesh triMesh = new GraphicResearchHuiZhao.TriMesh();
triMesh.Traits.HasFaceVertexNormals = true;
triMesh.Traits.HasTextureCoordinates = true;
if (mesh.VertexNormal == null)
{
triMesh.Traits.HasFaceVertexNormals = false;
}
else
{
triMesh.Traits.HasFaceVertexNormals = true;
}
if (mesh.TextextCoordinate == null)
{
triMesh.Traits.HasTextureCoordinates = false;
}
else
{
triMesh.Traits.HasTextureCoordinates = true;
}
int vertexCount = mesh.VertexCount;
int faceCount = mesh.FaceCount;
for (int i = 0; i < vertexCount; i++)
{
VertexTraits traits = new VertexTraits((float)mesh.VertexPos[i * 3], (float)mesh.VertexPos[i * 3 + 1], (float)mesh.VertexPos[i * 3 + 2]);
triMesh.Vertices.Add(traits);
}
TriMesh.Vertex[] vertices = new TriMesh.Vertex[3];
for (int i = 0; i < faceCount; i++)
{
vertices[0] = triMesh.Vertices[mesh.FaceIndex[i * 3]];
vertices[1] = triMesh.Vertices[mesh.FaceIndex[i * 3 + 1]];
vertices[2] = triMesh.Vertices[mesh.FaceIndex[i * 3 + 2]];
triMesh.Faces.AddTriangles(vertices);
}
if (triMesh.Traits.HasTextureCoordinates)
{
TriMesh.HalfEdge faceVertex;
foreach (TriMesh.Face face in triMesh.Faces)
{
foreach (TriMesh.Vertex vertex in face.Vertices)
{
faceVertex = face.FindHalfedgeTo(vertex);
if (faceVertex != null) // Make sure vertex belongs to face if triangularization is on
{
faceVertex.Traits.TextureCoordinate = new Vector2D(mesh.TextextCoordinate[vertex.Index * 2], mesh.TextextCoordinate[vertex.Index * 2 + 1]);
}
}
}
}
if (triMesh.Traits.HasFaceVertexNormals)
{
TriMesh.HalfEdge faceVertex;
foreach (TriMesh.Face face in triMesh.Faces)
{
foreach (TriMesh.Vertex vertex in face.Vertices)
{
faceVertex = face.FindHalfedgeTo(vertex);
if (faceVertex != null) // Make sure vertex belongs to face if triangularization is on
{
faceVertex.Traits.Normal = new Vector3D(mesh.FaceNormal, vertex.Index);
}
}
}
}
//if (triMesh.Traits.HasTextureCoordinates)
//{
// foreach (HalfEdgeMesh.TriMesh.Vertex vertex in triMesh.Vertices )
// {
// vertex.Traits.TextureCoordinate = new Vector2d(mesh.TextextCoordinate[vertex.Index * 2], mesh.TextextCoordinate[vertex.Index * 2 + 1]);
// }
//}
//if (triMesh.Traits.HasFaceVertexNormals)
//{
// foreach (HalfEdgeMesh.TriMesh.Vertex vertex in triMesh.Vertices)
// {
// vertex.Traits.Normal = new Vector3d(mesh.FaceNormal, vertex.Index);
// }
//}
return triMesh;
}
/// <summary>
/// Processes a line from an OBJ file.
/// </summary>
/// <param name="line">A line from an OBJ file.</param>
/// <param name="state">An object that manages state between calls.</param>
private static void ProcessObjLine(TriMesh mesh, string line, ObjFileProcessorState state)
{
// Trim out comments (allow comments trailing on a line)
int commentStart = line.IndexOf('#');
if (commentStart != -1)
{
line = line.Substring(0, commentStart);
}
// Tokenize line
string[] tokens = line.Split((char[])null, StringSplitOptions.RemoveEmptyEntries);
// Process line based on the keyword used
if (tokens.Length > 0)
{
int? v;
float x, y, z;
TriMesh.Vertex[] faceVertices;
int?[] vt, vn;
switch (tokens[0])
{
case "v": // Vertex
if (tokens.Length != 4)
{
throw new IOException("Vertices in the OBJ file must have 3 coordinates.");
}
x = Single.Parse(tokens[1]);
y = Single.Parse(tokens[2]);
z = Single.Parse(tokens[3]);
mesh.Vertices.Add(new VertexTraits(x, y, z));
break;
case "vt": // Vertex texture
if (tokens.Length != 3 && tokens.Length != 4)
{
throw new IOException("Texture coordinates in the OBJ file must have 2 or 3 coordinates.");
}
x = Single.Parse(tokens[1]);
y = Single.Parse(tokens[2]);
state.VertexTextureCoords.Add(new Vector2D(x, y));
break;
case "vn": // Vertex normal
if (tokens.Length != 4)
{
throw new IOException("Vertex normals in the OBJ file must have 3 coordinates.");
}
x = Single.Parse(tokens[1]);
y = Single.Parse(tokens[2]);
z = Single.Parse(tokens[3]);
state.VertexNormals.Add(new Vector3D(x, y, z));
break;
case "f": // Face
faceVertices = new TriMesh.Vertex[tokens.Length - 1];
vt = new int?[tokens.Length - 1];
vn = new int?[tokens.Length - 1];
// Parse vertex/texture coordinate/normal indices
for (int i = 0; i < faceVertices.Length; ++i)
{
string[] vertexTokens = tokens[i + 1].Split("/".ToCharArray());
v = Int32.Parse(vertexTokens[0]);
if (vertexTokens.Length > 1 && vertexTokens[1].Length > 0)
{
vt[i] = Int32.Parse(vertexTokens[1]);
}
else
{
mesh.Traits.HasTextureCoordinates = false;
}
if (vertexTokens.Length > 2 && vertexTokens[2].Length > 0)
{
vn[i] = Int32.Parse(vertexTokens[2]);
}
else
{
mesh.Traits.HasFaceVertexNormals = false;
}
faceVertices[i] = mesh.Vertices[v.Value - 1];
}
try
{
TriMesh.Face[] addedFaces = mesh.Faces.AddTriangles(faceVertices);
// Set texture coordinates and normals if any are given
for (int i = 0; i < faceVertices.Length; ++i)
{
TriMesh.HalfEdge faceVertex;
if (vt[i].HasValue || vn[i].HasValue)
{
foreach (TriMesh.Face f in addedFaces)
{
faceVertex = f.FindHalfedgeTo(faceVertices[i]);
if (faceVertex != null) // Make sure vertex belongs to face if triangularization is on
{
if (vt[i].HasValue)
{
faceVertex.Traits.TextureCoordinate = state.VertexTextureCoords[vt[i].Value - 1];
}
if (vn[i].HasValue)
{
faceVertex.Traits.Normal = state.VertexNormals[vn[i].Value - 1];
}
}
}
}
}
}
catch { }
break;
}
}
}
public static void RepairHole(TriMesh mesh)
{
List<TriMesh.Vertex> hole = new List<TriMesh.Vertex>();
hole = TriMeshUtil.RetrieveBoundarySingle(mesh);
TriMesh.Vertex[] faceVertices = new TriMesh.Vertex[3];
for (int i = 0; i < hole.Count - 2; i++)
{
faceVertices[0] = mesh.Vertices[hole[0].Index];
faceVertices[1] = mesh.Vertices[hole[i + 1].Index];
faceVertices[2] = mesh.Vertices[hole[i + 2].Index];
mesh.Faces.AddTriangles(faceVertices);
}
TriMeshUtil.FixIndex(mesh);
}
public static void RepairComplexHole(TriMesh mesh)
{
List<TriMesh.Vertex> hole = new List<TriMesh.Vertex>();
TriMesh.Vertex[] faceVertices = new TriMesh.Vertex[3];
while (true)//此循环只限单洞修补
{
//计算边界边的平均值
#region 计算边界边的平均值
hole = TriMeshUtil.RetrieveBoundarySingle(mesh);
double aver_l = 0;
double[] edgeLength = new double[hole.Count];
for (int i = 0; i < hole.Count; i++)
{
if (i == hole.Count - 1)
{
edgeLength[i] = Math.Sqrt(Math.Pow(hole[i].Traits.Position.x - hole[0].Traits.Position.x, 2) + Math.Pow(hole[i].Traits.Position.y - hole[0].Traits.Position.y, 2) + Math.Pow(hole[i].Traits.Position.z - hole[0].Traits.Position.z, 2));
break;
}
edgeLength[i] = Math.Sqrt(Math.Pow(hole[i].Traits.Position.x - hole[i + 1].Traits.Position.x, 2) + Math.Pow(hole[i].Traits.Position.y - hole[i + 1].Traits.Position.y, 2) + Math.Pow(hole[i].Traits.Position.z - hole[i + 1].Traits.Position.z, 2));
}
for (int i = 0; i < hole.Count; i++)
{
aver_l += edgeLength[i];
}
aver_l = aver_l / hole.Count;
#endregion
hole = TriMeshUtil.RetrieveBoundarySingle(mesh);
//计算角度值
#region 计算角度值
double[] angle = new double[hole.Count];
double a = 0, b = 0, c = 0;
for (int i = 0; i < hole.Count; i++)
{
if (i == 0)
{
a = Math.Sqrt(Math.Pow(hole[hole.Count - 1].Traits.Position.x - hole[i + 1].Traits.Position.x, 2) + Math.Pow(hole[hole.Count - 1].Traits.Position.y - hole[i + 1].Traits.Position.y, 2) + Math.Pow(hole[hole.Count - 1].Traits.Position.z - hole[i + 1].Traits.Position.z, 2));
b = Math.Sqrt(Math.Pow(hole[i].Traits.Position.x - hole[i + 1].Traits.Position.x, 2) + Math.Pow(hole[i].Traits.Position.y - hole[i + 1].Traits.Position.y, 2) + Math.Pow(hole[i].Traits.Position.z - hole[i + 1].Traits.Position.z, 2));
c = Math.Sqrt(Math.Pow(hole[hole.Count - 1].Traits.Position.x - hole[i].Traits.Position.x, 2) + Math.Pow(hole[hole.Count - 1].Traits.Position.y - hole[i].Traits.Position.y, 2) + Math.Pow(hole[hole.Count - 1].Traits.Position.z - hole[i].Traits.Position.z, 2));
angle[i] = Math.Acos((b * b + c * c - a * a) / (2 * b * c));
}
else if (i == hole.Count - 1)
{
a = Math.Sqrt(Math.Pow(hole[i - 1].Traits.Position.x - hole[0].Traits.Position.x, 2) + Math.Pow(hole[i - 1].Traits.Position.y - hole[0].Traits.Position.y, 2) + Math.Pow(hole[i - 1].Traits.Position.z - hole[0].Traits.Position.z, 2));
b = Math.Sqrt(Math.Pow(hole[i].Traits.Position.x - hole[0].Traits.Position.x, 2) + Math.Pow(hole[i].Traits.Position.y - hole[0].Traits.Position.y, 2) + Math.Pow(hole[i].Traits.Position.z - hole[0].Traits.Position.z, 2));
c = Math.Sqrt(Math.Pow(hole[i - 1].Traits.Position.x - hole[i].Traits.Position.x, 2) + Math.Pow(hole[i - 1].Traits.Position.y - hole[i].Traits.Position.y, 2) + Math.Pow(hole[i - 1].Traits.Position.z - hole[i].Traits.Position.z, 2));
angle[i] = Math.Acos((b * b + c * c - a * a) / (2 * b * c));
}
else
{
a = Math.Sqrt(Math.Pow(hole[i - 1].Traits.Position.x - hole[i + 1].Traits.Position.x, 2) + Math.Pow(hole[i - 1].Traits.Position.y - hole[i + 1].Traits.Position.y, 2) + Math.Pow(hole[i - 1].Traits.Position.z - hole[i + 1].Traits.Position.z, 2));
b = Math.Sqrt(Math.Pow(hole[i].Traits.Position.x - hole[i + 1].Traits.Position.x, 2) + Math.Pow(hole[i].Traits.Position.y - hole[i + 1].Traits.Position.y, 2) + Math.Pow(hole[i].Traits.Position.z - hole[i + 1].Traits.Position.z, 2));
c = Math.Sqrt(Math.Pow(hole[i - 1].Traits.Position.x - hole[i].Traits.Position.x, 2) + Math.Pow(hole[i - 1].Traits.Position.y - hole[i].Traits.Position.y, 2) + Math.Pow(hole[i - 1].Traits.Position.z - hole[i].Traits.Position.z, 2));
angle[i] = Math.Acos((b * b + c * c - a * a) / (2 * b * c));
}
}
#endregion
//取得最小的角度
#region 取得最小的角度
int min = 0;
for (int i = 0; i < hole.Count - 1; i++)
{
if (angle[i] < angle[i + 1])
min = i;
else
min = i + 1;
}
#endregion
//求最小角度对应的边长
#region 求最小角度对应的边长
double temp = 0;
if (min == hole.Count - 1)
{
temp = Math.Sqrt(Math.Pow(hole[min - 1].Traits.Position.x - hole[0].Traits.Position.x, 2) + Math.Pow(hole[min - 1].Traits.Position.y - hole[0].Traits.Position.y, 2) + Math.Pow(hole[min - 1].Traits.Position.z - hole[0].Traits.Position.z, 2));
}
else if (min == 0)
{
temp = Math.Sqrt(Math.Pow(hole[hole.Count - 1].Traits.Position.x - hole[min + 1].Traits.Position.x, 2) + Math.Pow(hole[hole.Count - 1].Traits.Position.y - hole[min + 1].Traits.Position.y, 2) + Math.Pow(hole[hole.Count - 1].Traits.Position.z - hole[min + 1].Traits.Position.z, 2));
}
else
{
temp = Math.Sqrt(Math.Pow(hole[min - 1].Traits.Position.x - hole[min + 1].Traits.Position.x, 2) + Math.Pow(hole[min - 1].Traits.Position.y - hole[min + 1].Traits.Position.y, 2) + Math.Pow(hole[min - 1].Traits.Position.z - hole[min + 1].Traits.Position.z, 2));
}
#endregion
//判断最小角对应的边与平均边界边长，并进行修补
#region 判断最小角对应的边与平均边界边长，并进行修补
if (temp > aver_l)
{
if (min == hole.Count - 1)
{
faceVertices[0] = mesh.Vertices[hole[min].Index];
faceVertices[1] = mesh.Vertices[hole[0].Index];
faceVertices[2] = mesh.Vertices[hole[min - 1].Index];
mesh.Faces.AddTriangles(faceVertices);
}
else if (min == 0)
{
faceVertices[0] = mesh.Vertices[hole[min].Index];
faceVertices[1] = mesh.Vertices[hole[min + 1].Index];
faceVertices[2] = mesh.Vertices[hole[hole.Count - 1].Index];
mesh.Faces.AddTriangles(faceVertices);
}
else
{
faceVertices[0] = mesh.Vertices[hole[min].Index];
faceVertices[1] = mesh.Vertices[hole[min + 1].Index];
faceVertices[2] = mesh.Vertices[hole[min - 1].Index];
mesh.Faces.AddTriangles(faceVertices);
}
}
else
{
if (min == hole.Count - 1)
{
Vector3D midPosition;
midPosition = (hole[min - 1].Traits.Position + hole[0].Traits.Position) / 2;
mesh.Vertices.Add(new VertexTraits(midPosition.x, midPosition.y, midPosition.z));
faceVertices[0] = mesh.Vertices[hole[min].Index];
faceVertices[1] = mesh.Vertices[mesh.Vertices.Count - 1];
faceVertices[2] = mesh.Vertices[hole[min - 1].Index];
mesh.Faces.AddTriangles(faceVertices);
faceVertices[0] = mesh.Vertices[hole[min].Index];
faceVertices[1] = mesh.Vertices[hole[0].Index];
faceVertices[2] = mesh.Vertices[mesh.Vertices.Count - 1];
mesh.Faces.AddTriangles(faceVertices);
}
else if (min == 0)
{
Vector3D midPosition;
midPosition = (hole[hole.Count - 1].Traits.Position + hole[min + 1].Traits.Position) / 2;
mesh.Vertices.Add(new VertexTraits(midPosition.x, midPosition.y, midPosition.z));
faceVertices[0] = mesh.Vertices[hole[min].Index];
faceVertices[1] = mesh.Vertices[mesh.Vertices.Count - 1];
faceVertices[2] = mesh.Vertices[hole[hole.Count - 1].Index];
mesh.Faces.AddTriangles(faceVertices);
faceVertices[0] = mesh.Vertices[hole[min].Index];
faceVertices[1] = mesh.Vertices[hole[min + 1].Index];
faceVertices[2] = mesh.Vertices[mesh.Vertices.Count - 1];
mesh.Faces.AddTriangles(faceVertices);
}
else
{
Vector3D midPosition;
midPosition = (hole[min - 1].Traits.Position + hole[min + 1].Traits.Position) / 2;
mesh.Vertices.Add(new VertexTraits(midPosition.x, midPosition.y, midPosition.z));
faceVertices[0] = mesh.Vertices[hole[min].Index];
faceVertices[1] = mesh.Vertices[mesh.Vertices.Count - 1];
faceVertices[2] = mesh.Vertices[hole[min - 1].Index];
mesh.Faces.AddTriangles(faceVertices);
faceVertices[0] = mesh.Vertices[hole[min].Index];
faceVertices[1] = mesh.Vertices[hole[min + 1].Index];
faceVertices[2] = mesh.Vertices[mesh.Vertices.Count - 1];
mesh.Faces.AddTriangles(faceVertices);
}
}
#endregion
//更新边界点，并判断空洞是否完整
#region 更新边界点，并判断空洞是否完整
TriMeshUtil.FixIndex(mesh);
hole = TriMeshUtil.RetrieveBoundarySingle(mesh);
if (hole.Count < 3)
break;
#endregion
}
}
public static Vector4D[] ComputeDCruv(TriMesh mesh, double[] CornerArea, double[] PointArea)
{
PrincipalCurvature[] PrincipalCurv = ComputePrincipleCurvatures(mesh, CornerArea, PointArea);
Vector4D[] dcurv = new Vector4D[mesh.Vertices.Count];
TriMesh.HalfEdge[] fh = new TriMesh.HalfEdge[3];
TriMesh.Vertex[] fv = new TriMesh.Vertex[3];
Vector3D[] e = new Vector3D[3];
Vector3D t, b, faceNormal;
// Compute curvature for each face
foreach (TriMesh.Face f in mesh.Faces)
{
// Get halfedges for this face
fh[0] = f.HalfEdge;
fh[1] = fh[0].Next;
fh[2] = fh[1].Next;
// Get vertices for this face
fv[0] = fh[0].ToVertex;
fv[1] = fh[1].ToVertex;
fv[2] = fh[2].ToVertex;
// Edge vectors
e[0] = fv[2].Traits.Position - fv[1].Traits.Position;
e[1] = fv[0].Traits.Position - fv[2].Traits.Position;
e[2] = fv[1].Traits.Position - fv[0].Traits.Position;
t = e[0];
t.Normalize();
faceNormal = e[0].Cross(e[1]);
b = faceNormal.Cross(t);
b.Normalize();
KUV[] fcurv = new KUV[3];
for (int i = 0; i < 3; i++)
{
PrincipalCurvature pc = PrincipalCurv[fv[i].Index];
UV src = new UV { U = pc.maxDir, V = pc.minDir };
KUV mk = new KUV { U = pc.max, UV = 0, V = pc.min };
UV tb = new UV { U = t, V = b };
fcurv[i] = Transform.ProjectCurvature(src, mk, tb);
}
double[] m = new double[4];
double[,] w = new double[4, 4];
for (int i = 0; i < 3; i++)
{
KUV prev = fcurv[(i + 2) % 3];
KUV next = fcurv[(i + 1) % 3];
KUV dfcurv = new KUV { U = prev.U - next.U, UV = prev.UV - next.UV, V = prev.V - next.V };
double u = e[i].Dot(t);
double v = e[i].Dot(b);
w[0, 0] += u * u;
w[0, 1] += u * v;
w[3, 3] += v * v;
m[0] += u * dfcurv.U;
m[1] += v * dfcurv.U + 2d * u * dfcurv.UV;
m[2] += 2d * v * dfcurv.UV + u * dfcurv.V;
m[3] += v * dfcurv.V;
}
w[1, 1] = 2d * w[0, 0] + w[3, 3];
w[1, 2] = 2d * w[0, 1];
w[2, 2] = w[0, 0] + 2d * w[3, 3];
w[2, 3] = w[0, 1];
double[] diag = new double[4];
if (Transform.LdlTransposeDecomp(w, diag))
{
Transform.LdlTransposeSolveInPlace(w, diag, m);
Vector4D d = new Vector4D(m);
// Adjust curvature for vertices of this face
for (int i = 0; i < 3; ++i)
{
UV tb = new UV { U = t, V = b };
PrincipalCurvature pc = PrincipalCurv[fv[i].Index];
UV dst = new UV { U = pc.maxDir, V = pc.minDir };
Vector4D c = Transform.ProjectDCurvature(tb, d, dst);
double weight = CornerArea[fh[i].Index] / PointArea[fv[i].Index];
dcurv[fv[i].Index] += weight * d;
}
}
}
return dcurv;
}
public TriMesh CreateMesh()
{
TriMesh mesh = new TriMesh();
mesh.Vertices.Add(new VertexTraits(this.A));
mesh.Vertices.Add(new VertexTraits(this.B));
mesh.Vertices.Add(new VertexTraits(this.C));
TriMesh.Vertex[] faceVertices = new TriMesh.Vertex[3];
faceVertices[0] = mesh.Vertices[0];
faceVertices[1] = mesh.Vertices[1];
faceVertices[2] = mesh.Vertices[2];
mesh.Faces.AddTriangles(faceVertices);
return mesh;
}
public static PrincipalCurvature[] ComputePrincipleCurvatures(TriMesh mesh, double[] CornerArea, double[] PointArea)
{
Vector3D[] vertexNormal = TriMeshUtil.ComputeNormalVertex(mesh);
// Add dynamic trait for principle curvature computation
double[] curv = new double[mesh.Vertices.Count];
PrincipalCurvature[] pc = new PrincipalCurvature[mesh.Vertices.Count];
// Initialize a coordinate system for each vertex
foreach (TriMesh.Vertex v in mesh.Vertices)
{
pc[v.Index] = new PrincipalCurvature();
// Vector that points from this vertex to an adjacent one
pc[v.Index].maxDir = (v.HalfEdge.ToVertex.Traits.Position - v.Traits.Position).Cross(vertexNormal[v.Index]).Normalize();
// Get a vector orthogonal to this vector and the vertex normal
pc[v.Index].minDir = vertexNormal[v.Index].Cross(pc[v.Index].maxDir);
}
TriMesh.HalfEdge[] fh = new TriMesh.HalfEdge[3];
TriMesh.Vertex[] fv = new TriMesh.Vertex[3];
Vector3D[] e = new Vector3D[3];
Vector3D t, b, dn, faceNormal;
// Compute curvature for each face
foreach (TriMesh.Face f in mesh.Faces)
{
// Get halfedges for this face
fh[0] = f.HalfEdge;
fh[1] = fh[0].Next;
fh[2] = fh[1].Next;
// Get vertices for this face
fv[0] = fh[0].ToVertex;
fv[1] = fh[1].ToVertex;
fv[2] = fh[2].ToVertex;
// Edge vectors
e[0] = fv[2].Traits.Position - fv[1].Traits.Position;
e[1] = fv[0].Traits.Position - fv[2].Traits.Position;
e[2] = fv[1].Traits.Position - fv[0].Traits.Position;
t = e[0];
t.Normalize();
faceNormal = e[0].Cross(e[1]);
faceNormal.Normalize();
b = faceNormal.Cross(t);
b.Normalize();
// Estimate curvature by variation of normals along edges
double[] m = new double[3];
double[,] w = new double[3, 3];
for (int i = 0; i < 3; ++i)
{
double u = e[i].Dot(t);
double v = e[i].Dot(b);
w[0, 0] += u * u;
w[0, 1] += u * v;
w[2, 2] += v * v;
dn = vertexNormal[fv[(i + 2) % 3].Index] - vertexNormal[fv[(i + 1) % 3].Index];
double dnu = dn.Dot(t);
double dnv = dn.Dot(b);
m[0] += dnu * u;
m[1] += dnu * v + dnv * u;
m[2] += dnv * v;
}
w[1, 1] = w[0, 0] + w[2, 2];
w[1, 2] = w[0, 1];
// Least squares solution
double[] diag = new double[3];
if (Transform.LdlTransposeDecomp(w, diag))
{
Transform.LdlTransposeSolveInPlace(w, diag, m);
// Adjust curvature for vertices of this face
for (int i = 0; i < 3; ++i)
{
UV tb = new UV { U = t, V = b };
KUV mk = new KUV { U = m[0], UV = m[1], V = m[2] };
UV dst = new UV { U = pc[fv[i].Index].maxDir, V = pc[fv[i].Index].minDir };
KUV c = Transform.ProjectCurvature(tb, mk, dst);
double weight = CornerArea[fh[i].Index] / PointArea[fv[i].Index];
pc[fv[i].Index].max += weight * c.U;
curv[fv[i].Index] += weight * c.UV;
pc[fv[i].Index].min += weight * c.V;
}
}
}
// Compute curvature for each vertex
foreach (TriMesh.Vertex v in mesh.Vertices)
{
UV src = new UV { U = pc[v.Index].maxDir, V = pc[v.Index].minDir };
KUV srcK = new KUV { U = pc[v.Index].max, UV = curv[v.Index], V = pc[v.Index].min };
pc[v.Index] = Transform.DiagonalizeCurvature(src, srcK, vertexNormal[v.Index]);
}
return pc;
}
public static TriMesh.Vertex VertexSplit(TriMesh.Vertex v1, TriMesh.Vertex share1,
TriMesh.Vertex share2, Vector3D v1Position, Vector3D v2Position, int fixedIndex)
{
TriMesh.HalfEdge[] hfs = FindGroup(v1, share1, share2);
TriMesh mesh = (TriMesh)v1.Mesh;
v1.Traits.Position = v1Position;
v1.HalfEdge = hfs[0];
TriMesh.Vertex v2 = new TriMesh.Vertex();
v2.Traits = new VertexTraits(v2Position);
v2.Traits.FixedIndex = fixedIndex;
v2.HalfEdge = hfs[1];
mesh.AppendToVertexList(v2);
for (int i = 0; i < hfs.Length - 1; i++)
{
hfs[i].Opposite.ToVertex = v2;
}
TriMesh.HalfEdge[] triangle1 = AddInnerTriangle(mesh, v1, v2, share1);
InsertEdge(mesh, triangle1[1], hfs[0]);
TriMesh.HalfEdge[] triangle2 = AddInnerTriangle(mesh, v2, v1, share2);
InsertEdge(mesh, triangle2[1], hfs[hfs.Length - 1]);
TriMesh.Edge edge = new TriMesh.Edge();
edge.HalfEdge0 = triangle1[0];
triangle1[0].Edge = edge;
triangle2[0].Edge = edge;
triangle1[0].Opposite = triangle2[0];
triangle2[0].Opposite = triangle1[0];
mesh.AppendToEdgeList(edge);
return v2;
}
private static void BulidSphereFace(int v1, int v2, int v3,TriMesh mesh)//添加面
{
TriMesh.Vertex[] faceVertices = new TriMesh.Vertex[3];
faceVertices[0] = mesh.Vertices[v1];
faceVertices[1] = mesh.Vertices[v2];
faceVertices[2] = mesh.Vertices[v3];
TriMesh.Face[] addedFaces = mesh.Faces.AddTriangles(faceVertices);
}
/// <summary>
/// Computes principle curvatures on the vertices.
/// </summary>
/// <param name="cornerArea">A halfedge dynamic trait with face vertex angular areas.</param>
/// <param name="pointArea">A vertex dynamic trait with vertex angular areas.</param>
/// <remarks>
/// Portions of this method are based on code from the C++ trimesh2 library
/// (from TriMesh_curvature.cc).
/// </remarks>
public void ComputePrincipleCurvatures(TriMesh mesh,TriMesh.HalfedgeDynamicTrait<float> cornerArea, TriMesh.VertexDynamicTrait<float> pointArea)
{
// Add dynamic trait for principle curvature computation
TriMesh.VertexDynamicTrait<float> curv = new TriMesh.VertexDynamicTrait<float>(mesh);
// Initialize principle curvatures to zero
foreach (TriMesh.Vertex v in mesh.Vertices)
{
v.Traits.MaxCurvature = 0.0f;
v.Traits.MinCurvature = 0.0f;
}
// Initialize a coordinate system for each vertex
foreach (TriMesh.Vertex v in mesh.Vertices)
{
if (Math.Sqrt(v.Traits.Normal.Length()) > 0.0f) // Ignore isolated points
{
// Vector that points from this vertex to an adjacent one
v.Traits.MaxCurvatureDirection = v.HalfEdge.ToVertex.Traits.Position - v.Traits.Position;
v.Traits.MaxCurvatureDirection.Normalize();
// Get a vector orthogonal to this vector and the vertex normal
v.Traits.MinCurvatureDirection = v.Traits.Normal.Cross(v.Traits.MaxCurvatureDirection);
}
}
TriMesh.HalfEdge[] fh = new TriMesh.HalfEdge[3];
TriMesh.Vertex[] fv = new TriMesh.Vertex[3];
Vector3D[] e = new Vector3D[3];
Vector3D t, b, dn, faceNormal;
// Compute curvature for each face
foreach (TriMesh.Face f in mesh.Faces)
{
// Get halfedges for this face
fh[0] = f.HalfEdge;
fh[1] = fh[0].Next;
fh[2] = fh[1].Next;
// Get vertices for this face
fv[0] = fh[0].ToVertex;
fv[1] = fh[1].ToVertex;
fv[2] = fh[2].ToVertex;
// Edge vectors
e[0] = fv[2].Traits.Position - fv[1].Traits.Position;
e[1] = fv[0].Traits.Position - fv[2].Traits.Position;
e[2] = fv[1].Traits.Position - fv[0].Traits.Position;
t = e[0];
t.Normalize();
faceNormal = e[0].Cross(e[1]);
faceNormal.Normalize();
b = faceNormal.Cross(t);
b.Normalize();
// Estimate curvature by variation of normals along edges
float[] m = new float[3];
float[,] w = new float[3, 3];
for (int i = 0; i < 3; ++i)
{
float u = (float)e[i].Dot(t);
float v = (float)e[i].Dot(b);
w[0, 0] += u * u;
w[0, 1] += u * v;
w[2, 2] += v * v;
dn = fv[(i + 2) % 3].Traits.Normal - fv[(i + 1) % 3].Traits.Normal;
float dnu = (float)dn.Dot(t);
float dnv = (float)dn.Dot(b);
m[0] += dnu * u;
m[1] += dnu * v + dnv * u;
m[2] += dnv * v;
}
w[1, 1] = w[0, 0] + w[2, 2];
w[1, 2] = w[0, 1];
// Least squares solution
float[] diag = new float[3];
if (Curvature.LdlTransposeDecomp(w, diag))
{
Curvature.LdlTransposeSolveInPlace(w, diag, m);
// Adjust curvature for vertices of this face
for (int i = 0; i < 3; ++i)
{
float c1, c12, c2;
Curvature.ProjectCurvature(t, b, m[0], m[1], m[2], fv[i].Traits.MaxCurvatureDirection, fv[i].Traits.MinCurvatureDirection, out c1, out c12, out c2);
float weight = cornerArea[fh[i]] / pointArea[fv[i]];
fv[i].Traits.MaxCurvature += weight * c1;
curv[fv[i]] += weight * c12;
fv[i].Traits.MinCurvature += weight * c2;
}
}
}
// Compute curvature for each vertex
foreach (TriMesh.Vertex v in mesh.Vertices)
{
if (Math.Sqrt(v.Traits.Normal.Length()) > 0.0f) // Ignore isolated points
{
Curvature.DiagonalizeCurvature(v.Traits.MaxCurvatureDirection, v.Traits.MinCurvatureDirection, v.Traits.MaxCurvature, curv[v], v.Traits.MinCurvature, v.Traits.Normal,
out v.Traits.MaxCurvatureDirection, out v.Traits.MinCurvatureDirection, out v.Traits.MaxCurvature, out v.Traits.MinCurvature);
}
}
}
public static TriMesh CreateSquare()
{
double length = 0.5;
double width = 0.3;
TriMesh Shape = new TriMesh();
Shape.Vertices.Add(new VertexTraits(-width, -length, 0));
Shape.Vertices.Add(new VertexTraits(width, -length, 0));
Shape.Vertices.Add(new VertexTraits(-width, length, 0));
Shape.Vertices.Add(new VertexTraits(width, length, 0));
TriMesh.Vertex[] faceVertices = new TriMesh.Vertex[3];
faceVertices[0] = Shape.Vertices[0];
faceVertices[1] = Shape.Vertices[1];
faceVertices[2] = Shape.Vertices[2];
CreateFace(Shape,faceVertices);
faceVertices = new TriMesh.Vertex[3];
faceVertices[0] = Shape.Vertices[1];
faceVertices[1] = Shape.Vertices[3];
faceVertices[2] = Shape.Vertices[2];
CreateFace(Shape, faceVertices);
faceVertices = new TriMesh.Vertex[3];
faceVertices[0] = Shape.Vertices[2];
faceVertices[1] = Shape.Vertices[3];
faceVertices[2] = Shape.Vertices[0];
CreateFace(Shape, faceVertices);
faceVertices = new TriMesh.Vertex[3];
faceVertices[0] = Shape.Vertices[3];
faceVertices[1] = Shape.Vertices[1];
faceVertices[2] = Shape.Vertices[0];
CreateFace(Shape, faceVertices);
return Shape;
}