/// <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(); }
/// <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); }
/// <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); }
/// <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(); }