Beispiel #1
0
 private OutsideVertexSearcher(OutsideVertexSearcher copy) :
     this(copy.m_vertices, copy.m_triangles, copy.m_line)
 {
     CurrentTriangle = copy.CurrentTriangle;
     PreviousVertex  = copy.PreviousVertex;
     CurrentVertex   = copy.CurrentVertex;
 }
Beispiel #2
0
            public void SearchNext()
            {
                NextVertex   = -1;
                NextTriangle = -1;
                float lowestAngle = 360.0f;

                for (int i = 0; i < m_triangles.Count; i++)
                {
                    if (i == CurrentTriangle)
                    {
                        continue;
                    }

                    Vector3i triangle = m_triangles[i];
                    if (!triangle.ContainsValue(CurrentVertex))
                    {
                        continue;
                    }

                    int checkVertexMember = triangle.GetMemberByValue(CurrentVertex);
                    int checkVertex       = triangle.GetValueByMember(checkVertexMember + 1);
                    if (m_line.Contains(checkVertex))
                    {
                        continue;
                    }

                    Vector2f checkVertexValue   = m_vertices[checkVertex].ToVector2();
                    int      checkTriangleIndex = i;
                    if (checkVertexValue == CurrentVertexValue)
                    {
                        // recursivly find next non matching vertex
                        m_line.Add(checkVertex);
                        OutsideVertexSearcher deepSearcher = new OutsideVertexSearcher(this);
                        deepSearcher.CurrentTriangle = i;
                        deepSearcher.CurrentVertex   = checkVertex;
                        deepSearcher.SearchNext();
                        m_line.RemoveAt(m_line.Count - 1);

                        if (deepSearcher.NextVertex == -1)
                        {
                            continue;
                        }

                        checkVertex        = deepSearcher.NextVertex;
                        checkVertexValue   = m_vertices[deepSearcher.NextVertex].ToVector2();
                        checkTriangleIndex = deepSearcher.NextTriangle;
                    }

                    float angle = Vector2f.AngleFrom3Points(PreviousVertexValue, CurrentVertexValue, checkVertexValue);
                    if (angle <= lowestAngle)
                    {
                        NextVertex   = checkVertex;
                        NextTriangle = checkTriangleIndex;
                        lowestAngle  = angle;
                    }
                }
            }
Beispiel #3
0
        private Vector2f[] GenerateOutline()
        {
            FindOutsideTriangle(out int outsideTriangleIndex, out int outsideMember);
            Vector3i   outsideTriangle = m_triangles[outsideTriangleIndex];
            List <int> line            = new List <int>();
            int        vertex1         = outsideTriangle.GetValueByMember(outsideMember);
            int        vertex2         = outsideTriangle.GetValueByMember(outsideMember + 1);

            line.Add(vertex1);
            line.Add(vertex2);

            OutsideVertexSearcher searcher = new OutsideVertexSearcher(m_vertices, m_triangles, line);

            searcher.CurrentTriangle = outsideTriangleIndex;
            searcher.PreviousVertex  = vertex1;
            searcher.CurrentVertex   = vertex2;
            while (true)
            {
                searcher.SearchNext();

                if (searcher.NextVertex == -1)
                {
                    Vector3i currentTriangle = m_triangles[searcher.CurrentTriangle];
                    int      nextPointMember = currentTriangle.GetMemberByValue(searcher.CurrentVertex);
                    int      nextVertex      = currentTriangle.GetValueByMember(nextPointMember + 1);
                    searcher.PreviousVertex = searcher.CurrentVertex;
                    searcher.CurrentVertex  = nextVertex;
                    if (line.Contains(nextVertex))
                    {
                        break;
                    }
                }
                else
                {
                    searcher.CurrentTriangle = searcher.NextTriangle;
                    searcher.PreviousVertex  = searcher.CurrentVertex;
                    searcher.CurrentVertex   = searcher.NextVertex;
                }

                line.Add(searcher.CurrentVertex);
            }

            Vector2f[] outline = new Vector2f[line.Count];
            for (int i = 0; i < line.Count; i++)
            {
                outline[i] = m_vertices[line[i]].ToVector2();
            }

            HashSet <int> deletePoints = new HashSet <int>();

            foreach (int point in line)
            {
                deletePoints.Add(point);
            }
            while (true)
            {
                bool isNew = false;
                for (int i = 0; i < m_triangles.Count; i++)
                {
                    Vector3i vertex = m_triangles[i];
                    if (deletePoints.Contains(vertex.X))
                    {
                        isNew |= deletePoints.Add(vertex.Y);
                        isNew |= deletePoints.Add(vertex.Z);
                        m_triangles.RemoveAt(i--);
                    }
                    else if (deletePoints.Contains(vertex.Y))
                    {
                        isNew |= deletePoints.Add(vertex.Z);
                        isNew |= deletePoints.Add(vertex.X);
                        m_triangles.RemoveAt(i--);
                    }
                    else if (deletePoints.Contains(vertex.Z))
                    {
                        isNew |= deletePoints.Add(vertex.X);
                        isNew |= deletePoints.Add(vertex.Y);
                        m_triangles.RemoveAt(i--);
                    }
                }
                if (!isNew)
                {
                    break;
                }
            }

            return(outline);
        }