HalfEdge_old.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using Wolfram.NETLink;

namespace MathPolyLib
{
    //public class HalfEdge : MathLinked
    //{
        /*
        public HalfEdge(PointRef start, PointRef end)
        {
            _start = start;
            _end = end;
        }

        public Facet Facet { get; set; }

        public EndPointPacket EndPointPacket
        {
            get
            {
                return new EndPointPacket(Start, End);
            }
        }

        public EndPointPacket OppositesEndPointPacket
        {
            get
            {
                return EndPointPacket.Opposite;
            }
        }

        public PointRef Start
        {
            get { return _start; }
            set { _start = value; }
        }

        public PointRef End
        {
            get { return _end; }
            set { _end = value; }
        }

        protected PointRef _start;
        protected PointRef _end;

        protected HalfEdge _opposite;

        public HalfEdge Opposite
        {
            get { return _opposite; }
            set
            {
                _opposite = value;
            }
        }

        protected HalfEdge _next;
        protected HalfEdge _prev;

        public HalfEdge Next
        {
            get { return _next; }
        }

        public HalfEdge Prev
        {
            get { return _prev; }
        }

        /*private List<HalfEdge> InsertAfter(HalfEdge he)
        {
            //Acting upon this
            var oldNext = _next;
            _next = he;

            //Acting upon he
            var retList = new List<HalfEdge>();
            if (he._next != null)
            {
                he._next._prev = null;
                retList.Add(he._next);
            }
            if (he._prev != null)
            {
                he._prev._next = null;
                retList.Add(he._prev);
            }
            he._next = oldNext;
            he._prev = this;
            return retList;
        }

        public IEnumerable<FoldingHalfEdge> HEsFromHere
        {
            get
            {
                yield return this;
                var he = this.Next;
                while (he != this)
                {
                    yield return he;
                    he = he.Next;
                }
            }
        }

        public IEnumerable<HalfEdge> HEsFromHereReversed
        {
            get
            {
                yield return this;
                var he = this.Prev;
                while (he != this)
                {
                    yield return he;
                    he = he.Prev;
                }
            }
        }

        public Expr AsVectorExpr
        {
            get { return EndPointPacket.AsVectorExpr; }
        }

        public Plane Plane
        {
            get
            {
                Expr point = Start.Point;
                Expr normal = ML["Normalize[Cross[{0},{1}]]"].Format(this.AsVectorExpr, Next.AsVectorExpr).FullSimplify().Eval();
                return new Plane(point, normal);
            }
        }

        public Expr DotOpposite
        {
            get { return ML["Dot[{0},{1}]"].Format(this.Plane.Normal, Opposite.Plane.Normal).Eval(); }
        }

        public HalfEdge[] DetourToVertex(PointRef p)
        {
            var ret = new HalfEdge[2];
            var outHE = new HalfEdge(End, p)
                {
                    Facet = Facet
                };
            var backHE = new HalfEdge(p, End)
                {
                    Facet = Facet
                };
            outHE.Opposite = backHE;
            backHE.Opposite = outHE;

            var oldNext = _next;
            _next = outHE;
            outHE._prev = this;
            outHE._next = backHE;
            backHE._prev = outHE;
            backHE._next = oldNext;

            ret[0] = outHE;
            ret[1] = backHE;
            return ret;
        }

        public Dictionary<HalfEdge, HalfEdge> LinkNext(HalfEdge he)
        {
            var d = new Dictionary<HalfEdge, HalfEdge>();
            d[this] = Next;
            d[he] = he.Prev;
            _next = he;
            he._prev = this;
            return d;
        }

        public bool OppIsNull
        {
            get { return Opposite == null; }
        }

        public void MergeAcross()
        {
            var prev = Prev;
            prev.LinkNext(Opposite.Next);
            Opposite.Prev.LinkNext(Next);
            Opposite.Facet.Head = null;
            foreach (var halfEdge in prev.HEsFromHere)
            {
                halfEdge.Facet = Facet;
            }
        }

        public override string ToString()
        {
            return String.Format("[{0} to {1}]", Start, End);
        }

        public IEnumerable<HalfEdge> CycleAboutEndPoint
        {
            get
            {
                yield return this;
                var he = this.Next.Opposite;
                while (he != this)
                {
                    yield return he;
                    he = he.Next.Opposite;
                }
            }
        }
        
        public Expr DotNext
        {
            get { return ML["Dot"].Bracket(this.AsVectorExpr, this.Next.EndPointPacket.Opposite.AsVectorExpr).Eval(); }
        }

        public Expr AngleToNext
        {
            get
            {
                return ML["ArcCos[{0}] / ({1} * {2})"].Format(this.DotNext, this.EndPointPacket.Magnitude,
                                                            this.Next.EndPointPacket.Magnitude).Eval();
            }
        }

        public Expr SumAngles
        {
            get
            {
                return this.CycleAboutEndPoint.Select(he => he.AngleToNext).Aggregate((a1, a2) => ML["{0} + {1}"].Format(a1,a2).Eval());
            }
        }

        public FoldingHalfEdge AsFoldingHalfEdge
        {
            get { return (this as FoldingHalfEdge); }
        }

        public Expr Curvature
        {
            get { return ML["2*Pi - {0}"].Format(SumAngles).Eval(); }
        }

        public virtual Expr Graphics
        {
            get { return null; }
        }

        public Expr Highlight
        {
            get { return ML["GraphicsGroup[ {{ Thick, Red, Arrow[ {{ {0},{1} }} ] }} ]"].Format(Start.Point, End.Point).Eval(); }
        }

        //Static methods

        private static readonly HalfEdge littleLine = new HalfEdge(PointRef.OriginRef, PointRef.Ref100);
        private static readonly HalfEdge line2 = new HalfEdge(PointRef.Ref100, PointRef.Ref010);
        private static readonly HalfEdge line3 = new HalfEdge(PointRef.Ref010, PointRef.OriginRef);

        public static HalfEdge LittleLine
        {
            get { return littleLine; }
        }

        public static HalfEdge Facetable
        {
            get
            {
                if (LittleLine.Next == null)
                {
                    LittleLine.LinkNext(line2);
                    line2.LinkNext(line3);
                    line3.LinkNext(LittleLine);
                }
                return LittleLine;
            }
        }

        //TODO this function doesn't work. And we don't run it very often.
        public virtual HalfEdge FacetRingClone
        {
            get
            {
                throw new NotImplementedException();
                /*
                var cloneRing = HEsFromHere.Select(he => he.ShallowClone).Skip(1).ToList();
                var prev = this.ShallowClone;
                var myClone = prev;

                foreach (var he in cloneRing.Concat(new[] {myClone}))
                {
                    he.Start = he.Start.DeepClone;
                    he.End = he.End.DeepClone;
                    he._prev = prev;
                    prev._next = he;
                }
                return myClone;
            }
        }

        protected virtual HalfEdge ShallowClone
        {
            get
            {
                throw new NotImplementedException();
                /*
                var n = new HalfEdge(Start, End){
                    _next = Next,
                    _prev = Prev,
                    _opposite = null};
                return n;
            }
        }

        public Expr NormalGraphics
        {
            get { return ML["GraphicsGroup[ {{Purple, Arrow[ {{ {0}, {0} + {1} }} ] }} ]"].Format(End.Point, Plane.Normal).Eval(); }
        }
        */
    //}
}