Пример #1
0
        private static void SwapBorderEdgeToFront(FaceRef[] efra, int[] fera, int vi)
        {
            if (fera[vi] == 0)
            {
                return;
            }
            int firstEdgeRef   = EdgeRef.Create(vi, 0);
            int otherVertexRef = efra[firstEdgeRef].Index;

            if (otherVertexRef < 0)
            {
                return;
            }
            if (TopologyVertexSideOf(otherVertexRef) != 1)
            {
                return;
            }
            int edgeRef = efra[firstEdgeRef | 1].Index;

            while (edgeRef >= 0)
            {
                otherVertexRef = efra[edgeRef].Index;
                if (TopologyVertexSideOf(otherVertexRef) != 1)
                {
                    Fun.Swap(ref efra[firstEdgeRef].Index, ref efra[edgeRef].Index);
                    return;
                }
                edgeRef = efra[edgeRef | 1].Index;
            }
        }
Пример #2
0
 /// <summary>
 /// Check if the edge is in the edge list of vertex v0.
 /// </summary>
 private static int FindEdgeInList(
     FaceRef[] edgeFaceRefArray, int v0, int v1)
 {
     #if DEBUG
     int count = 0;
     #endif
     int otherVertexRef;
     int edgeRef = EdgeRef.Create(v0, 0);
     do
     {
         otherVertexRef = edgeFaceRefArray[edgeRef].Index;
         if (TopologyVertexIndexOf(otherVertexRef) == v1)  // found edge!
         {
             // check if its a nonmanifold edge, use it if unused,
             // search first unused, use it and mark it
             if (TopologyVertexSideOf(otherVertexRef) < 3)
             {
                 if (TopologyVertexSideOf(otherVertexRef) == 2)
                 {
                     edgeFaceRefArray[edgeRef].Index
                         = TopologyVertexRef(v1, 3);
                 }
                 return(edgeRef);
             }
         }
         edgeRef = edgeFaceRefArray[edgeRef | 1].Index;
         #if DEBUG
         ++count;
         #endif
     }while (edgeRef >= 0);
     return(-1);
 }
Пример #3
0
        private void BuildTopology(int eulerCharacteristic, bool strict)
        {
            Report.BeginTimed(12, "building topology for {0} {1}",
                              m_faceCount,
                              "face".Plural(m_faceCount));

            // use Eulers Formula to compute number of edges, but there
            // must be at least one edge per vertex, otherwise the mesh
            // cannot be topologically correct
            int edgeCount
                = Fun.Max(m_vertexCount,
                          m_vertexCount + m_faceCount - eulerCharacteristic);
            int nonManifoldEdgeCount = 0;

            FaceRef[] edgeFaceRefArray
                = new FaceRef[2 * edgeCount].Set(new FaceRef(int.MinValue, int.MinValue));

            // make this array large enough to hold one counter (for the
            // borderedges) per vertex, even if there are unused vertices
            int[] faceEdgeRefArray
                = new int[Fun.Max(m_faceVertexCount,
                                  m_vertexCount)].Set(0);
            int freeEdgeRef = EdgeRef.Create(m_vertexCount, 0);

            int[] fvia = m_faceVertexIndexArray;

            // create list of edges for each vertex stored in edgeFaceRefArray
            for (int fi = 0; fi < m_faceCount; fi++)
            {
                int ffi = m_firstIndexArray[fi];
                int fvc = m_firstIndexArray[fi + 1] - ffi;
                for (int fs0 = fvc - 1, fs1 = 0; fs1 < fvc; fs0 = fs1, fs1++)
                {
                    nonManifoldEdgeCount +=
                        AddEdge(ref edgeFaceRefArray, ref freeEdgeRef,
                                faceEdgeRefArray,
                                fvia[ffi + fs0], fvia[ffi + fs1], strict, true);
                }
            }

            int borderEdgeCount = 0;

            for (int vi = 0; vi < m_vertexCount; vi++)
            {
                borderEdgeCount += faceEdgeRefArray[vi];
            }

            if (borderEdgeCount > 0)
            {
                for (int vi = 0; vi < m_vertexCount; vi++)
                {
                    SwapBorderEdgeToFront(edgeFaceRefArray,
                                          faceEdgeRefArray, vi);
                }
            }

            // fill faceEdgeRefArray by searching edge in both vertex lists

            for (int fi = 0; fi < m_faceCount; fi++)
            {
                int ffi = m_firstIndexArray[fi];
                int fvc = m_firstIndexArray[fi + 1] - ffi;
                for (int fs0 = fvc - 1, fs1 = 0; fs1 < fvc; fs0 = fs1, fs1++)
                {
                    int v0 = fvia[ffi + fs0], v1 = fvia[ffi + fs1];
                    int edgeRef = FindEdgeInList(edgeFaceRefArray, v0, v1);
                    if (edgeRef < 0)
                    {
                        edgeRef = EdgeRef.Reversed(
                            FindEdgeInList(edgeFaceRefArray, v1, v0));
                    }
                    faceEdgeRefArray[ffi + fs0] = edgeRef;
                }
            }

            if (nonManifoldEdgeCount > 0)
            {
                for (int fi = 0; fi < m_faceCount; fi++)
                {
                    int ffi = m_firstIndexArray[fi];
                    int fvc = m_firstIndexArray[fi + 1] - ffi;
                    for (int fs0 = fvc - 1, fs1 = 0; fs1 < fvc; fs0 = fs1, fs1++)
                    {
                        ConnectNonManifoldEdges(edgeFaceRefArray,
                                                fvia[ffi + fs0], fvia[ffi + fs1]);
                    }
                }
                for (int edgeRef = 0; edgeRef < freeEdgeRef; edgeRef += 2)
                {
                    if (edgeFaceRefArray[edgeRef].Index < 0)
                    {
                        edgeFaceRefArray[edgeRef | 1].Index =
                            edgeFaceRefArray[edgeRef].Index;
                    }
                    else
                    {
                        edgeFaceRefArray[edgeRef | 1].Index = int.MinValue;
                    }
                    edgeFaceRefArray[edgeRef].Index = int.MinValue;
                    edgeFaceRefArray[edgeRef].Side  = int.MinValue;
                }
            }
            else
            {
                edgeFaceRefArray.Set(new FaceRef(int.MinValue, int.MinValue));
            }

            // go through faces, store backpointers from edges to faces

            for (int fi = 0; fi < m_faceCount; fi++)
            {
                int ffi = m_firstIndexArray[fi];
                int fvc = m_firstIndexArray[fi + 1] - ffi;
                for (int fs = 0; fs < fvc; fs++)
                {
                    int edgeRef = faceEdgeRefArray[ffi + fs];
                    edgeFaceRefArray[edgeRef].Index = fi;
                    edgeFaceRefArray[edgeRef].Side  = fs;
                }
            }

            EdgeCount            = EdgeRef.Index(freeEdgeRef);
            BorderEdgeCount      = borderEdgeCount;
            NonManifoldEdgeCount = nonManifoldEdgeCount;
            FaceEdgeRefArray     = faceEdgeRefArray;
            EdgeFaceRefArray     = edgeFaceRefArray;
            EulerCharacteristic  = m_vertexCount + m_faceCount - EdgeCount;

            if (nonManifoldEdgeCount > 0)
            {
                Report.End(12, ": non-manifold");
            }
            else
            {
                Report.End(12, ": euler characteristic {0}", EulerCharacteristic);
            }
        }
Пример #4
0
        /// <summary>
        /// Create rings of non-manifold edges. The references are stored
        /// in faceRef 0 of each edge, and need to be moved to the
        /// other faceRef before they can be used.
        /// </summary>
        private static void ConnectNonManifoldEdges(FaceRef[] efra, int v0, int v1)
        {
            int pEdgeRef = -1, pSide = -1;

            int v0FirstEdgeRef = EdgeRef.Create(v0, 0), v0count = 0;

            if (efra[v0FirstEdgeRef].Side == 0)
            {
                int hasNonManifolds = int.MinValue;
                int v0edgeRef       = v0FirstEdgeRef;
                while (v0edgeRef >= 0)
                {
                    int v1VertexRef = efra[v0edgeRef].Index;
                    if (TopologyVertexSideOf(v1VertexRef) > 1)
                    {
                        if (TopologyVertexIndexOf(v1VertexRef) == v1)
                        {
                            pEdgeRef = v0edgeRef; pSide = 0; ++v0count;
                        }
                        hasNonManifolds = 0;
                    }
                    v0edgeRef = efra[v0edgeRef | 1].Index;
                }
                efra[v0FirstEdgeRef].Side = hasNonManifolds;
            }

            int v1FirstEdgeRef = EdgeRef.Create(v1, 0), v1count = 0;

            if (efra[v1FirstEdgeRef].Side == 0)
            {
                int hasNonManifolds = int.MinValue;
                int v1edgeRef       = v1FirstEdgeRef;
                while (v1edgeRef >= 0)
                {
                    int v0VertexRef = efra[v1edgeRef].Index;
                    if (TopologyVertexSideOf(v0VertexRef) > 1)
                    {
                        if (TopologyVertexIndexOf(v0VertexRef) == v0)
                        {
                            pEdgeRef = v1edgeRef; pSide = 1; ++v1count;
                        }
                        hasNonManifolds = 0;
                    }
                    v1edgeRef = efra[v1edgeRef | 1].Index;
                }
                efra[v1FirstEdgeRef].Side = hasNonManifolds;
            }

            #if DEBUG
            int nonManifoldCount = v0count + v1count;
            if (nonManifoldCount == 1)
            {
                Report.Warn("single non-manifold edge");
            }
            #endif

            if (v0count > 0)
            {
                int v0edgeRef = v0FirstEdgeRef;
                int thisRef   = -1;
                while (v0count > 0)
                {
                    int v1VertexRef = efra[v0edgeRef].Index;
                    int nextRef     = v0edgeRef | 1;
                    if (TopologyVertexIndexOf(v1VertexRef) == v1 &&
                        TopologyVertexSideOf(v1VertexRef) > 1)
                    {
                        efra[v0edgeRef].Index = -pEdgeRef - (pSide == 0 ? 2 : 1);
                        pEdgeRef = v0edgeRef; pSide = 0; --v0count;
                        if (thisRef >= 0)
                        {
                            efra[thisRef].Index = efra[nextRef].Index;
                        }
                    }
                    v0edgeRef = efra[nextRef].Index;
                    thisRef   = nextRef;
                }
            }
            if (v1count > 0)
            {
                int v1edgeRef = v1FirstEdgeRef;
                int thisRef   = -1;
                while (v1count > 0)
                {
                    int v0VertexRef = efra[v1edgeRef].Index;
                    int nextRef     = v1edgeRef | 1;
                    if (TopologyVertexIndexOf(v0VertexRef) == v0 &&
                        TopologyVertexSideOf(v0VertexRef) > 1)
                    {
                        efra[v1edgeRef].Index = -pEdgeRef - (pSide == 1 ? 2 : 1);
                        pEdgeRef = v1edgeRef; pSide = 1; --v1count;
                        if (thisRef >= 0)
                        {
                            efra[thisRef].Index = efra[nextRef].Index;
                        }
                    }
                    v1edgeRef = efra[nextRef].Index;
                    thisRef   = nextRef;
                }
            }
        }
Пример #5
0
        /// <summary>
        /// The edgeFaceRefArray is misused to contain a list of edges for
        /// each vertex. For each vertex v, the list starts at the index v. As
        /// the edgeFaceRefArray can hold two values at each index, the
        /// first value (side 0) is used as the vertex index of the other
        /// vertex of the edge, and the second value (side 1) is used as a
        /// pointer to the next edge in the list. Each edge should be member
        /// of exactly one of the two edge lists of its vertices. When
        /// building up this data structure, it is necessary to look into both
        /// vertex lists if an edge has already been inserted.
        /// By adding external edges at the front of the vertex v0 list, and
        /// internal edges at the back, it is very likely, that border edges
        /// are the first edges in the list.
        /// Additionally we set the side filed of the side 0 references to
        /// indicate if a list contains (-1) or does not contain (0)
        /// non-manifold references.
        /// </summary>
        private static int AddEdge(
            ref FaceRef[] efra, ref int freeEdgeRef, int[] fera,
            int v0, int v1, bool strict, bool isExternalEdge)
        {
            int result         = -1;
            int v1FirstEdgeRef = EdgeRef.Create(v1, 0);
            // check if the edge is in the edge list of vertex v1
            int edgeRef            = v1FirstEdgeRef;
            int nonManifoldEdgeRef = -1;

            do
            {
                int otherVertexRef = efra[edgeRef].Index;
                if (TopologyVertexIndexOf(otherVertexRef) == v0)  // found
                {
                    if (TopologyVertexSideOf(otherVertexRef) > 0) // in use
                    {
                        if (strict)
                        {
                            Report.End(3, " FAILED!");
                            throw new Exception("Edge already in use!");
                        }
                        else
                        {
                            nonManifoldEdgeRef = edgeRef;
                            break;
                        }
                    }
                    else // fill other side of edge
                    {
                        fera[v1]           -= 1;
                        efra[edgeRef].Index = TopologyVertexRef(v0, 1);
                        result = edgeRef | 1;
                        break;
                    }
                }
                edgeRef = efra[edgeRef | 1].Index;
            }while (edgeRef >= 0);

            // check the edge list of vertex v0, if the edge is there

            int v0FirstEdgeRef = EdgeRef.Create(v0, 0);
            int v0LastEdgeRef  = -1;

            if (nonManifoldEdgeRef < 0)
            {
                edgeRef = v0FirstEdgeRef;
                do
                {
                    int otherVertexRef = efra[edgeRef].Index;
                    if (TopologyVertexIndexOf(otherVertexRef) == v1)
                    {
                        if (strict)
                        {
                            Report.End(3, " FAILED!");
                            throw new Exception("Edge already in use!");
                        }
                        else
                        {
                            nonManifoldEdgeRef = edgeRef;
                            break;
                        }
                    }
                    v0LastEdgeRef = edgeRef;
                    edgeRef       = efra[edgeRef | 1].Index;
                }while (edgeRef >= 0);
            }

            if (nonManifoldEdgeRef >= 0)
            {
                int nonManifoldEdgeCount = 1;
                int otherVertexRef       = efra[nonManifoldEdgeRef].Index;
                if (TopologyVertexSideOf(otherVertexRef) == 1)
                {
                    // swap edge to the front, split it,  and add 3rd edge
                    fera[v0]             += 1; fera[v1] += 1;
                    nonManifoldEdgeCount += 2;
                    if (TopologyVertexIndexOf(otherVertexRef) == v0)
                    {
                        if (nonManifoldEdgeRef != v1FirstEdgeRef)
                        {
                            efra[nonManifoldEdgeRef].Index = efra[v1FirstEdgeRef].Index;
                        }
                        efra[v1FirstEdgeRef].Index = TopologyVertexRef(v0, 2);
                        InsertEdge(ref efra, ref freeEdgeRef, v0FirstEdgeRef,
                                   TopologyVertexRef(v1, 2));
                    }
                    else
                    {
                        if (nonManifoldEdgeRef != v0FirstEdgeRef)
                        {
                            efra[nonManifoldEdgeRef].Index = efra[v0FirstEdgeRef].Index;
                        }
                        efra[v0FirstEdgeRef].Index = TopologyVertexRef(v1, 2);
                        InsertEdge(ref efra, ref freeEdgeRef, v1FirstEdgeRef,
                                   TopologyVertexRef(v0, 2));
                    }
                    efra[v1FirstEdgeRef].Side = 0;
                }
                else if (TopologyVertexSideOf(otherVertexRef) == 0)
                {
                    nonManifoldEdgeCount          += 1;
                    efra[nonManifoldEdgeRef].Index = TopologyVertexRef(v1, 2);
                }

                fera[v0] += 1;
                InsertEdge(ref efra, ref freeEdgeRef, v0FirstEdgeRef,
                           TopologyVertexRef(v1, 2));
                efra[v0FirstEdgeRef].Side = 0;
                return(nonManifoldEdgeCount);
            }

            if (result < 0) // we have to create a new (normal) edge
            {
                if (isExternalEdge)
                {
                    InsertEdge(ref efra, ref freeEdgeRef, v0FirstEdgeRef,
                               TopologyVertexRef(v1, 0));
                }
                else
                {
                    AppendEdge(ref efra, ref freeEdgeRef, v0FirstEdgeRef,
                               v0LastEdgeRef, TopologyVertexRef(v1, 0));
                }
                fera[v0] += 1;
            }
            return(0);
        }