Example #1
0
    //this face is one of the srrounding faces attahed to vold
    public void ReplaceVertex(Vertex vold, Vertex vnew)
    {
        for (int i = 0; i < 3; i++)
        {
            if (vertex[i].position == vold.position)
            {
                vertex[i] = vnew;
                vold.RemoveFace(this);

                if (vnew != null)
                {
                    vnew.AddFace(this);
                }
                break;
            }
        }

        //remove reff of vold from Neighborhood
        vold.RemoveIfNonNeighbor(vertex[0]);
        vertex[0].RemoveIfNonNeighbor(vold);
        vold.RemoveIfNonNeighbor(vertex[1]);
        vertex[1].RemoveIfNonNeighbor(vold);
        vold.RemoveIfNonNeighbor(vertex[2]);
        vertex[2].RemoveIfNonNeighbor(vold);


        vertex[0].AddNeighbor(vertex[1]);
        vertex[0].AddNeighbor(vertex[2]);

        vertex[1].AddNeighbor(vertex[0]);
        vertex[1].AddNeighbor(vertex[2]);

        vertex[2].AddNeighbor(vertex[0]);
        vertex[2].AddNeighbor(vertex[1]);
        ComputeNormal();
    }
Example #2
0
    //this face is one of the srrounding faces attahed to vold
    public void ReplaceVertex(Vertex vold,Vertex vnew)
    {
        for(int i = 0; i < 3; i++)
        {

            if(vertex[i].position == vold.position  )
            {
                vertex[i]  = vnew;
                vold.RemoveFace( this );

                if(vnew!=null)
                vnew.AddFace( this );
                break;
            }
        }

        //remove reff of vold from Neighborhood
                vold.RemoveIfNonNeighbor( vertex[0] );
                vertex[0].RemoveIfNonNeighbor( vold );
           				vold.RemoveIfNonNeighbor( vertex[1] );
           				vertex[1].RemoveIfNonNeighbor( vold );
                vold.RemoveIfNonNeighbor( 	vertex[2] );
                vertex[2].RemoveIfNonNeighbor( vold );

                vertex[0]. AddNeighbor(vertex[1]);
                vertex[0]. AddNeighbor(vertex[2]);

                vertex[1]. AddNeighbor(vertex[0]);
                vertex[1]. AddNeighbor(vertex[2]);

                vertex[2]. AddNeighbor(vertex[0]);
                vertex[2]. AddNeighbor(vertex[1]);
                ComputeNormal();
    }
    public List <Edge> Analyze(Vector3[] dsm_vertices, int[] dsm_tris, Color[] maskcolors, bool peak = true)
    {
        // generate vertextriangle network graph in roof surface

        Vector3[] vertices;
        int[]     tris;
        facecount = dsm_tris.Length / 3;

        for (int i = 0; i < dsm_vertices.Length; i++)
        {
            Vertex v = new Vertex(dsm_vertices[i], i, i);
            LodVertices.Add(v);
        }

        for (int i = 0; i < facecount; i++)
        {
            int t = 3 * i;

            Vertex v0 = LodVertices[dsm_tris[t + 0]];
            Vertex v1 = LodVertices[dsm_tris[t + 1]];
            Vertex v2 = LodVertices[dsm_tris[t + 2]];

            Triangle tri = new Triangle(v0, v1, v2);
            LodTriangles.Add(tri);

            v0.AddFace(tri);
            v1.AddFace(tri);
            v2.AddFace(tri);
        }

        List <Edge> edges = new List <Edge>();

        int nedge = 0;

        for (k = 0; k < LodVertices.Count; k++)
        {
            //if(LodVertices[k].deleted) continue;
            for (int n = 0; n < LodVertices[k].neighbor.Count; n++)
            {
                if (LodVertices[k].neighbor[n].deleted)
                {
                    continue;
                }
                if (ComputeEdgeCollapseCost(LodVertices[k], LodVertices[k].neighbor[n]) < 1)
                {
                    //LodVertices[k].neighbor[n].deleted = true;

                    Vector3 p1 = Vector3.zero;
                    Vector3 p2 = Vector3.zero;
                    //rectify edge vector with id cheking
                    if (LodVertices[k].id < LodVertices[k].neighbor[n].id)
                    {
                        p1 = LodVertices[k].position;
                        p2 = LodVertices[k].neighbor[n].position;

                        //
                    }
                    else
                    {
                        p1 = LodVertices[k].neighbor[n].position;
                        p2 = LodVertices[k].position;
                    }
                    Vector3 edgevec = (p2 - p1).normalized;
                    if (Vector3.Dot(edgevec, Vector3.up) == 0)
                    {
                        Edge e = new Edge(p1, p2);
                        e.AtoB = edgevec;
                        edges.Add(e);
                    }
                }
            }
        }

        return(edges);
    }