public Gauss(Mesh input_mesh)
{
mesh = input_mesh;
mesh.Compact();
mesh.UnifyNormals();
el = mesh.TopologyEdges;
vs = mesh.TopologyVertices;
ps = new List<VertexProperties>();
for (int i = 0; i < vs.Count; i++)
{
ps.Add(new VertexProperties
(mesh.Normals[vs.MeshVertexIndices(i)[0]]));
// outputs2.Add(new Vector3d());
}
}
public void colorMesh3Colors()
{
for (int i = 0; i < topvertex.Count; i++)
{
if (Kmed[i] < v1)
{
ind = topvertex.MeshVertexIndices(i);
vertexCol[ind[0]] = A;
}
else if (Kmed[i] < v2)
{
ind = topvertex.MeshVertexIndices(i);
vertexCol[ind[0]] = B;
}
else
{
ind = topvertex.MeshVertexIndices(i);
vertexCol[ind[0]] = C;
}
}
mesh.VertexColors.SetColors(vertexCol.ToArray());
}
public string Mesh2Topo(ref Mesh mesh, out Mesh mesh2, double length, double width, double mX, double mY, double maxX, double maxY)
{
//
//construct a single bitmap but the edge is not fit well.The Vt has not been tested yet.
//
Rhino.Geometry.Collections.MeshTopologyEdgeList el = mesh.TopologyEdges;
Rhino.Geometry.Collections.MeshTopologyVertexList vs = mesh.TopologyVertices;
string str = "";
List <int> firstLoop1;
str += FirstEdge(mesh, out firstLoop1);
double column = (double)vs.Count / (double)firstLoop1.Count;
int Column = (int)column;
if (column - Column != 0)
{
str += "Points Count error,Please confirm the topo to be quad style";
}
int[] energy = new int[vs.Count];
List <int> indexPt = new List <int>();
indexPt.AddRange(firstLoop1);
for (int i = 0; i < firstLoop1.Count; i++)
{
energy[firstLoop1[i]] = 1;
}
for (int i = 0; i < Column - 1; i++)
{
bool sign = true;
for (int j = 0; j < firstLoop1.Count; j++)
{
int[] index = vs.ConnectedTopologyVertices(firstLoop1[j]);
for (int k = 0; k < index.Length; k++)
{
energy[index[k]]++;
}
}
for (int j = 0; j < firstLoop1.Count; j++)
{
int[] index = vs.ConnectedTopologyVertices(firstLoop1[j]);
for (int k = 0; k < index.Length; k++)
{
if (energy[index[k]] == 1)
{
firstLoop1[j] = index[k]; sign = false; break;
}
}
}
if (sign)
{
str += " Loop false,Not quad topo Or To the end";
}
else
{
indexPt.AddRange(firstLoop1);
}
}
///*******
double MX = (double)Column - 1;
double MY = (double)firstLoop1.Count - 1;
List <Point3d> output1 = new List <Point3d>();
List <Point3d> output2 = new List <Point3d>();
int iCount = 0;
Color[] cl = new Color[mesh.Vertices.Count];
for (int i = 0; i < Column; i++)
{
for (int j = 0; j < firstLoop1.Count; j++)
{
output1.Add(vs[indexPt[iCount]]);
int indexV = vs.MeshVertexIndices(indexPt[iCount])[0];
cl[iCount] = mesh.VertexColors[indexV];
iCount++;
Point3d pt = new Point3d(length / MX * i, width / MY * (double)j, 0);
output2.Add(pt);
}
}
mesh2 = mc.MeshFromPoints(output2, firstLoop1.Count, Column);
mesh = mc.MeshFromPoints(output1, firstLoop1.Count, Column);
mesh2.Transform(Transform.Translation(mX, mY, 0));
mesh.VertexColors.Clear();
mesh.VertexColors.AppendColors(cl);
mesh2.VertexColors.Clear();
mesh2.VertexColors.AppendColors(cl);
iCount = 0;
//Print(mesh.TextureCoordinates.Count.ToString());//unit=100
for (double i = 0; i < Column; i++)
{
for (double j = 0; j < firstLoop1.Count; j++)
{
//not tested
mesh.TextureCoordinates.Add(new Point2f((Single)((i * length / MX + mX) / maxX),
(Single)(j * width / MY + mY) / maxY));
mesh2.TextureCoordinates.Add(new Point2f((Single)((i * length / MX + mX) / maxX),
(Single)(j * width / MY + mY) / maxY));
iCount++;
}
}
return(str);
}
/// 2Nurbs
///
public string Mesh2Topo(ref Mesh mesh, out Mesh mesh2, int edge, out IndexPair data)
{
Rhino.Geometry.Collections.MeshTopologyEdgeList el = mesh.TopologyEdges;
Rhino.Geometry.Collections.MeshTopologyVertexList vs = mesh.TopologyVertices;
string str = "";
List <int> firstLoop1;
str += FirstEdge(mesh, out firstLoop1);
double column = (double)vs.Count / (double)firstLoop1.Count;
int Column = (int)column;
if (column - Column != 0)
{
str += "Points Count error,Please confirm the topo to be quad style";
}
int[] energy = new int[vs.Count];
List <int> indexPt = new List <int>();
indexPt.AddRange(firstLoop1);
for (int i = 0; i < firstLoop1.Count; i++)
{
energy[firstLoop1[i]] = 1;
}
for (int i = 0; i < Column - 1; i++)
{
bool sign = true;
for (int j = 0; j < firstLoop1.Count; j++)
{
int[] index = vs.ConnectedTopologyVertices(firstLoop1[j]);
for (int k = 0; k < index.Length; k++)
{
energy[index[k]]++;
}
}
for (int j = 0; j < firstLoop1.Count; j++)
{
int[] index = vs.ConnectedTopologyVertices(firstLoop1[j]);
for (int k = 0; k < index.Length; k++)
{
if (energy[index[k]] == 1)
{
firstLoop1[j] = index[k]; sign = false; break;
}
}
}
if (sign)
{
str += " Loop false,Not quad topo Or To the end";
}
else
{
indexPt.AddRange(firstLoop1);
}
}
///
///*******
double MX = (double)Column - 1;
double MY = (double)firstLoop1.Count - 1;
List <Point3d> output1 = new List <Point3d>();
List <Point3d> output2 = new List <Point3d>();
int iCount = 0;
Color[] cl = new Color[mesh.Vertices.Count];
//edge
List <int> pl1 = new List <int>();
List <int> pl2 = new List <int>();
List <int> pl3 = new List <int>();
List <int> pl4 = new List <int>();
int edge1 = 0, edge2 = 0, edge3 = 0, edge4 = 0;
//////////
for (int i = 0; i < Column; i++)
{
for (int j = 0; j < firstLoop1.Count; j++)
{
if (i == 0)
{
pl1.Add(iCount);
}
if (i == column - 1)
{
pl3.Add(iCount);
}
if (j == 0)
{
pl2.Add(iCount);
}
if (j == firstLoop1.Count - 1)
{
pl4.Add(iCount);
}
if (i == 0 && j == 0)
{
edge1 = iCount;
}
if (i == 0 && j == firstLoop1.Count - 1)
{
edge2 = iCount;
}
if (i == column - 1 && j == firstLoop1.Count - 1)
{
edge3 = iCount;
}
if (i == column - 1 && j == 0)
{
edge4 = iCount;
}
output1.Add(vs[indexPt[iCount]]);
int indexV = vs.MeshVertexIndices(indexPt[iCount])[0];
cl[iCount] = mesh.VertexColors[indexV];
iCount++;
Point3d pt = new Point3d(edge * i, edge * j, 0);
output2.Add(pt);
}
}
mesh2 = mc.MeshFromPoints(output2, firstLoop1.Count, Column);
mesh = mc.MeshFromPoints(output1, firstLoop1.Count, Column);
mesh.VertexColors.Clear();
mesh.VertexColors.AppendColors(cl);
mesh2.VertexColors.Clear();
mesh2.VertexColors.AppendColors(cl);
///edge
List <Point3d> pts;
/////////////////////////////////////////////////////////
Color[] cl1 = new Color[pl1.Count * 2]; pts = new List <Point3d>();
for (int i = 0; i < pl1.Count; i++)
{
pts.Add(new Point3d(mesh2.Vertices[pl1[i]]));
pts.Add((Point3d)mesh2.Vertices[pl1[i]] + new Vector3d(-edge, 0, 0));
cl1[i * 2] = mesh2.VertexColors[pl1[i]]; cl1[i * 2 + 1] = mesh2.VertexColors[pl1[i]];
}
Mesh mesh3 = mc.MeshFromPoints(pts, 2, pl1.Count);
mesh3.VertexColors.AppendColors(cl1);
mesh2.Append(mesh3);
/////////////////////////////////////////////////////////
Color[] cl2 = new Color[pl2.Count * 2]; pts = new List <Point3d>();
for (int i = 0; i < pl2.Count; i++)
{
pts.Add(new Point3d(mesh2.Vertices[pl2[i]]));
pts.Add((Point3d)mesh2.Vertices[pl2[i]] + new Vector3d(0, -edge, 0));
cl2[i * 2] = mesh2.VertexColors[pl2[i]]; cl2[i * 2 + 1] = mesh2.VertexColors[pl2[i]];
}
mesh3 = mc.MeshFromPoints(pts, 2, pl2.Count);
mesh3.VertexColors.AppendColors(cl2);
mesh2.Append(mesh3);
/////////////////////////////////////////////////////////
Color[] cl3 = new Color[pl3.Count * 2]; pts = new List <Point3d>();
for (int i = 0; i < pl3.Count; i++)
{
pts.Add(new Point3d(mesh2.Vertices[pl3[i]]));
pts.Add((Point3d)mesh2.Vertices[pl3[i]] + new Vector3d(edge, 0, 0));
cl3[i * 2] = mesh2.VertexColors[pl3[i]]; cl3[i * 2 + 1] = mesh2.VertexColors[pl3[i]];
}
mesh3 = mc.MeshFromPoints(pts, 2, pl3.Count);
mesh3.VertexColors.AppendColors(cl3);
mesh2.Append(mesh3);
/////////////////////////////////////////////////////////
Color[] cl4 = new Color[pl4.Count * 2]; pts = new List <Point3d>();
for (int i = 0; i < pl4.Count; i++)
{
pts.Add(new Point3d(mesh2.Vertices[pl4[i]]));
pts.Add((Point3d)mesh2.Vertices[pl4[i]] + new Vector3d(0, edge, 0));
cl4[i * 2] = mesh2.VertexColors[pl4[i]]; cl4[i * 2 + 1] = mesh2.VertexColors[pl4[i]];
}
mesh3 = mc.MeshFromPoints(pts, 2, pl4.Count);
mesh3.VertexColors.AppendColors(cl4);
mesh2.Append(mesh3);
/////////////////////////////////////////////////////////
Point3d ept = (Point3d)mesh2.Vertices[edge1];
mesh3 = mc.MeshFromPoints(ept, ept + new Vector3d(-edge, 0, 0), ept + new Vector3d(-edge, -edge, 0), ept + new Vector3d(0, -edge, 0));
mesh3.VertexColors.Add(mesh2.VertexColors[edge1]);
mesh3.VertexColors.Add(mesh2.VertexColors[edge1]);
mesh3.VertexColors.Add(mesh2.VertexColors[edge1]);
mesh3.VertexColors.Add(mesh2.VertexColors[edge1]);
mesh2.Append(mesh3);
ept = (Point3d)mesh2.Vertices[edge2];
mesh3 = mc.MeshFromPoints(ept, ept + new Vector3d(-edge, 0, 0), ept + new Vector3d(-edge, edge, 0), ept + new Vector3d(0, edge, 0));
mesh3.VertexColors.Add(mesh2.VertexColors[edge2]);
mesh3.VertexColors.Add(mesh2.VertexColors[edge2]);
mesh3.VertexColors.Add(mesh2.VertexColors[edge2]);
mesh3.VertexColors.Add(mesh2.VertexColors[edge2]);
mesh2.Append(mesh3);
ept = (Point3d)mesh2.Vertices[edge3];
mesh3 = mc.MeshFromPoints(ept, ept + new Vector3d(edge, 0, 0), ept + new Vector3d(edge, edge, 0), ept + new Vector3d(0, edge, 0));
mesh3.VertexColors.Add(mesh2.VertexColors[edge3]);
mesh3.VertexColors.Add(mesh2.VertexColors[edge3]);
mesh3.VertexColors.Add(mesh2.VertexColors[edge3]);
mesh3.VertexColors.Add(mesh2.VertexColors[edge3]);
mesh2.Append(mesh3);
ept = (Point3d)mesh2.Vertices[edge4];
mesh3 = mc.MeshFromPoints(ept, ept + new Vector3d(edge, 0, 0), ept + new Vector3d(edge, -edge, 0), ept + new Vector3d(0, -edge, 0));
mesh3.VertexColors.Add(mesh2.VertexColors[edge4]);
mesh3.VertexColors.Add(mesh2.VertexColors[edge4]);
mesh3.VertexColors.Add(mesh2.VertexColors[edge4]);
mesh3.VertexColors.Add(mesh2.VertexColors[edge4]);
mesh2.Append(mesh3);
//////////////////////////////////////////////////////
for (double i = 1; i <= Column; i++)
{
for (double j = 1; j <= firstLoop1.Count; j++)
{
mesh.TextureCoordinates.Add(i / (Column + 1), j / (firstLoop1.Count + 1));
}
}
data = new IndexPair((Column + 1) * edge, (firstLoop1.Count + 1) * edge);
return(str);
}
private List <MeshSimplify_Point> preDivide(Mesh mesh)
{
Rhino.Geometry.Collections.MeshTopologyEdgeList el = mesh.TopologyEdges;
Rhino.Geometry.Collections.MeshTopologyVertexList vs = mesh.TopologyVertices;
List <MeshSimplify_Point> PointList = new List <MeshSimplify_Point>();
for (int i = 0; i < vs.Count; i++)
{
MeshSimplify_Point pt = new MeshSimplify_Point(vs[i]);
if (vs.MeshVertexIndices(i).Length > 0)
{
pt.N = mesh.Normals[vs.MeshVertexIndices(i)[0]];
}
else
{
pt.computeNormal(mesh);
}
PointList.Add(pt);
}
for (int i = 0; i < vs.Count; i++)
{
int[] index = vs.ConnectedTopologyVertices(i);
for (int j = 0; j < index.Length; j++)
{
PointList[i].refpoints.Add(PointList[index[j]]);
}
PointList[i].Sort();
}
/////////////////////////////////////////////////////
for (int i = 0; i < vs.Count; i++)
{
PointList[i].order = 0;
}
for (int i = 0; i < el.Count; i++)
{
if (el.GetConnectedFaces(i).Length == 1)
{
PointList[el.GetTopologyVertices(i).I].order = 5;
PointList[el.GetTopologyVertices(i).J].order = 5;
}
}
for (int i = 0; i < vs.Count; i++)
{
if (PointList[i].order == 5)
{
if (PointList[i].refpoints.Count != 3)
{
PointList[i].order = 4;
}
}
else
{
if (PointList[i].refpoints.Count != 4)
{
PointList[i].order = 4;
}
}
}
//////////////////////////////////////////////////////////
for (int k = 0; k < PointList.Count; k++)
{
bool sign = true;
for (int i = 0; i < PointList.Count; i++)
{
if (PointList[i].order == 4)
{
sign = false;
PointList[i].order++;
if (PointList[i].refpoints.Count == 4)
{
if (PointList[i].refpoints[0].order == 5 && PointList[i].refpoints[2].order != 5)
{
PointList[i].refpoints[2].order = 1;
}
if (PointList[i].refpoints[1].order == 5 && PointList[i].refpoints[3].order != 5)
{
PointList[i].refpoints[3].order = 1;
}
if (PointList[i].refpoints[2].order == 5 && PointList[i].refpoints[0].order != 5)
{
PointList[i].refpoints[0].order = 1;
}
if (PointList[i].refpoints[3].order == 5 && PointList[i].refpoints[1].order != 5)
{
PointList[i].refpoints[1].order = 1;
}
}
else
{
for (int j = 0; j < PointList[i].refpoints.Count; j++)
{
PointList[i].refpoints[j].order++;
}
}
}
}
for (int i = 0; i < PointList.Count; i++)
{
if (PointList[i].order > 0 && PointList[i].order < 4)
{
PointList[i].order = 4;
}
}
if (sign)
{
break;
}
}
return(PointList);
}