using System;

using System.Collections.Generic;

using System.Threading.Tasks;

using System.Windows.Forms;

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

​

namespace placePillars.Place_Cables

{

    class CableIntersects

    {

        public static (Line, ObjectId) IntersectingCables(Document doc, Editor ed, Database db, List<Line> lineList, Line innerLine, Line outerLine)

        {

            //Assume the line is correct, ie y2-y

            bool innerbackwars = false;

            bool outerbackwars = false;

            bool linebackwards = false;

            Double mBoundary;

            Double bBoundary;

            Double mInner;

            Double mOuter;

            bool inner = false;

            bool outer = false;

            double tolerance = 0.001;

            List<Line> newCable = new List<Line>();

            ObjectId cableIntersect = new ObjectId();

            //Check where the start point is in regards to the end point

            if (innerLine.EndPoint.X - innerLine.StartPoint.X < 0)

            {

                //start point is after end point

                innerbackwars = true;

            }

​

            if (outerLine.EndPoint.X - outerLine.StartPoint.X < 0)

            {

                outerbackwars = true;

            }

​

            //Workout gradient of unchanging lines

            if (innerbackwars == false)

            {

                mInner = (innerLine.EndPoint.Y - innerLine.StartPoint.Y) / (innerLine.EndPoint.X - innerLine.StartPoint.X);

            }

            else

            {

                mInner = (innerLine.StartPoint.Y - innerLine.EndPoint.Y) / (innerLine.StartPoint.X - innerLine.EndPoint.X);

                ;

            }

​

            if (outerbackwars == false)

            {

                mOuter = (outerLine.EndPoint.Y - outerLine.StartPoint.Y) / (outerLine.EndPoint.X - outerLine.StartPoint.X);

            }

            else

            {

                mOuter = (outerLine.StartPoint.Y - outerLine.EndPoint.Y) / (outerLine.StartPoint.X - outerLine.EndPoint.X);

            }

​

            //Workout y axis intersect (where x=0)

            Double bInner = innerLine.StartPoint.Y - mInner * innerLine.StartPoint.X;

            Double bOuter = outerLine.StartPoint.Y - mOuter * outerLine.StartPoint.X;

            try

            {

                using (DocumentLock acLckDoc = doc.LockDocument())

                {

                    using (Transaction acTrans = db.TransactionManager.StartTransaction())

                    {

                        //Check for parallel lines first

                        Parallel.ForEach(lineList, (lineRecord) =>

                        //foreach(Line lineRecord in lineList)

                        {

                            if (lineRecord.EndPoint.X - lineRecord.StartPoint.X < 0)

                            {

                                //start point is after end point

                                linebackwards = true;

                            }

​

                            //Workout gradients of the lines

                            if (linebackwards == false)

                            {

                                mBoundary = (lineRecord.EndPoint.Y - lineRecord.StartPoint.Y) / (lineRecord.EndPoint.X - lineRecord.StartPoint.X);

                            }

                            else

                            {

                                mBoundary = (lineRecord.StartPoint.Y - lineRecord.EndPoint.Y) / (lineRecord.StartPoint.X - lineRecord.EndPoint.X);

                            }

​

                            bBoundary = lineRecord.StartPoint.Y - mBoundary * lineRecord.StartPoint.X;

                            //test to see if  innter out outer intersect

                            //Check to see if they are parallel to reduce calculations

                            //y=xm+b ---> xm+b=y=xm+b ---> x=x (move x to LHS) ---> x+x(-1)

                            var x = mBoundary + mInner * -1;

                            var b = bBoundary * -1 + bInner;

                            if (x <= tolerance && x >= -tolerance)

                                x = 0;

                            double x1 = (float)b / (float)x;

                            x = mBoundary + mOuter * -1;

                            b = bBoundary * -1 + bOuter;

                            if (x <= tolerance && x >= -tolerance)

                                x = 0;

                            double x2 = (float)b / (float)x;

                            //If X1 is the intercept line then we want to look at ir whilst X2 = inf

                            if (!double.IsInfinity(x1) && double.IsInfinity(x2))

                            {

                                //Dont know if line start or end comes first on x axis so work it out based on line length from x=0

                                if (innerbackwars == true)

                                {

                                    if (x1 < innerLine.StartPoint.X && x1 > innerLine.EndPoint.X)

                                    {

                                        //if inner line intercepts then we want the outer as our cable

                                        outer = true;

                                    }

                                }

​

                                if (innerbackwars == false)

                                {

                                    if (x1 > innerLine.StartPoint.X && x1 < innerLine.EndPoint.X)

                                    {

                                        outer = true;

                                    }

                                }

                            //if (inner == true && outer == false) break;

                            }

​

                            //Now see if outer cable intersects

                            if (double.IsInfinity(x1) && !double.IsInfinity(x2))

                            {

                                //Dont know if line start or end comes first on x axis so work it out based on line length from x=0

                                if (outerbackwars == false)

                                {

                                    if (x2 < outerLine.StartPoint.X && x2 > outerLine.EndPoint.X)

                                    {

                                        inner = true;

                                    }

                                }

​

                                if (outerbackwars == true)

                                {

                                    if (x2 > outerLine.StartPoint.X && x2 < outerLine.EndPoint.X)

                                    {

                                        inner = true;

                                    }

                                }

                            }

​

                            if ((inner == true && outer == false) || (inner == false && outer == true))

                            {

                                if (inner == true)

                                {

                                    newCable.Add(innerLine);

                                    cableIntersect = outerLine.ObjectId;

                                }

                                else

                                    newCable.Add(outerLine);

                                cableIntersect = innerLine.ObjectId;

                            }

                        }); //End of loop

                    }

                }

            }

            catch (System.Exception ex)

            {

                MessageBox.Show(ex.StackTrace);

                MessageBox.Show(ex.Source);

            }

​

            return (newCable[0], cableIntersect);

        }

    }

}