Ejemplo n.º 1
0
        /// <summary>
        /// Iterator.
        /// Circulate around a given vertex and enumerate all incoming halfedges.
        /// </summary>
        /// <param name="vertexHandle">A handle to a vertex to use as a 'center' vertex.</param>
        /// <returns>An Enumerable of HalfEdge handles to be used in loops, etc.</returns>
        public IEnumerable <HandleHalfEdge> EnVertexIncomingHalfEdge(HandleVertex vertexHandle)
        {
            List <HandleHalfEdge> LTmpIncomingHedges = new List <HandleHalfEdge>();

            //Get the one outgoing half-edge for the vertex.
            HandleHalfEdge currentHedge = _LvertexPtrCont[vertexHandle]._h;
            //Remember the index of the first half-edge
            int startHedgeIndex = currentHedge;

            do
            {
                if (currentHedge == -1)
                {
                    break;
                }

                HEdgePtrCont currentHedgeContainer = _LhedgePtrCont[currentHedge];
                if (vertexHandle == _LhedgePtrCont[currentHedgeContainer._he]._v)
                {
                    LTmpIncomingHedges.Add(currentHedgeContainer._he);
                }
                currentHedge = _LhedgePtrCont[currentHedgeContainer._he]._nhe;
            } while (currentHedge != startHedgeIndex);

            return(LTmpIncomingHedges);

            //return _LhedgePtrCont.Where(e => e._v == vertexHandle).AsParallel().Select(e => _LhedgePtrCont[e._he._DataIndex]._he).AsParallel().ToList();
            //return (from e in _LhedgePtrCont where e._v == vertexHandle select _LhedgePtrCont[e._he]._he).AsParallel().ToList();
        }
Ejemplo n.º 2
0
 /// <summary>
 /// Only for testing now.
 /// </summary>
 /// <param name="fromVert"></param>
 /// <param name="toVert"></param>
 /// <returns></returns>
 private HandleEdge DoesConnectionExist(HandleVertex fromVert, HandleVertex toVert)
 {
     return(new HandleEdge(
                _LedgePtrCont.FindIndex(
                    edgePtrCont => _LhedgePtrCont[edgePtrCont._he1]._v == fromVert && _LhedgePtrCont[edgePtrCont._he2]._v == toVert || _LhedgePtrCont[edgePtrCont._he1]._v._DataIndex == toVert && _LhedgePtrCont[edgePtrCont._he2]._v == fromVert)
                ));
 }
Ejemplo n.º 3
0
        /// <summary>
        /// This method calculates vertex normals for a specific vertex in the geometry and inserts them at the corresponding half-edges on the correct faces.
        /// This method uses an angle based algorithm to determine whether to calculate with another faces normal or not.
        /// </summary>
        /// <param name="vertexHandle">A handle for the vertex to calc the normals for.</param>
        public void CalcVertexNormal(HandleVertex vertexHandle)
        {
            List <HandleHalfEdge> EincomingHEdges = EnVertexIncomingHalfEdge(vertexHandle).ToList();

            // Loop over every incoming half-edge.
            foreach (HandleHalfEdge handleHedge in EincomingHEdges)
            {
                int hedgeIndex = handleHedge;
                // Check if the half-edge is pointing to a face.
                int faceIndex = _LhedgePtrCont[hedgeIndex]._f;
                if (faceIndex == -1)
                {
                    return;
                }

                float3 currentFaceNormal = _LfaceNormals[_LfacePtrCont[faceIndex]._fn];
                float3 normalAggregate   = new float3();
                // Loop over every incoming half-edge again, so we can compare the angles between the current one and all the others.
                // We do this to decide which normal should be added to the sum and which not.
                foreach (int eincomingHEdge in EincomingHEdges)
                {
                    // Add the current normal if the index is on it and do not compare any angles etc.
                    if (eincomingHEdge == hedgeIndex)
                    {
                        normalAggregate += currentFaceNormal;
                        continue;
                    }
                    // Stop when the current half-edge is not pointing to a face.
                    int faceIndex2 = _LhedgePtrCont[eincomingHEdge]._f;
                    if (faceIndex2 == -1)
                    {
                        continue;
                    }

                    float3 normalToCompare = _LfaceNormals[_LfacePtrCont[faceIndex2]._fn];

                    float dot = float3.Dot(currentFaceNormal, normalToCompare);
                    if (System.Math.Acos(dot) * _constPiFactor < _SmoothingAngle)
                    {
                        normalAggregate += float3.Add(normalAggregate, normalToCompare);
                    }
                }

                _LVertexNormals.Add(float3.Normalize(normalAggregate));

                HEdgePtrCont currentHedge = _LhedgePtrCont[hedgeIndex];
                _LhedgePtrCont[hedgeIndex] = new HEdgePtrCont()
                {
                    _f   = currentHedge._f,
                    _he  = currentHedge._he,
                    _nhe = currentHedge._nhe,
                    _v   = currentHedge._v,
                    _vn  = new HandleVertexNormal(_LVertexNormals.Count - 1),
                    _vuv = currentHedge._vuv
                };
            }
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Establishes a connection between two vertices.
        /// 1) Creates two half-edges
        /// 2) Fills them with information
        /// 3) Creates an edge pointer container and adds it to the geo container.
        /// 4) returns a handle to an edge
        /// </summary>
        /// <param name="fromVert">HandleVertex from which vertex</param>
        /// <param name="toVert">Handlevertex to which vertex</param>
        /// <returns>Returns a handle to the half-edge that has just been inserted</returns>
        public HandleHalfEdge CreateConnection(HandleVertex fromVert, HandleVertex toVert)
        {
            // Check if the connection does already exist.
            HandleEdge existingEdge = DoesConnectionExist(fromVert, toVert);

            if (existingEdge != -1)
            {
                return(ReuseExistingConnection(existingEdge, fromVert, toVert));
            }
            else
            {
                return(CreateAllNewConnection(fromVert, toVert));
            }
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Adds a vertex to the geometry container.
        /// Will return a handle to the newly inserted or still existing vertex.
        /// </summary>
        /// <param name="val">float3 value to insert</param>
        /// <returns>Returns a handle to the just inserted vertex or a handle to an existing one because the given one was already inserterd.</returns>
        public HandleVertex AddVertex(float3 val)
        {
            int          index   = DoesVertexExist(val);
            HandleVertex hvToAdd = new HandleVertex()
            {
                _DataIndex = -1
            };

            // When vertex does not exist - insert it
            if (index == -1)
            {
                _LvertexVal.Add(val);

                _LvertexPtrCont.Add(
                    new VertexPtrCont()
                {
                    _h = new HandleHalfEdge()
                    {
                        _DataIndex = -1
                    }
                }
                    );
                hvToAdd = new HandleVertex()
                {
                    _DataIndex = _LvertexPtrCont.Count - 1
                };
            }
            else
            {
                HandleVertex vHndl = new HandleVertex();
                vHndl._DataIndex = index;
                hvToAdd          = vHndl;
            }

            if (!_LverticeHndl.Contains(hvToAdd))
            {
                _LverticeHndl.Add(hvToAdd);
            }
            else
            {
                if (LFGMessages._DEBUGOUTPUT)
                {
                    Debug.WriteLine("$$$ Vertex has been already inserted!");
                }
            }
            return(hvToAdd);
        }
Ejemplo n.º 6
0
        /// <summary>
        /// For testing only now.
        /// </summary>
        /// <param name="existingEdge"></param>
        /// <param name="fromVert"></param>
        /// <param name="toVert"></param>
        /// <returns></returns>
        private HandleHalfEdge ReuseExistingConnection(HandleEdge existingEdge, HandleVertex fromVert, HandleVertex toVert)
        {
            // Check half-edge 1 and 2 if one points to the actual face. This is the one we use for our face then. If no one we build a new connection.
            HEdgePtrCont hedge1 = _LhedgePtrCont[_LedgePtrCont[existingEdge]._he1];
            HEdgePtrCont hedge2 = _LhedgePtrCont[_LedgePtrCont[existingEdge]._he2];

            HandleHalfEdge hedgeToUse = new HandleHalfEdge(-1);

            if (hedge2._f == -1)
            {
                // It is hedge 2 that is free. We should use it.
                hedgeToUse = _LedgePtrCont[existingEdge]._he2;
            }
            else if (hedge1._f == -1)
            {
                // It is hedge 1 that is free. We should use it. Should never happen. TODO: Exception throw?
                hedgeToUse = _LedgePtrCont[existingEdge]._he1;
            }
            else
            {
                // Neither one of the faces of the existing half-edges was free so we build a new edge.
                return(CreateAllNewConnection(fromVert, toVert));
            }
            // Updating the face pointer.
            HEdgePtrCont hedge = _LhedgePtrCont[hedgeToUse];

            hedge._f = new HandleFace(_LfacePtrCont.Count - 1);

            _LhedgePtrCont[hedgeToUse] = new HEdgePtrCont()
            {
                _f   = hedge._f,
                _he  = hedge._he,
                _nhe = hedge._nhe,
                _v   = hedge._v,
                _vn  = hedge._vn,
                _vuv = hedge._vuv
            };

            return(hedgeToUse);
        }
Ejemplo n.º 7
0
        /// <summary>
        /// For testing now only.
        /// </summary>
        /// <returns></returns>
        private HandleHalfEdge CreateAllNewConnection(HandleVertex fromVert, HandleVertex toVert)
        {
            HEdgePtrCont hedge1 = new HEdgePtrCont()
            {
                _f   = new HandleFace(_LfacePtrCont.Count - 1),
                _he  = new HandleHalfEdge(_LedgePtrCont.Count == 0 ? 1 : _LhedgePtrCont.Count + 1),
                _v   = new HandleVertex(toVert),
                _vn  = new HandleVertexNormal(-1),
                _vuv = new HandleVertexUV(-1),
                _nhe = new HandleHalfEdge(-1)
            };

            HEdgePtrCont hedge2 = new HEdgePtrCont()
            {
                _f   = new HandleFace(-1),
                _he  = new HandleHalfEdge(_LedgePtrCont.Count == 0 ? 0 : _LhedgePtrCont.Count),
                _v   = new HandleVertex(fromVert),
                _vn  = new HandleVertexNormal(-1),
                _vuv = new HandleVertexUV(-1),
                _nhe = new HandleHalfEdge(-1)
            };

            _LhedgePtrCont.Add(hedge1);
            _LhedgePtrCont.Add(hedge2);

            _LedgePtrCont.Add(
                new EdgePtrCont()
            {
                _he1 = new HandleHalfEdge(_LhedgePtrCont.Count - 2),
                _he2 = new HandleHalfEdge(_LhedgePtrCont.Count - 1)
            }
                );
            _LedgeHndl.Add(
                new HandleEdge()
            {
                _DataIndex = _LedgePtrCont.Count - 1
            }
                );

            // Update the vertices.
            VertexPtrCont vertFrom = _LvertexPtrCont[fromVert._DataIndex];
            VertexPtrCont vertTo   = _LvertexPtrCont[toVert._DataIndex];

            if (!vertFrom._h.isValid)
            {
                vertFrom._h = _LedgePtrCont[_LedgePtrCont.Count - 1]._he1;
                _LvertexPtrCont[fromVert] = new VertexPtrCont()
                {
                    _h = vertFrom._h
                };
            }
            if (!vertTo._h.isValid)
            {
                vertTo._h = _LedgePtrCont[_LedgePtrCont.Count - 1]._he2;
                _LvertexPtrCont[toVert] = new VertexPtrCont()
                {
                    _h = vertTo._h
                };
            }

            return(_LedgePtrCont[_LedgePtrCont.Count - 1]._he1);
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Adds a face from the importer to the geometry container
        /// </summary>
        /// <param name="gf">GeoFace object from the importer</param>
        private void AddFace(GeoFace gf)
        {
            // Add a face container.
            _LfacePtrCont.Add(
                new FacePtrCont()
            {
                _h = new HandleHalfEdge()
                {
                    _DataIndex = -1
                }
            }
                );
            // Add a face handle.
            _LfaceHndl.Add(
                new HandleFace()
            {
                _DataIndex = _LfacePtrCont.Count - 1
            }
                );

            // Insert all the vertices for the face.
            List <HandleVertex> LHandleVertsForFace = new List <HandleVertex>();

            foreach (float3 vVal in gf._LFVertices)
            {
                LHandleVertsForFace.Add(
                    AddVertex(vVal)
                    );
            }
            // Insert all the uv coordinates for the face.
            List <HandleVertexUV> LHandleUVsForFace = new List <HandleVertexUV>();

            foreach (float2 uvVal in gf._UV)
            {
                _LuvCoordinates.Add(uvVal);
                LHandleUVsForFace.Add(new HandleVertexUV()
                {
                    _DataIndex = _LuvCoordinates.Count - 1
                });
            }

            // Build up the half-edge connections for the face
            List <HandleHalfEdge> LHandleHEForFace = new List <HandleHalfEdge>();

            for (int i = 0; i < LHandleVertsForFace.Count; i++)
            {
                HandleVertex fromVert = LHandleVertsForFace[i];
                HandleVertex toVert   = i + 1 < LHandleVertsForFace.Count ? LHandleVertsForFace[i + 1] : LHandleVertsForFace[0];

                LHandleHEForFace.Add(
                    CreateConnection(fromVert, toVert)
                    );
            }

            // Loop over all the half-edges for the face and concat them and set the correct uv coordinates.
            for (int i = 0; i < LHandleHEForFace.Count; i++)
            {
                HandleHalfEdge currentHedge = LHandleHEForFace[i];
                HEdgePtrCont   hedge        = _LhedgePtrCont[currentHedge];
                HandleHalfEdge nextHedge    = i + 1 < LHandleHEForFace.Count ? LHandleHEForFace[i + 1] : LHandleHEForFace[0];
                hedge._nhe = nextHedge;
                if (LHandleUVsForFace.Count > 0)
                {
                    HandleVertexUV currentUV = i + 1 < LHandleUVsForFace.Count ? LHandleUVsForFace[i + 1] : LHandleUVsForFace[0];
                    hedge._vuv = currentUV;
                }
                //_LhedgePtrCont.RemoveAt(currentHedge);
                //_LhedgePtrCont.Insert(currentHedge, hedge);
                _LhedgePtrCont[currentHedge] = new HEdgePtrCont()
                {
                    _f   = hedge._f,
                    _he  = hedge._he,
                    _nhe = hedge._nhe,
                    _v   = hedge._v,
                    _vn  = hedge._vn,
                    _vuv = hedge._vuv
                };
            }

            // Set the half-edge the face points to.
            FacePtrCont face = _LfacePtrCont[_LfacePtrCont.Count - 1];

            face._h = new HandleHalfEdge(LHandleHEForFace.First());
            _LfacePtrCont.RemoveAt(_LfacePtrCont.Count - 1);
            _LfacePtrCont.Add(face);
        }
Ejemplo n.º 9
0
        /// <summary>
        /// This method converts a quad based 'Geometry' object to a triangle based one.
        /// </summary>
        private void TriangulateGeometry()
        {
            List <HandleFace> LtmpFaces = new List <HandleFace>();

            foreach (HandleFace currentFace in _LfaceHndl)
            {
                // Pruefe zuerst ob man das face triangulaten sollte oder nicht.
                if (EnFaceAdjacentHalfEdges(currentFace).Count() == 3)
                {
                    continue;
                }

                // Hole aktuelles face und merke den index.
                FacePtrCont currentFaceCont = _LfacePtrCont[currentFace];
                // Merke erste hedge h0.
                HandleHalfEdge h0H    = currentFaceCont._h;
                HEdgePtrCont   h0Cont = _LhedgePtrCont[h0H];
                // Merke ersten vert v0.
                HandleVertex v0H = _LhedgePtrCont[h0Cont._he]._v;
                // Merke die letzte hedge im face hl.
                //HandleHalfEdge hlH = RetLastHalfEdgeInFaceCw(currentFace);

                var temp = EnFaceAdjacentHalfEdges(currentFace);


                HandleHalfEdge hlH    = temp.ElementAt(temp.Count() - 1);
                HEdgePtrCont   hlCont = _LhedgePtrCont[hlH];
                // Lege zwei neue hedges an und fülle sie korrekt.
                int            hedgeCount = _LhedgePtrCont.Count;
                HandleHalfEdge hedge0H    = new HandleHalfEdge()
                {
                    _DataIndex = hedgeCount
                };
                HandleHalfEdge hedge1H = new HandleHalfEdge()
                {
                    _DataIndex = hedgeCount + 1
                };
                HandleEdge edgeHNew = new HandleEdge()
                {
                    _DataIndex = _LedgeHndl.Count
                };
                EdgePtrCont edgeContNew = new EdgePtrCont()
                {
                    _he1 = hedge0H, _he2 = hedge1H
                };

                HEdgePtrCont newhedge0 = new HEdgePtrCont()
                {
                    _nhe = h0H,
                    _v   = v0H,
                    _he  = hedge1H,
                    _f   = currentFace,
                    _vn  = hlCont._vn,
                    _vuv = hlCont._vuv
                };
                // Hole h1 und h2 zum Merken.
                HandleHalfEdge h1H    = h0Cont._nhe;
                HEdgePtrCont   h1Cont = _LhedgePtrCont[h1H];
                HandleHalfEdge h2H    = h1Cont._nhe;
                HEdgePtrCont   h2Cont = _LhedgePtrCont[h2H];

                HEdgePtrCont newhedge1 = new HEdgePtrCont()
                {
                    _nhe = h1Cont._nhe,
                    _v   = h1Cont._v,
                    _he  = hedge0H,
                    _f   = new HandleFace(-1),
                    _vn  = h1Cont._vn,
                    _vuv = h1Cont._vuv,
                };
                // Update die jeweiligen next pointer der angrenzenden hedges.
                h1Cont._nhe = hedge0H;
                hlCont._nhe = hedge1H;
                // Lege ein neues face an für das triangle 2.
                HandleFace f1H = new HandleFace()
                {
                    _DataIndex = (_LfaceHndl.Count - 1) + LtmpFaces.Count + 1
                };
                FacePtrCont f1Cont = new FacePtrCont()
                {
                    _fn = currentFaceCont._fn, _h = hlH
                };
                // Update das neue triangle bezüglich des neuen faces. Dazu erstmal h2 holen noch.
                newhedge1._f = f1H;
                h2Cont._f    = f1H;
                hlCont._f    = f1H;
                // Sichere die Änderungen in den listen.
                _LedgeHndl.Add(edgeHNew);
                _LedgePtrCont.Add(edgeContNew);
                _LhedgePtrCont.Add(newhedge0);
                _LhedgePtrCont.Add(newhedge1);

                // Speichere das face handle erstmal in tmp faces wegen der iteration.
                LtmpFaces.Add(f1H);
                _LfacePtrCont.Add(f1Cont);

                _LhedgePtrCont[h1H] = new HEdgePtrCont()
                {
                    _f   = h1Cont._f,
                    _he  = h1Cont._he,
                    _nhe = h1Cont._nhe,
                    _v   = h1Cont._v,
                    _vn  = h1Cont._vn,
                    _vuv = h1Cont._vuv
                };

                _LhedgePtrCont[h2H] = new HEdgePtrCont()
                {
                    _f   = h2Cont._f,
                    _he  = h2Cont._he,
                    _nhe = h2Cont._nhe,
                    _v   = h2Cont._v,
                    _vn  = h2Cont._vn,
                    _vuv = h2Cont._vuv
                };

                _LhedgePtrCont[hlH] = new HEdgePtrCont()
                {
                    _f   = hlCont._f,
                    _he  = hlCont._he,
                    _nhe = hlCont._nhe,
                    _v   = hlCont._v,
                    _vn  = hlCont._vn,
                    _vuv = hlCont._vuv
                };
            }

            foreach (HandleFace handleFace in LtmpFaces)
            {
                _LfaceHndl.Add(handleFace);
            }
            LtmpFaces.Clear();
        }
Ejemplo n.º 10
0
 /// <summary>
 /// Iterator.
 /// Circulate around a given vertex and enumerate all faces adjacent to the center vertex.
 /// </summary>
 /// <param name="vertexHandle">Handle to the vertex to do this operation on.</param>
 /// <returns>An Enumerable of HalfEdge handles to be used in loops, etc.</returns>
 public IEnumerable <HandleFace> EnVertexAdjacentFaces(HandleVertex vertexHandle)
 {
     return(EnVertexIncomingHalfEdge(vertexHandle).Select(handleHalfEdge => _LhedgePtrCont[handleHalfEdge]._f));
 }
Ejemplo n.º 11
0
 /// <summary>
 /// Iterator.
 /// Circulate around a given vertex and enumerate all outgoing halfedges.
 /// </summary>
 /// <param name="vertexHandle">A handle to a vertex to use as a 'center' vertex.</param>
 /// <returns>An Enumerable of HalfEdge handles to be used in loops, etc.</returns>
 public IEnumerable <HandleHalfEdge> EnVertexOutgoingHalfEdge(HandleVertex vertexHandle)
 {
     return(EnVertexIncomingHalfEdge(vertexHandle).Select(handleHalfEdge => _LhedgePtrCont[handleHalfEdge]._he));
 }
Ejemplo n.º 12
0
 /// <summary>
 /// Iterator.
 /// Circulate around a given vertex and enumerate all vertices connected by a direct edge.
 /// </summary>
 /// <param name="vertexHandle">A handle to a vertex to use as a 'center' vertex.</param>
 /// <returns>An Enumerable of VertexHandles to be used in loops, etc.</returns>
 public IEnumerable <HandleVertex> EnStarVertexVertex(HandleVertex vertexHandle)
 {
     return(EnVertexIncomingHalfEdge(vertexHandle).Select(handleHalfEdge => _LhedgePtrCont[_LhedgePtrCont[handleHalfEdge]._he]._v));
 }