Пример #1
0
        public string FirstEdge(Mesh mesh, out List <int> firstLoop1)
        {
            Rhino.Geometry.Collections.MeshTopologyEdgeList   el = mesh.TopologyEdges;
            Rhino.Geometry.Collections.MeshTopologyVertexList vs = mesh.TopologyVertices;
            firstLoop1 = new List <int>();
            int firstPoint = -1;

            for (int i = 0; i < vs.Count; i++)
            {
                if (vs.ConnectedTopologyVertices(i).Length == 2)
                {
                    firstPoint = i; break;
                }
            }
            if (firstPoint == -1)
            {
                return("can not find a 2 degree Vertex,Please check the mesh boundary");
            }
            int SecondPoint = vs.ConnectedTopologyVertices(firstPoint)[0];
            int ThirdPoint  = vs.ConnectedTopologyVertices(firstPoint)[1];
            int firstPoint1 = firstPoint;

            firstLoop1.Add(firstPoint);



            if (vs.ConnectedTopologyVertices(ThirdPoint).Length == 2)
            {
                firstLoop1.Add(ThirdPoint);
            }
            else if (vs.ConnectedTopologyVertices(SecondPoint).Length == 2)
            {
                firstLoop1.Add(SecondPoint);
            }
            else
            {
                firstLoop1.Add(SecondPoint);
                for (int i = 0; i < vs.Count; i++)
                {
                    bool  stop  = false;
                    int[] index = vs.ConnectedTopologyVertices(SecondPoint);
                    for (int j = 0; j < index.Length; j++)
                    {
                        if (index[j] != firstPoint1)
                        {
                            if (vs.ConnectedTopologyVertices(index[j]).Length == 3)
                            {
                                firstPoint1 = SecondPoint;
                                SecondPoint = index[j];
                                firstLoop1.Add(SecondPoint);
                                break;
                            }//if
                            if (vs.ConnectedTopologyVertices(index[j]).Length == 2)
                            {
                                firstPoint1 = SecondPoint;
                                SecondPoint = index[j];
                                firstLoop1.Add(SecondPoint);
                                stop = true;
                                break;
                            }//if
                        }
                    }
                    if (stop)
                    {
                        break;
                    }
                }
            }
            return("Done");
        }
Пример #2
0
        public string Mesh2Mesh(Mesh mesh, out Mesh s, double uscale, double vscale)
        {
            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++)
                    {
                        //Print("j:" + j.ToString() + " k:" + k.ToString() + " energy: " + energy[index[k]].ToString());////////
                        energy[index[k]]++;
                    }
                }
                //Print("///");
                for (int j = 0; j < firstLoop1.Count; j++)
                {
                    int[] index = vs.ConnectedTopologyVertices(firstLoop1[j]);
                    for (int k = 0; k < index.Length; k++)
                    {
                        // Print("j:" + j.ToString() + " k:" + k.ToString() + " energy: " + energy[index[k]].ToString());////////
                        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);
                }
            }
            List <Point3d> output1 = new List <Point3d>();

            for (int i = 0; i < indexPt.Count; i++)
            {
                output1.Add(vs[indexPt[i]]);
            }

            //   s = NurbsSurface.CreateFromPoints(output1, Column, firstLoop1.Count, 3, 3);

            s = mc.MeshFromPoints(output1, firstLoop1.Count, Column, uscale, vscale);
            return(str);
        }
Пример #3
0
        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);
        }
Пример #4
0
        /// 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);
        }
Пример #5
0
        public Mesh Catmull_Clark(Mesh x)
        {
            Mesh           mesh = new Mesh();
            List <Point3d> pv   = new List <Point3d>();
            List <Point3d> pe   = new List <Point3d>();
            List <Point3d> pf   = new List <Point3d>();

            Rhino.Geometry.Collections.MeshTopologyVertexList vs = x.TopologyVertices;
            Rhino.Geometry.Collections.MeshTopologyEdgeList   el = x.TopologyEdges;
            for (int i = 0; i < x.Faces.Count; i++)
            {
                int[]   index = vs.IndicesFromFace(i);
                Point3d pf1   = new Point3d();
                for (int j = 0; j < index.Length; j++)
                {
                    pf1 += vs[index[j]];
                }
                pf1 /= index.Length;
                pf.Add(pf1);
            }
            for (int i = 0; i < el.Count; i++)
            {
                IndexPair pair  = el.GetTopologyVertices(i);
                Point3d   pe1   = vs[pair.I] + vs[pair.J];
                int[]     index = el.GetConnectedFaces(i);
                if (index.Length == 2)
                {
                    pe1 += pf[index[0]] + pf[index[1]];
                    pe1 /= 4.0;
                }
                else
                {
                    pe1 = pe1 / 2.0;
                }
                pe.Add(pe1);
            }
            for (int i = 0; i < vs.Count; i++)
            {
                int[]   index  = vs.ConnectedEdges(i);
                int[]   index2 = vs.ConnectedFaces(i);
                Point3d V      = vs[i];
                if (index.Length == index2.Length)
                {
                    Point3d R = new Point3d(), Q = new Point3d();
                    for (int j = 0; j < index.Length; j++)
                    {
                        IndexPair pair = el.GetTopologyVertices(index[j]);
                        Point3d   pe1  = (vs[pair.I] + vs[pair.J]) * 0.5f;
                        R += pe1;
                    }
                    R /= index.Length;
                    for (int j = 0; j < index2.Length; j++)
                    {
                        Q += pf[index2[j]];
                    }
                    Q /= index2.Length;

                    int n = vs.ConnectedTopologyVertices(i).Length;
                    V  = Q + (R * 2) + V * (n - 3);
                    V /= n;
                }
                else
                {
                    Point3d R = new Point3d();
                    for (int j = 0; j < index.Length; j++)
                    {
                        if (el.GetConnectedFaces(index[j]).Length == 1)
                        {
                            IndexPair pair = el.GetTopologyVertices(index[j]);
                            R += vs[pair.I] + vs[pair.J];
                        }
                    }
                    V = R * 0.125f + V * 0.5;
                }
                pv.Add(V);
            }
            mesh.Vertices.AddVertices(pv);
            mesh.Vertices.AddVertices(pe);
            mesh.Vertices.AddVertices(pf);
            for (int i = 0; i < x.Faces.Count; i++)
            {
                int[] index = vs.IndicesFromFace(i);
                if (x.Faces[i].IsQuad)
                {
                    int pc = pv.Count + pe.Count + i;
                    int p1 = index[0]; int p2 = index[1]; int p3 = index[2]; int p4 = index[3];
                    int p12 = el.GetEdgeIndex(p1, p2) + pv.Count;
                    int p23 = el.GetEdgeIndex(p2, p3) + pv.Count;
                    int p34 = el.GetEdgeIndex(p3, p4) + pv.Count;
                    int p41 = el.GetEdgeIndex(p4, p1) + pv.Count;
                    mesh.Faces.AddFace(p1, p12, pc, p41);
                    mesh.Faces.AddFace(p12, p2, p23, pc);
                    mesh.Faces.AddFace(pc, p23, p3, p34);
                    mesh.Faces.AddFace(p41, pc, p34, p4);
                }
                else if (x.Faces[i].IsTriangle)
                {
                    int pc = pv.Count + pe.Count + i;
                    int p1 = index[0]; int p2 = index[1]; int p3 = index[2];
                    int p12 = el.GetEdgeIndex(p1, p2) + pv.Count;
                    int p23 = el.GetEdgeIndex(p2, p3) + pv.Count;
                    int p31 = el.GetEdgeIndex(p3, p1) + pv.Count;
                    mesh.Faces.AddFace(p1, p12, pc, p31);
                    mesh.Faces.AddFace(p12, p2, p23, pc);
                    mesh.Faces.AddFace(pc, p23, p3, p31);
                }
            }
            mesh.UnifyNormals();
            return(mesh);
        }
Пример #6
0
        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);
        }