Esempio n. 1
0
 private void UpdateSiblingConvexDeleting(LinkedListNode <MappedPoint> node)
 {
     if (!IsVertConvex(
             LinkedListExtensions.Previous(node).Value,
             node.Value,
             LinkedListExtensions.Next(node).Value))
     {
         _earsVerts.Remove(node);
         _reflexVerts.Add(node);
         _convexVerts.Remove(node);
     }
     else
     {
         if (!ShouldAddConvexToEar(node))
         {
             _earsVerts.Remove(node);
         }
         else
         {
             if (!_earsVerts.Contains(node))
             {
                 _earsVerts.Add(node);
             }
         }
     }
 }
Esempio n. 2
0
        public List <Triangle> Triangulate()
        {
            for (var p = _pointsN.First; p != null; p = p.Next)
            {
                if (IsVertConvex(LinkedListExtensions.Previous(p).Value, p.Value, LinkedListExtensions.Next(p).Value))
                {
                    _convexVerts.Add(p);
                }
                else
                {
                    _reflexVerts.Add(p);
                }
            }

            foreach (var node in _convexVerts)
            {
                if (ShouldAddConvexToEar(node))
                {
                    _earsVerts.Add(node);
                }
            }

            while (_earsVerts.Any())
            {
                CreateTriangle();
            }

            return(_triangles);
        }
Esempio n. 3
0
        private void UnionFatherAndChildPoints(SliceHierarchy child, SliceHierarchy father,
                                               LinkedListNode <MappedPoint> childStartPoint, LinkedListNode <MappedPoint> fatherStartPoint)
        {
            var prev = fatherStartPoint;

            for (var p3 = childStartPoint; p3 != LinkedListExtensions.Previous(childStartPoint); p3 = LinkedListExtensions.Next(p3))
            {
                prev = father.Points.AddAfter(prev, p3.Value);
            }

            prev = father.Points
                   .AddAfter(prev, LinkedListExtensions.Previous(childStartPoint).Value);
            prev = father.Points.AddAfter(prev, childStartPoint.Value);
            father.Points.AddAfter(prev, fatherStartPoint.Value);

            father.MaxX = Mathf.Max(father.MaxX, child.MaxX);
        }
Esempio n. 4
0
        private bool ShouldAddConvexToEar(LinkedListNode <MappedPoint> node)
        {
            for (var p = _pointsN.First; p != null; p = p.Next)
            {
                if (
                    !LinkedListExtensions.Previous(node).Value.v2.Equals(p.Value.v2) &&
                    !node.Value.v2.Equals(p.Value.v2) &&
                    !LinkedListExtensions.Next(node).Value.v2.Equals(p.Value.v2)
                    )
                {
                    if (IsPointInTriangle(
                            p.Value,
                            LinkedListExtensions.Previous(node).Value,
                            node.Value,
                            LinkedListExtensions.Next(node).Value)
                        )
                    {
                        return(false);
                    }
                }
            }

            return(true);
        }
Esempio n. 5
0
        private void CreateTriangle()
        {
            var node     = _earsVerts.First();
            var prevNode = LinkedListExtensions.Previous(node);
            var nextNode = LinkedListExtensions.Next(node);

            _earsVerts.Remove(node);
            _triangles.Add(new Triangle(prevNode.Value, node.Value, nextNode.Value));
            _pointsN.Remove(node);

            ////// update convex and reflex and points
            if (_convexVerts.Contains(prevNode))
            {
                UpdateSiblingConvexDeleting(prevNode);
            }

            if (_convexVerts.Contains(nextNode))
            {
                UpdateSiblingConvexDeleting(nextNode);
            }

            if (_convexVerts.Contains(node))
            {
                _convexVerts.Remove(node);
            }

            if (_reflexVerts.Contains(prevNode))
            {
                UpdateSiblingReflexDeleting(prevNode);
            }

            if (_reflexVerts.Contains(nextNode))
            {
                UpdateSiblingReflexDeleting(nextNode);
            }
        }