public static void MoveToCenter(QuadMesh mesh)
{
Vector3D max = new Vector3D(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity);
Vector3D min = new Vector3D(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity);
foreach (QuadMesh.Vertex v in mesh.Vertices)
{
for (int i = 0; i < 3; ++i)
{
if (v.Traits.Position[i] > max[i])
{
max[i] = v.Traits.Position[i];
}
if (v.Traits.Position[i] < min[i])
{
min[i] = v.Traits.Position[i];
}
}
}
Vector3D center = (max + min) / 2.0;
foreach (QuadMesh.Vertex v in mesh.Vertices)
{
v.Traits.Position -= center;
}
}
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 double ComputeVolume(QuadMesh mesh)
{
int n = mesh.Faces.Count;
double volume = 0;
for (int i = 0; i < n; i++)
{
Vector3D vertexA = mesh.Faces[i].GetVertex(0).Traits.Position;
Vector3D vertexB = mesh.Faces[i].GetVertex(1).Traits.Position;
Vector3D vertexC = mesh.Faces[i].GetVertex(2).Traits.Position;
Vector3D vertexD = mesh.Faces[i].GetVertex(3).Traits.Position;
double v123 = vertexA.x * vertexB.y * vertexC.z;
double v231 = vertexA.y * vertexB.z * vertexC.x;
double v312 = vertexA.z * vertexB.x * vertexC.y;
double v132 = vertexA.x * vertexB.z * vertexC.y;
double v213 = vertexA.y * vertexB.x * vertexC.z;
double v321 = vertexA.z * vertexB.y * vertexC.x;
volume += (v123 + v231 + v312 - v132 - v213 - v321) / 6;
double d123 = vertexC.x * vertexD.y * vertexA.z;
double d231 = vertexC.y * vertexD.z * vertexA.x;
double d312 = vertexC.z * vertexD.x * vertexA.y;
double d132 = vertexC.x * vertexD.z * vertexA.y;
double d213 = vertexC.y * vertexD.x * vertexA.z;
double d321 = vertexC.z * vertexD.y * vertexA.x;
volume += (d123 + d231 + d312 - d132 - d213 - d321) / 6;
}
return(volume);
}
public void DrawSmoothShaded(QuadMesh mesh)
{
GL.Enable(EnableCap.PolygonOffsetFill);
GL.ShadeModel(ShadingModel.Smooth);
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
GL.Enable(EnableCap.Normalize);
Color c = GlobalSetting.DisplaySetting.MeshColor;
GL.Color3(c);
GL.Begin(BeginMode.Quads);
for (int i = 0; i < mesh.Faces.Count; i++)
{
foreach (QuadMesh.Vertex vertex in mesh.Faces[i].Vertices)
{
GL.Normal3(vertex.Traits.Normal.x, vertex.Traits.Normal.y, vertex.Traits.Normal.z);
GL.Vertex3(vertex.Traits.Position.x, vertex.Traits.Position.y, vertex.Traits.Position.z);
}
}
GL.End();
GL.Flush();
}
public void DrawFlatShaded(QuadMesh mesh)
{
GL.ShadeModel(ShadingModel.Flat);
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
GL.Enable(EnableCap.Normalize);
Color c = GlobalSetting.DisplaySetting.MeshColor;
GL.Color3(c);
GL.Begin(BeginMode.Triangles);
for (int i = 0; i < mesh.Faces.Count; i++)
{
foreach (QuadMesh.Vertex vertex in mesh.Faces[i].Vertices)
{
GL.Normal3(vertex.Traits.Normal.x, vertex.Traits.Normal.y, vertex.Traits.Normal.z);
GL.Vertex3(vertex.Traits.Position.x, vertex.Traits.Position.y, vertex.Traits.Position.z);
}
}
GL.End();
GL.Flush();
}
public static QuadMesh FromOffStream(Stream stream)
{
QuadMesh m = new QuadMesh();
m.LoadOffStream(stream);
return(m);
}
public QuadMesh CreatePlane(int column, int row)
{
QuadMesh shape = new QuadMesh();
for (int i = 0; i < row; i++)
{
for (int j = 0; j < column; j++)
{
shape.Vertices.Add(new VertexTraits((double)i / (double)row, (double)j / (double)column, 0));
}
}
QuadMesh.Vertex[] faceVertices = new QuadMesh.Vertex[4];
for (int i = 0; i < row - 1; i++)
{
for (int j = 0; j < column - 1; j++)
{
faceVertices[0] = shape.Vertices[i * column + j];
faceVertices[1] = shape.Vertices[i * column + j + 1];
faceVertices[2] = shape.Vertices[(i + 1) * column + j + 1];
faceVertices[3] = shape.Vertices[(i + 1) * column + j];
shape.Faces.AddQuads(faceVertices);
}
}
return(shape);
}
public void DrawFlatHiddenLine(QuadMesh m)
{
GL.Enable(EnableCap.PolygonOffsetFill);
DrawFlatShaded(m);
DrawDarkWireframe(m);
GL.Disable(EnableCap.PolygonOffsetFill);
}
public void DrawCurves(QuadMesh m, List <List <int> > lines)
{
GL.Color3(0.0f, 1.0f, 0.0f);
GL.LineWidth(GlobalSetting.DisplaySetting.SelectionLineWidth);
for (int i = 0; i < lines.Count; i++)
{
GL.Begin(BeginMode.LineStrip);
switch (i % 6)
{
case 0: GL.Color3(0.0f, 0.0f, 1.0f); break;
case 1: GL.Color3(1.0f, 0.0f, 0.0f); break;
case 2: GL.Color3(0.0f, 1.0f, 0.0f); break;
case 3: GL.Color3(1.0f, 1.0f, 0.0f); break;
case 4: GL.Color3(0.0f, 1.0f, 1.0f); break;
case 5: GL.Color3(1.0f, 0.0f, 1.0f); break;
}
for (int j = 0; j < lines[i].Count; j++)
{
GL.Vertex3(m.Vertices[lines[i][j]].Traits.Position.x, m.Vertices[lines[i][j]].Traits.Position.y, m.Vertices[lines[i][j]].Traits.Position.z);
}
GL.End();
}
}
public void DrawSelectedVerticeBySphere(QuadMesh m)
{
for (int i = 0; i < m.Vertices.Count; i++)
{
if (m.Vertices[i].Traits.SelectedFlag == 0)
{
continue;
}
switch (m.Vertices[i].Traits.SelectedFlag % 6)
{
case 0: GL.Color3(0.0f, 0.0f, 1.0f); break;
case 1: GL.Color3(1.0f, 0.0f, 0.0f); break;
case 2: GL.Color3(0.0f, 1.0f, 0.0f); break;
case 3: GL.Color3(1.0f, 1.0f, 0.0f); break;
case 4: GL.Color3(0.0f, 1.0f, 1.0f); break;
case 5: GL.Color3(1.0f, 0.0f, 1.0f); break;
}
GL.PushMatrix();
GL.Translate(m.Vertices[i].Traits.Position.x, m.Vertices[i].Traits.Position.y, m.Vertices[i].Traits.Position.z);
GL.Scale(0.01, 0.01, 0.01);
OpenGLManager.Instance.DrawSphere();
GL.PopMatrix();
}
}
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 QuadMesh FromOffFile(string fileName)
{
QuadMesh m = new QuadMesh();
m.LoadOffFile(fileName);
return(m);
}
public void ComputeNormal(QuadMesh quadMesh)
{
foreach (QuadMesh.Face face in quadMesh.Faces)
{
QuadMesh.Vertex v0 = face.GetVertex(0);
QuadMesh.Vertex v1 = face.GetVertex(1);
QuadMesh.Vertex v2 = face.GetVertex(2);
QuadMesh.Vertex v3 = face.GetVertex(3);
Vector3D normal1 = (v2.Traits.Position - v1.Traits.Position).Cross(v0.Traits.Position - v2.Traits.Position);
normal1.Normalize();
Vector3D normal2 = (v0.Traits.Position - v3.Traits.Position).Cross(v2.Traits.Position - v0.Traits.Position);
normal2.Normalize();
face.Traits.Normal = (normal1 + normal2) / 2;
}
foreach (QuadMesh.Vertex vertex in quadMesh.Vertices)
{
vertex.Traits.Normal = Vector3D.Zero;
foreach (QuadMesh.Face face in vertex.Faces)
{
vertex.Traits.Normal += face.Traits.Normal;
}
vertex.Traits.Normal /= vertex.FaceCount;
}
}
public static void MoveToCenter(QuadMesh mesh)
{
Vector3D max = new Vector3D(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity);
Vector3D min = new Vector3D(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity);
foreach (QuadMesh.Vertex v in mesh.Vertices)
{
for (int i = 0; i < 3; ++i)
{
if (v.Traits.Position[i] > max[i])
{
max[i] = v.Traits.Position[i];
}
if (v.Traits.Position[i] < min[i])
{
min[i] = v.Traits.Position[i];
}
}
}
Vector3D center = (max + min) / 2.0;
foreach (QuadMesh.Vertex v in mesh.Vertices)
{
v.Traits.Position -= center;
}
}
public void DrawSmoothHiddenLine(QuadMesh m)
{
GL.Enable(EnableCap.PolygonOffsetFill);
DrawSmoothShaded(m);
DrawWireFrame(m);
GL.Disable(EnableCap.PolygonOffsetFill);
}
public void DrawPoints(QuadMesh m)
{
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Point);
GL.PointSize(GlobalSetting.DisplaySetting.PointSize);
Color c = GlobalSetting.DisplaySetting.MeshColor;
DrawQuads(m);
}
public QuadMesh DooSabin()
{
QuadMesh subdivisionedMesh = ChangeTopologyDooSabin(Mesh);
ChangeGeometryDooSabin(Mesh, subdivisionedMesh);
return(subdivisionedMesh);
}
private QuadMesh ChangeTopologyDooSabin(QuadMesh sourceMesh)
{
QuadMesh newMesh = new QuadMesh();
return(newMesh);
}
public QuadMesh CatMullClark()
{
QuadMesh subdivisionedMesh = ChangeTopologyCatMullClark(Mesh);
ChangeGeometryCatMullClark(Mesh, subdivisionedMesh);
return(subdivisionedMesh);
}
private void cubeToolStripMenuItem_Click(object sender, EventArgs e)
{
QuadMesh mesh = QuadShape.Instance.CreateCube();
QuadMeshUtil.ScaleToUnit(mesh, 1.0);
QuadMeshUtil.MoveToCenter(mesh);
QuadMeshUtil.ComputeNormal(mesh);
GlobalData.Instance.QuadMesh = mesh;
}
public void DrawDarkWireframe(QuadMesh mesh)
{
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
GL.Disable(EnableCap.CullFace);
GL.Color3(0.0f, 0.0f, 0.0f);
GL.LineWidth(GlobalSetting.DisplaySetting.LineWidth);
DrawQuads(mesh);
GL.Enable(EnableCap.CullFace);
}
private void ChangeGeometryCatMullClark(QuadMesh sourceMesh, QuadMesh targetMesh)
{
for (int i = 0; i < sourceMesh.Vertices.Count; i++)
{
Vector3D position = new Vector3D(0, 0, 0);
if (sourceMesh.Vertices[i].OnBoundary)
{
int n = 0;
foreach (QuadMesh.Vertex neighbor in sourceMesh.Vertices[i].Vertices)
{
if (neighbor.OnBoundary)
{
position += neighbor.Traits.Position;
n++;
}
}
targetMesh.Vertices[i].Traits.Position =
sourceMesh.Vertices[i].Traits.Position * 3 / 4
+ position * 1 / (4 * n);
}
else
{
foreach (QuadMesh.Vertex neighbor in sourceMesh.Vertices[i].Vertices)
{
position += neighbor.Traits.Position;
}
int n = Mesh.Vertices[i].VertexCount;
double beta = LoopComputeBeta(n);
targetMesh.Vertices[i].Traits.Position =
(1 - n * beta) *
Mesh.Vertices[i].Traits.Position +
beta * position;
}
}
//update new added vertex position
for (int i = 0; i < sourceMesh.Edges.Count; i++)
{
Vector3D position = new Vector3D(0, 0, 0);
QuadMesh.Vertex vertex0 = sourceMesh.Edges[i].Vertex0;
QuadMesh.Vertex vertex1 = sourceMesh.Edges[i].Vertex1;
if (sourceMesh.Edges[i].OnBoundary)
{
position = (vertex0.Traits.Position + vertex1.Traits.Position) / 2;
}
else
{
QuadMesh.Vertex vertex2 = sourceMesh.Edges[i].HalfEdge0.Next.ToVertex;
QuadMesh.Vertex vertex3 = sourceMesh.Edges[i].HalfEdge1.Next.ToVertex;
position = (vertex0.Traits.Position + vertex1.Traits.Position) * 3 / 8 +
(vertex2.Traits.Position + vertex3.Traits.Position) * 1 / 8;
}
targetMesh.Vertices[sourceMesh.Vertices.Count + i].Traits.Position = position;
}
}
private void DrawQuads(QuadMesh mesh)
{
GL.Begin(BeginMode.Quads);
for (int i = 0; i < mesh.Faces.Count; i++)
{
foreach (QuadMesh.Vertex vertex in mesh.Faces[i].Vertices)
{
GL.Normal3(vertex.Traits.Normal.x, vertex.Traits.Normal.y, vertex.Traits.Normal.z);
GL.Vertex3(vertex.Traits.Position.x, vertex.Traits.Position.y, vertex.Traits.Position.z);
}
}
GL.End();
}
public void DrawHalfEdgeQuadMesh(QuadMesh mesh)
{
switch (GlobalSetting.DisplaySetting.DisplayMode)
{
case EnumDisplayMode.Vertex:
DrawPoints(mesh);
break;
case EnumDisplayMode.WireFrame:
DrawWireFrame(mesh);
break;
case EnumDisplayMode.Flat:
DrawFlatShaded(mesh);
break;
case EnumDisplayMode.FlatLine:
DrawFlatHiddenLine(mesh);
break;
case EnumDisplayMode.Smooth:
DrawSmoothShaded(mesh);
break;
case EnumDisplayMode.SmoothLine:
DrawSmoothHiddenLine(mesh);
break;
case EnumDisplayMode.SelectedVertex:
DrawSmoothShaded(mesh);
DrawSelectedVerticeBySphere(mesh);
break;
case EnumDisplayMode.SelectedFace:
DrawSmoothShaded(mesh);
DrawSelectedFace(mesh);
break;
case EnumDisplayMode.SelectedEdge:
DrawSmoothShaded(mesh);
DrawSelectedEdges(mesh);
break;
case EnumDisplayMode.Basic:
DrawBasic(mesh);
break;
}
}
public void DrawHalfEdgeQuadMesh(QuadMesh mesh)
{
switch (GlobalSetting.DisplaySetting.DisplayMode)
{
case EnumDisplayMode.Vertex:
DrawPoints(mesh);
break;
case EnumDisplayMode.WireFrame:
DrawWireFrame(mesh);
break;
case EnumDisplayMode.Flat:
DrawFlatShaded(mesh);
break;
case EnumDisplayMode.FlatLine:
DrawFlatHiddenLine(mesh);
break;
case EnumDisplayMode.Smooth:
DrawSmoothShaded(mesh);
break;
case EnumDisplayMode.SmoothLine:
DrawSmoothHiddenLine(mesh);
break;
case EnumDisplayMode.SelectedVertex:
DrawSmoothShaded(mesh);
DrawSelectedVerticeBySphere(mesh);
break;
case EnumDisplayMode.SelectedFace:
DrawSmoothShaded(mesh);
DrawSelectedFace(mesh);
break;
case EnumDisplayMode.SelectedEdge:
DrawSmoothShaded(mesh);
DrawSelectedEdges(mesh);
break;
case EnumDisplayMode.Basic:
DrawBasic(mesh);
break;
}
}
public static double ComputeArea(QuadMesh mesh)
{
double area = 0;
foreach (QuadMesh.Face face in mesh.Faces)
{
Vector3D v0 = face.GetVertex(0).Traits.Position;
Vector3D v1 = face.GetVertex(1).Traits.Position;
Vector3D v2 = face.GetVertex(2).Traits.Position;
Vector3D v3 = face.GetVertex(3).Traits.Position;
area += ((v1 - v0).Cross(v2 - v0)).Length() / 2.0;
area += ((v0 - v2).Cross(v3 - v2)).Length() / 2.0;
}
return(area);
}
public void DrawWireFrame(QuadMesh mesh)
{
GL.ShadeModel(ShadingModel.Smooth);
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
GL.Enable(EnableCap.Normalize);
Color c = GlobalSetting.DisplaySetting.WifeFrameColor;
GL.Color3(c);
DrawQuads(mesh);
GL.Flush();
}
public void DrawSelectedEdges(QuadMesh m)
{
GL.Color3(1.0f, 0.0f, 0.0f);
GL.LineWidth(GlobalSetting.DisplaySetting.SelectionLineWidth);
GL.Begin(BeginMode.Lines);
for (int i = 0; i < m.Edges.Count; i++)
{
if (m.Edges[i].Traits.SelectedFlag != 0)
{
GL.Normal3(m.Edges[i].Vertex0.Traits.Normal.x, m.Edges[i].Vertex0.Traits.Normal.y, m.Edges[i].Vertex0.Traits.Normal.z);
GL.Vertex3(m.Edges[i].Vertex0.Traits.Position.x, m.Edges[i].Vertex0.Traits.Position.y, m.Edges[i].Vertex0.Traits.Position.z);
GL.Normal3(m.Edges[i].Vertex1.Traits.Normal.x, m.Edges[i].Vertex1.Traits.Normal.y, m.Edges[i].Vertex1.Traits.Normal.z);
GL.Vertex3(m.Edges[i].Vertex1.Traits.Position.x, m.Edges[i].Vertex1.Traits.Position.y, m.Edges[i].Vertex1.Traits.Position.z);
}
}
GL.End();
}
public void OpenQuadMesh()
{
String filename = SetUpOpenDialog();
if (filename == null)
{
return;
}
else
{
QuadMesh mesh = QuadMesh.FromOffFile(filename);
QuadMeshUtil.ScaleToUnit(mesh, 1.0);
QuadMeshUtil.MoveToCenter(mesh);
QuadMeshUtil.ComputeNormal(mesh);
GlobalData.Instance.QuadMesh = mesh;
}
}
public void DrawSelectedFace(QuadMesh m)
{
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
GL.Color3(1.0f, 0.0f, 0.0f);
GL.LineWidth(GlobalSetting.DisplaySetting.SelectionLineWidth);
GL.Begin(BeginMode.Triangles);
for (int i = 0; i < m.Faces.Count; i++)
{
if (m.Faces[i].Traits.SelectedFlag != 0)
{
foreach (QuadMesh.Vertex vertex in m.Faces[i].Vertices)
{
GL.Normal3(vertex.Traits.Normal.x, vertex.Traits.Normal.y, vertex.Traits.Normal.z);
GL.Vertex3(vertex.Traits.Position.x, vertex.Traits.Position.y, vertex.Traits.Position.z);
}
}
}
GL.End();
}
public static void ScaleToUnit(QuadMesh mesh,double scale)
{
Vector3D max = new Vector3D(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity);
Vector3D min = new Vector3D(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity);
foreach (QuadMesh.Vertex v in mesh.Vertices)
{
for (int i = 0; i < 3; ++i)
{
if (v.Traits.Position[i] > max[i])
{
max[i] = v.Traits.Position[i];
}
if (v.Traits.Position[i] < min[i])
{
min[i] = v.Traits.Position[i];
}
}
}
Vector3D d = max - min;
double s = (d.x > d.y) ? d.x : d.y;
s = (s > d.z) ? s : d.z;
if (s <= 0) return;
foreach (QuadMesh.Vertex v in mesh.Vertices)
{
v.Traits.Position /= s;
v.Traits.Position *= scale;
}
}
public static void ScaleToUnit(QuadMesh mesh, double scale)
{
Vector3D max = new Vector3D(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity);
Vector3D min = new Vector3D(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity);
foreach (QuadMesh.Vertex v in mesh.Vertices)
{
for (int i = 0; i < 3; ++i)
{
if (v.Traits.Position[i] > max[i])
{
max[i] = v.Traits.Position[i];
}
if (v.Traits.Position[i] < min[i])
{
min[i] = v.Traits.Position[i];
}
}
}
Vector3D d = max - min;
double s = (d.x > d.y) ? d.x : d.y;
s = (s > d.z) ? s : d.z;
if (s <= 0)
{
return;
}
foreach (QuadMesh.Vertex v in mesh.Vertices)
{
v.Traits.Position /= s;
v.Traits.Position *= scale;
}
}
public void DrawBasic(QuadMesh mesh)
{
GL.Enable(EnableCap.PolygonOffsetFill);
GL.PolygonOffset(1f, 1f);
GL.ShadeModel(ShadingModel.Smooth);
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
GL.Enable(EnableCap.Normalize);
//OpenGLManager.Instance.SetMeshColor(GlobalSetting.DisplaySetting.MeshColor);
OpenGLManager.Instance.SetMaterialInfo();
foreach (var face in mesh.Faces)
{
GL.Begin(BeginMode.Polygon);
foreach (var v in face.Vertices)
{
GL.Normal3(v.Traits.Normal.ToArray());
GL.Vertex3(v.Traits.Position.ToArray());
}
GL.End();
}
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
GL.LineWidth(GlobalSetting.DisplaySetting.LineWidth);
GL.Enable(EnableCap.CullFace);
OpenGLManager.Instance.SetColorMesh(GlobalSetting.DisplaySetting.WifeFrameColor);
foreach (var face in mesh.Faces)
{
GL.Begin(BeginMode.Polygon);
foreach (var v in face.Vertices)
{
GL.Normal3(v.Traits.Normal.ToArray());
GL.Vertex3(v.Traits.Position.ToArray());
}
GL.End();
}
GL.Flush();
}
private QuadMesh ChangeTopologyDooSabin(QuadMesh sourceMesh)
{
QuadMesh newMesh = new QuadMesh();
return newMesh;
}
private void ChangeGeometryCatMullClark(QuadMesh sourceMesh, QuadMesh targetMesh)
{
for (int i = 0; i < sourceMesh.Vertices.Count; i++)
{
Vector3D position = new Vector3D(0, 0, 0);
if (sourceMesh.Vertices[i].OnBoundary)
{
int n = 0;
foreach (QuadMesh.Vertex neighbor in sourceMesh.Vertices[i].Vertices)
{
if (neighbor.OnBoundary)
{
position += neighbor.Traits.Position;
n++;
}
}
targetMesh.Vertices[i].Traits.Position =
sourceMesh.Vertices[i].Traits.Position * 3 / 4
+ position * 1 / (4 * n);
}
else
{
foreach (QuadMesh.Vertex neighbor in sourceMesh.Vertices[i].Vertices)
{
position += neighbor.Traits.Position;
}
int n = Mesh.Vertices[i].VertexCount;
double beta = LoopComputeBeta(n);
targetMesh.Vertices[i].Traits.Position =
(1 - n * beta) *
Mesh.Vertices[i].Traits.Position +
beta * position;
}
}
//update new added vertex position
for (int i = 0; i < sourceMesh.Edges.Count; i++)
{
Vector3D position = new Vector3D(0, 0, 0);
QuadMesh.Vertex vertex0 = sourceMesh.Edges[i].Vertex0;
QuadMesh.Vertex vertex1 = sourceMesh.Edges[i].Vertex1;
if (sourceMesh.Edges[i].OnBoundary)
{
position = (vertex0.Traits.Position + vertex1.Traits.Position) / 2;
}
else
{
QuadMesh.Vertex vertex2 = sourceMesh.Edges[i].HalfEdge0.Next.ToVertex;
QuadMesh.Vertex vertex3 = sourceMesh.Edges[i].HalfEdge1.Next.ToVertex;
position = (vertex0.Traits.Position + vertex1.Traits.Position) * 3 / 8 +
(vertex2.Traits.Position + vertex3.Traits.Position) * 1 / 8;
}
targetMesh.Vertices[sourceMesh.Vertices.Count + i].Traits.Position = position;
}
}
public static QuadMesh FromOffFile(string fileName)
{
QuadMesh m = new QuadMesh();
m.LoadOffFile(fileName);
return m;
}
public SubdivisionQuad(QuadMesh Mesh)
{
this.Mesh = Mesh;
}
public static double ComputeArea(QuadMesh mesh)
{
double area = 0;
foreach (QuadMesh.Face face in mesh.Faces)
{
Vector3D v0 = face.GetVertex(0).Traits.Position;
Vector3D v1 = face.GetVertex(1).Traits.Position;
Vector3D v2 = face.GetVertex(2).Traits.Position;
Vector3D v3 = face.GetVertex(3).Traits.Position;
area += ((v1 - v0).Cross(v2 - v0)).Length() / 2.0;
area += ((v0 - v2).Cross(v3 - v2)).Length() / 2.0;
}
return area;
}
public QuadMesh CreatePlane(int column, int row)
{
QuadMesh shape = new QuadMesh();
for (int i = 0; i < row; i++)
{
for (int j = 0; j < column; j++)
{
shape.Vertices.Add(new VertexTraits((double)i / (double)row, (double)j / (double)column, 0));
}
}
QuadMesh.Vertex[] faceVertices = new QuadMesh.Vertex[4];
for (int i = 0; i < row - 1; i++)
{
for (int j = 0; j < column - 1; j++)
{
faceVertices[0] = shape.Vertices[i * column + j];
faceVertices[1] = shape.Vertices[i * column + j + 1];
faceVertices[2] = shape.Vertices[(i + 1) * column + j + 1];
faceVertices[3] = shape.Vertices[(i + 1) * column + j];
shape.Faces.AddQuads(faceVertices);
}
}
return shape;
}
public SubdivisionQuad(QuadMesh Mesh)
{
this.Mesh = Mesh;
}
public void DrawDarkWireframe(QuadMesh mesh)
{
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
GL.Disable(EnableCap.CullFace);
GL.Color3(0.0f, 0.0f, 0.0f);
GL.LineWidth(GlobalSetting.DisplaySetting.LineWidth);
DrawQuads(mesh);
GL.Enable(EnableCap.CullFace);
}
public void DrawSmoothHiddenLine(QuadMesh m)
{
GL.Enable(EnableCap.PolygonOffsetFill);
DrawSmoothShaded(m);
DrawWireFrame(m);
GL.Disable(EnableCap.PolygonOffsetFill);
}
public void DrawFlatHiddenLine(QuadMesh m)
{
GL.Enable(EnableCap.PolygonOffsetFill);
DrawFlatShaded(m);
DrawDarkWireframe(m);
GL.Disable(EnableCap.PolygonOffsetFill);
}
public void DrawPoints(QuadMesh m)
{
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Point);
GL.PointSize(GlobalSetting.DisplaySetting.PointSize);
Color c = GlobalSetting.DisplaySetting.MeshColor;
DrawQuads(m);
}
public void DrawCurves(QuadMesh m, List<List<int>> lines)
{
GL.Color3(0.0f, 1.0f, 0.0f);
GL.LineWidth(GlobalSetting.DisplaySetting.SelectionLineWidth);
for (int i = 0; i < lines.Count; i++)
{
GL.Begin(BeginMode.LineStrip);
switch (i % 6)
{
case 0: GL.Color3(0.0f, 0.0f, 1.0f); break;
case 1: GL.Color3(1.0f, 0.0f, 0.0f); break;
case 2: GL.Color3(0.0f, 1.0f, 0.0f); break;
case 3: GL.Color3(1.0f, 1.0f, 0.0f); break;
case 4: GL.Color3(0.0f, 1.0f, 1.0f); break;
case 5: GL.Color3(1.0f, 0.0f, 1.0f); break;
}
for (int j = 0; j < lines[i].Count; j++)
{
GL.Vertex3(m.Vertices[lines[i][j]].Traits.Position.x, m.Vertices[lines[i][j]].Traits.Position.y, m.Vertices[lines[i][j]].Traits.Position.z);
}
GL.End();
}
}
public void DrawSelectedEdges(QuadMesh m)
{
GL.Color3(1.0f, 0.0f, 0.0f);
GL.LineWidth(GlobalSetting.DisplaySetting.SelectionLineWidth);
GL.Begin(BeginMode.Lines);
for (int i = 0; i < m.Edges.Count; i++)
{
if (m.Edges[i].Traits.SelectedFlag != 0)
{
GL.Normal3(m.Edges[i].Vertex0.Traits.Normal.x, m.Edges[i].Vertex0.Traits.Normal.y, m.Edges[i].Vertex0.Traits.Normal.z);
GL.Vertex3(m.Edges[i].Vertex0.Traits.Position.x, m.Edges[i].Vertex0.Traits.Position.y, m.Edges[i].Vertex0.Traits.Position.z);
GL.Normal3(m.Edges[i].Vertex1.Traits.Normal.x, m.Edges[i].Vertex1.Traits.Normal.y, m.Edges[i].Vertex1.Traits.Normal.z);
GL.Vertex3(m.Edges[i].Vertex1.Traits.Position.x, m.Edges[i].Vertex1.Traits.Position.y, m.Edges[i].Vertex1.Traits.Position.z);
}
}
GL.End();
}
public void DrawSelectedFace(QuadMesh m)
{
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
GL.Color3(1.0f, 0.0f, 0.0f);
GL.LineWidth(GlobalSetting.DisplaySetting.SelectionLineWidth);
GL.Begin(BeginMode.Triangles);
for (int i = 0; i < m.Faces.Count; i++)
{
if (m.Faces[i].Traits.SelectedFlag != 0)
{
foreach (QuadMesh.Vertex vertex in m.Faces[i].Vertices)
{
GL.Normal3(vertex.Traits.Normal.x, vertex.Traits.Normal.y, vertex.Traits.Normal.z);
GL.Vertex3(vertex.Traits.Position.x, vertex.Traits.Position.y, vertex.Traits.Position.z);
}
}
}
GL.End();
}
private void ChangeGeometryDooSabin(QuadMesh sourceMesh, QuadMesh targetMesh)
{
}
private QuadMesh ChangeTopologyCatMullClark(QuadMesh sourceMesh)
{
QuadMesh newMesh = new QuadMesh();
//获得初始的点
for (int i = 0; i < sourceMesh.Vertices.Count; i++)
{
newMesh.Vertices.Add(new VertexTraits(sourceMesh.Vertices[i].Traits.Position.x, sourceMesh.Vertices[i].Traits.Position.y, sourceMesh.Vertices[i].Traits.Position.z));
}
//获得E点
Vector3D midPosition;
for (int i = 0; i < sourceMesh.Edges.Count; i++)
{
midPosition = (sourceMesh.Edges[i].Vertex0.Traits.Position +
sourceMesh.Edges[i].Vertex1.Traits.Position) / 2;
newMesh.Vertices.Add(new VertexTraits(midPosition.x, midPosition.y, midPosition.z));
}
//获得F点
foreach (QuadMesh.Face face in sourceMesh.Faces)
{
midPosition = (face.GetVertex(0).Traits.Position + face.GetVertex(1).Traits.Position + face.GetVertex(2).Traits.Position + face.GetVertex(3).Traits.Position) / 4;
newMesh.Vertices.Add(new VertexTraits(midPosition.x, midPosition.y, midPosition.z));
}
//构造面
foreach (QuadMesh.Face face in sourceMesh.Faces)
{
QuadMesh.Vertex vertex0 = newMesh.Vertices[face.GetVertex(3).Index];
QuadMesh.Vertex vertex1 = newMesh.Vertices[face.GetVertex(0).Index];
QuadMesh.Vertex vertex2 = newMesh.Vertices[face.GetVertex(1).Index];
QuadMesh.Vertex vertex3 = newMesh.Vertices[face.GetVertex(2).Index];
QuadMesh.Edge edge0 = face.GetVertex(0).FindEdgeTo(face.GetVertex(1));
QuadMesh.Edge edge1 = face.GetVertex(1).FindEdgeTo(face.GetVertex(2));
QuadMesh.Edge edge2 = face.GetVertex(2).FindEdgeTo(face.GetVertex(3));
QuadMesh.Edge edge3 = face.GetVertex(3).FindEdgeTo(face.GetVertex(0));
QuadMesh.Vertex midVertex0 = newMesh.Vertices[sourceMesh.Vertices.Count + edge0.Index];
QuadMesh.Vertex midVertex1 = newMesh.Vertices[sourceMesh.Vertices.Count + edge1.Index];
QuadMesh.Vertex midVertex2 = newMesh.Vertices[sourceMesh.Vertices.Count + edge2.Index];
QuadMesh.Vertex midVertex3 = newMesh.Vertices[sourceMesh.Vertices.Count + edge3.Index];
QuadMesh.Vertex FVertex = newMesh.Vertices[sourceMesh.Vertices.Count + sourceMesh.Edges.Count + face.Index];
QuadMesh.Vertex[] newFace = new QuadMesh.Vertex[4];
newFace[0] = vertex0;
newFace[1] = midVertex3;
newFace[2] = FVertex;
newFace[3] = midVertex2;
newMesh.Faces.AddQuads(newFace);
newFace[0] = midVertex2;
newFace[1] = FVertex;
newFace[2] = midVertex1;
newFace[3] = vertex3;
newMesh.Faces.AddQuads(newFace);
newFace[0] = midVertex3;
newFace[1] = vertex1;
newFace[2] = midVertex0;
newFace[3] = FVertex;
newMesh.Faces.AddQuads(newFace);
newFace[0] = FVertex;
newFace[1] = midVertex0;
newFace[2] = vertex2;
newFace[3] = midVertex1;
newMesh.Faces.AddQuads(newFace);
}
return newMesh;
}
public void DrawSelectedVerticeBySphere(QuadMesh m)
{
for (int i = 0; i < m.Vertices.Count; i++)
{
if (m.Vertices[i].Traits.SelectedFlag == 0) continue;
switch (m.Vertices[i].Traits.SelectedFlag % 6)
{
case 0: GL.Color3(0.0f, 0.0f, 1.0f); break;
case 1: GL.Color3(1.0f, 0.0f, 0.0f); break;
case 2: GL.Color3(0.0f, 1.0f, 0.0f); break;
case 3: GL.Color3(1.0f, 1.0f, 0.0f); break;
case 4: GL.Color3(0.0f, 1.0f, 1.0f); break;
case 5: GL.Color3(1.0f, 0.0f, 1.0f); break;
}
GL.PushMatrix();
GL.Translate(m.Vertices[i].Traits.Position.x, m.Vertices[i].Traits.Position.y, m.Vertices[i].Traits.Position.z);
GL.Scale(0.01, 0.01, 0.01);
OpenGLManager.Instance.DrawSphere();
GL.PopMatrix();
}
}
public void ComputeNormal(QuadMesh quadMesh)
{
foreach (QuadMesh.Face face in quadMesh.Faces)
{
QuadMesh.Vertex v0 = face.GetVertex(0);
QuadMesh.Vertex v1 = face.GetVertex(1);
QuadMesh.Vertex v2 = face.GetVertex(2);
QuadMesh.Vertex v3 = face.GetVertex(3);
Vector3D normal1 = (v2.Traits.Position - v1.Traits.Position).Cross(v0.Traits.Position - v2.Traits.Position);
normal1.Normalize();
Vector3D normal2 = (v0.Traits.Position - v3.Traits.Position).Cross(v2.Traits.Position - v0.Traits.Position);
normal2.Normalize();
face.Traits.Normal = (normal1 + normal2) / 2;
}
foreach (QuadMesh.Vertex vertex in quadMesh.Vertices)
{
vertex.Traits.Normal = Vector3D.Zero;
foreach (QuadMesh.Face face in vertex.Faces)
{
vertex.Traits.Normal += face.Traits.Normal;
}
vertex.Traits.Normal /= vertex.FaceCount;
}
}
private void DrawQuads(QuadMesh mesh)
{
GL.Begin(BeginMode.Quads);
for (int i = 0; i < mesh.Faces.Count; i++)
{
foreach (QuadMesh.Vertex vertex in mesh.Faces[i].Vertices)
{
GL.Normal3(vertex.Traits.Normal.x, vertex.Traits.Normal.y, vertex.Traits.Normal.z);
GL.Vertex3(vertex.Traits.Position.x, vertex.Traits.Position.y, vertex.Traits.Position.z);
}
}
GL.End();
}
public QuadMesh CreateCube()
{
QuadMesh shape = new QuadMesh();
shape.Vertices.Add(new VertexTraits(0, 0, 0));
shape.Vertices.Add(new VertexTraits(0, 0.5, 0));
shape.Vertices.Add(new VertexTraits(0.5, 0.5, 0));
shape.Vertices.Add(new VertexTraits(0.5, 0, 0));
shape.Vertices.Add(new VertexTraits(0, 0, 0.5));
shape.Vertices.Add(new VertexTraits(0, 0.5, 0.5));
shape.Vertices.Add(new VertexTraits(0.5, 0.5, 0.5));
shape.Vertices.Add(new VertexTraits(0.5, 0, 0.5));
QuadMesh.Vertex[] faceVertices = new QuadMesh.Vertex[4];
faceVertices[0] = shape.Vertices[0];
faceVertices[1] = shape.Vertices[1];
faceVertices[2] = shape.Vertices[2];
faceVertices[3] = shape.Vertices[3];
shape.Faces.AddQuads(faceVertices);
faceVertices[0] = shape.Vertices[5];
faceVertices[1] = shape.Vertices[4];
faceVertices[2] = shape.Vertices[7];
faceVertices[3] = shape.Vertices[6];
shape.Faces.AddQuads(faceVertices);
faceVertices[0] = shape.Vertices[1];
faceVertices[1] = shape.Vertices[0];
faceVertices[2] = shape.Vertices[4];
faceVertices[3] = shape.Vertices[5];
shape.Faces.AddQuads(faceVertices);
faceVertices[0] = shape.Vertices[2];
faceVertices[1] = shape.Vertices[1];
faceVertices[2] = shape.Vertices[5];
faceVertices[3] = shape.Vertices[6];
shape.Faces.AddQuads(faceVertices);
faceVertices[0] = shape.Vertices[3];
faceVertices[1] = shape.Vertices[2];
faceVertices[2] = shape.Vertices[6];
faceVertices[3] = shape.Vertices[7];
shape.Faces.AddQuads(faceVertices);
faceVertices[0] = shape.Vertices[0];
faceVertices[1] = shape.Vertices[3];
faceVertices[2] = shape.Vertices[7];
faceVertices[3] = shape.Vertices[4];
shape.Faces.AddQuads(faceVertices);
//shape.Vertices.Add(new VertexTraits(0.25, 0.25, 0));
//shape.Vertices.Add(new VertexTraits(0, 0.25, 0));
//shape.Vertices.Add(new VertexTraits(0.25, 0, 0));
//faceVertices[0] = shape.Vertices[0];
//faceVertices[1] = shape.Vertices[3];
//faceVertices[2] = shape.Vertices[7];
//faceVertices[3] = shape.Vertices[4];
//shape.Faces.AddQuads(faceVertices);
//ChangTopolopy(shape);
return shape;
}
public void DrawWireFrame(QuadMesh mesh)
{
GL.ShadeModel(ShadingModel.Smooth);
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
GL.Enable(EnableCap.Normalize);
Color c = GlobalSetting.DisplaySetting.WifeFrameColor;
GL.Color3(c);
DrawQuads(mesh);
GL.Flush();
}
public QuadMesh CreateCube()
{
QuadMesh shape = new QuadMesh();
shape.Vertices.Add(new VertexTraits(0, 0, 0));
shape.Vertices.Add(new VertexTraits(0, 0.5, 0));
shape.Vertices.Add(new VertexTraits(0.5, 0.5, 0));
shape.Vertices.Add(new VertexTraits(0.5, 0, 0));
shape.Vertices.Add(new VertexTraits(0, 0, 0.5));
shape.Vertices.Add(new VertexTraits(0, 0.5, 0.5));
shape.Vertices.Add(new VertexTraits(0.5, 0.5, 0.5));
shape.Vertices.Add(new VertexTraits(0.5, 0, 0.5));
QuadMesh.Vertex[] faceVertices = new QuadMesh.Vertex[4];
faceVertices[0] = shape.Vertices[0];
faceVertices[1] = shape.Vertices[1];
faceVertices[2] = shape.Vertices[2];
faceVertices[3] = shape.Vertices[3];
shape.Faces.AddQuads(faceVertices);
faceVertices[0] = shape.Vertices[5];
faceVertices[1] = shape.Vertices[4];
faceVertices[2] = shape.Vertices[7];
faceVertices[3] = shape.Vertices[6];
shape.Faces.AddQuads(faceVertices);
faceVertices[0] = shape.Vertices[1];
faceVertices[1] = shape.Vertices[0];
faceVertices[2] = shape.Vertices[4];
faceVertices[3] = shape.Vertices[5];
shape.Faces.AddQuads(faceVertices);
faceVertices[0] = shape.Vertices[2];
faceVertices[1] = shape.Vertices[1];
faceVertices[2] = shape.Vertices[5];
faceVertices[3] = shape.Vertices[6];
shape.Faces.AddQuads(faceVertices);
faceVertices[0] = shape.Vertices[3];
faceVertices[1] = shape.Vertices[2];
faceVertices[2] = shape.Vertices[6];
faceVertices[3] = shape.Vertices[7];
shape.Faces.AddQuads(faceVertices);
faceVertices[0] = shape.Vertices[0];
faceVertices[1] = shape.Vertices[3];
faceVertices[2] = shape.Vertices[7];
faceVertices[3] = shape.Vertices[4];
shape.Faces.AddQuads(faceVertices);
//shape.Vertices.Add(new VertexTraits(0.25, 0.25, 0));
//shape.Vertices.Add(new VertexTraits(0, 0.25, 0));
//shape.Vertices.Add(new VertexTraits(0.25, 0, 0));
//faceVertices[0] = shape.Vertices[0];
//faceVertices[1] = shape.Vertices[3];
//faceVertices[2] = shape.Vertices[7];
//faceVertices[3] = shape.Vertices[4];
//shape.Faces.AddQuads(faceVertices);
//ChangTopolopy(shape);
return(shape);
}
public static double ComputeVolume(QuadMesh mesh)
{
int n = mesh.Faces.Count;
double volume = 0;
for (int i = 0; i < n; i++)
{
Vector3D vertexA = mesh.Faces[i].GetVertex(0).Traits.Position;
Vector3D vertexB = mesh.Faces[i].GetVertex(1).Traits.Position;
Vector3D vertexC = mesh.Faces[i].GetVertex(2).Traits.Position;
Vector3D vertexD = mesh.Faces[i].GetVertex(3).Traits.Position;
double v123 = vertexA.x * vertexB.y * vertexC.z;
double v231 = vertexA.y * vertexB.z * vertexC.x;
double v312 = vertexA.z * vertexB.x * vertexC.y;
double v132 = vertexA.x * vertexB.z * vertexC.y;
double v213 = vertexA.y * vertexB.x * vertexC.z;
double v321 = vertexA.z * vertexB.y * vertexC.x;
volume += (v123 + v231 + v312 - v132 - v213 - v321) / 6;
double d123 = vertexC.x * vertexD.y * vertexA.z;
double d231 = vertexC.y * vertexD.z * vertexA.x;
double d312 = vertexC.z * vertexD.x * vertexA.y;
double d132 = vertexC.x * vertexD.z * vertexA.y;
double d213 = vertexC.y * vertexD.x * vertexA.z;
double d321 = vertexC.z * vertexD.y * vertexA.x;
volume += (d123 + d231 + d312 - d132 - d213 - d321) / 6;
}
return volume;
}
public void DrawBasic(QuadMesh mesh)
{
GL.Enable(EnableCap.PolygonOffsetFill);
GL.PolygonOffset(1f, 1f);
GL.ShadeModel(ShadingModel.Smooth);
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
GL.Enable(EnableCap.Normalize);
//OpenGLManager.Instance.SetMeshColor(GlobalSetting.DisplaySetting.MeshColor);
OpenGLManager.Instance.SetMaterialInfo();
foreach (var face in mesh.Faces)
{
GL.Begin(BeginMode.Polygon);
foreach (var v in face.Vertices)
{
GL.Normal3(v.Traits.Normal.ToArray());
GL.Vertex3(v.Traits.Position.ToArray());
}
GL.End();
}
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
GL.LineWidth(GlobalSetting.DisplaySetting.LineWidth);
GL.Enable(EnableCap.CullFace);
OpenGLManager.Instance.SetColorMesh(GlobalSetting.DisplaySetting.WifeFrameColor);
foreach (var face in mesh.Faces)
{
GL.Begin(BeginMode.Polygon);
foreach (var v in face.Vertices)
{
GL.Normal3(v.Traits.Normal.ToArray());
GL.Vertex3(v.Traits.Position.ToArray());
}
GL.End();
}
GL.Flush();
}
public static QuadMesh FromOffStream(Stream stream)
{
QuadMesh m = new QuadMesh();
m.LoadOffStream(stream);
return m;
}
