Facet.cs

Go to the documentation of this file.

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

namespace PolyLink
{
    public class Facet : MathLinked
    {
        private static readonly Expr _p110 = MSingle.Eval("{1,1,0}");
        private static readonly PointRef _ref110 = new PointRef(_p110);

        public string Tag { get; set; }

        public Facet(HalfEdge head, string color = "RGBColor[1,1,1]")
        {
            Head = head;
            Expr c = ML[color].Eval();
            if (c.Head != MathConstants.ColorHead)
                throw new ArgumentException("argument 'color' does not resolve into a Mathematica color");
            Color = c;
        }

        public bool Convex
        {
            get
            {
                Console.WriteLine("Assuming this facet is convex.");
                return true;
            }
        }

        public Expr Color { get; set; }

        public HalfEdge Head { get; set; }

        public Plane Plane
        {
            get { return Head.Plane; }
        }

        public void ForceHalfEdgesToReferenceThis()
        {
            foreach (var he in HalfEdges)
            {
                he.Facet = this;
            }
        }

        public IEnumerable<HalfEdge> HalfEdges
        {
            get { return Head.HEsFromHere; }
        }

        public HalfEdge[] HalfEdgeArray
        {
            get { return HalfEdges.ToArray(); }
        }

        public Expr Graphics
        {
            get
            {
                return ML["List"].Bracket(
                    ML["List"].Bracket(
                        Color,
                        PolyPrimitive
                        ).Eval()
                    ).Eval();
            }
        }

        private Expr PolyPrimitive
        {
            get
            {
                return ML["Polygon"].Bracket(
                    ML["List"].Bracket(
                        HalfEdges.Select(he => he.Start.Expr)
                        ).Eval()
                    ).Eval();
            }
        }

        public Expr Highlight
        {
            get
            {
                return ML["List"].Bracket(
                    ML["List"].Bracket(
                        ML["Glow[Yellow]"].Eval(),
                        PolyPrimitive
                        ).Eval()
                    ).Eval();
            }
        }

        public IEnumerable<PointRef> PointRefs
        {
            get { return HalfEdges.Select(he => he.Start); }
        }

        public PointRef[] PointRefArray
        {
            get { return PointRefs.ToArray(); }
        }

        public Expr Points
        {
            get { return ML["List"].Bracket(PointRefs.Select(p => p.Expr)).Eval(); }
        }

        //Static methods

        public static Facet TestQuad
        {
            get
            {
                var a = new HalfEdge(PointRef.OriginRef, PointRef.Ref100);
                var b = new HalfEdge(a.End, _ref110);
                var c = new HalfEdge(b.End, PointRef.Ref010);
                var d = new HalfEdge(c.End, a.Start);

                a.LinkNext(b);
                b.LinkNext(c);
                c.LinkNext(d);
                d.LinkNext(a);

                return new Facet(a);
            }
        }

        public Facet CloneWithAllHalfEdgesCloned
        {
            get
            {

                return new Facet(Head.FacetRingClone, Color.ToString());
            }
        }

        public Facet SubDivide(PointRef v1, PointRef v2)
        {

            HalfEdge he1 = HalfEdges.First(he => he.Start == v1);
            HalfEdge he2 = HalfEdges.First(he => he.Start == v2);
            HalfEdge he2P = he2.Prev;

            HalfEdge[] newHes = he1.Prev.DetourToVertex(v2);

            newHes[0].LinkNext(he2);
            he2P.LinkNext(newHes[1]);
            newHes[1].LinkNext(he1);

            var facet = new Facet(newHes[0]);

            foreach (HalfEdge halfEdge in newHes[0].HEsFromHere)
            {
                halfEdge.Facet = facet;
            }

            return new Facet(newHes[0]);
        }

        public IEnumerable<Facet> Triangulate()
        {
            Console.WriteLine("Triangulating!");
            return HalfEdges.Skip(3)
                            .Select(he => he.Start).ToList()
                            .Select(vert => SubDivide(vert, Head.End));
        }

        public bool CheckIntersectSlow(EndPointPacket p)
        {
            //Console.WriteLine("c1");
            Expr t = FindIntersectSlow(p);
            //Console.WriteLine("c2");
            if (t == null)
                return false;
            Expr point = ML["{0}*{1} + (1-{0})*{2}"].Format(t, p.StartRef.Expr, p.EndRef.Expr).Eval();
            //Console.WriteLine("c3");
            Expr cp =
                ML["Cross[{1} - {0},{2} - {0}]"].Format(point, PointRefs.Last().Expr, PointRefs.First().Expr).Eval();
            //Console.WriteLine("c4");
            return !PointRefs.CirclularPairs()
                        //.Print(any => "c5")
                             .Select(
                                 pair =>
                                 ML["Cross[{1} - {0},{2} - {0}]"].Format(point, pair.Item1.Expr, pair.Item2.Expr)
                                                                 .Eval())
                        //.Print(any => "c6")
                             .Any(crossProduct => (bool) ML["Dot[{0},{1}] <= 0"].Format(cp, crossProduct).EvalObject());
        }

        private Expr FindIntersectSlow(EndPointPacket p)
        {
            //Console.WriteLine("f1");
            Expr tNum =
                ML["Dot[{0},{1}] - Dot[{2},{1}]"].Format(p.EndRef.Expr, Plane.Normal, Plane.Point)
                                                 .FullSimplify()
                                                 .Eval();
            //Console.WriteLine("f2");
            Expr tDenom =
                ML["Dot[{0}.{1}] - Dot[{1}.{2}]"].Format(p.EndRef.Expr, Plane.Normal, p.StartRef.Expr)
                                                 .FullSimplify()
                                                 .Eval();
            //Console.WriteLine("f3");
            if ((bool) ML["{0} == 0"].Format(tDenom).FullSimplify().EvalObject())
            {
                //Console.WriteLine("f4a");
                //Either on plane or parallel
                if ((bool) ML["{0} == 0"].Format(tNum).FullSimplify().EvalObject())
                {
                    return "(1/2)".MsEvalWith();
                }
                return null;
            }
            //Console.WriteLine("f4b");
            Expr q = ML["{0}/{1}"].Format(tNum, tDenom).FullSimplify().Eval();
            // Console.WriteLine("f5b");
            return ((bool) ML["{0} > 0 && {0} < 1"].Format(q).FullSimplify().EvalObject())
                       ? q
                       : null;
        }

        public bool CheckIntersectSlow(Facet f)
        {
            if (PlaneCheck(f))
            {
                return false;
            }
            return HalfEdges.Any(he => f.CheckIntersectSlow(he.EndPointPacket));
        }

        private bool PlaneCheck(Facet f)
        {
            Expr normal = Plane.Normal;

            bool pointsInFront = false;
            bool pointsInBack = false;

            Expr headPt = Head.Start.Expr;

            foreach (Expr vector in f.PointRefs
                                     .Select(pr => pr.Expr)
                                     .Select(p =>
                                             ML["{0} - {1}"].Format(p, headPt).Eval()))
            {
                Expr dot = ML["Dot"].Bracket(vector, normal).FullSimplify().Eval();
                if ((bool) ML["{0} > 0"].Format(dot).EvalObject())
                {
                    pointsInFront = true;
                }
                if ((bool) ML["{0} < 0"].Format(dot).EvalObject())
                {
                    pointsInBack = true;
                }
                if (pointsInBack && pointsInFront)
                {
                    return false;
                }
            }
            return true;
        }

        public Expr Midpoint
        {
            get { return ML["Mean"].Bracket(Points).Eval(); }
        }

        public Expr InsetLabel(int labelNumber)
        {
            var labelpoint = ML["{0} + .1*{1}"].Format(Midpoint, Plane.Normal).Eval();
            return ML["Inset"].Bracket(labelNumber, labelpoint).Eval();
        }

        public Expr ClipLabel(int labelNumber)
        {
            return ML["Text"].Bracket(labelNumber, Midpoint).Eval();
        }

        public Expr HELabelsStartingFrom(int startFrom)
        {
            var labels = Enumerable.Range(startFrom, int.MaxValue).NetZip(HalfEdges, (i, h) => h.Label(i));
            return
                ML["List"].Bracket
                (
                    ML["List"]
                        .Bracket(labels)
                        .Eval()
                ).Eval();
        }

        public Expr HELabels
        {
            get { return HELabelsStartingFrom(1); }
        }

        public HalfEdge PickHalfEdge(int i)
        {
            return HalfEdges.Skip(i - 1).First();
        }

        public Expr Normal
        {
            get { return Plane.Normal; }
        }

        public Expr NormalGraphics
        {
            get
            {
                return ML["List[ {{Purple, Arrow[ {{ {0}, {0} + .5*{1} }} ] }} ]"].Format(Midpoint, Normal).Eval();
            }
        }

        public Expr HEHighlights
        {
            get
            {
                return ML["List"].Bracket(
                    ML["List"].Bracket(HalfEdges.Select(he => he.Highlight)).Eval()
                    ).Eval();
            }
        }
    }
}