Пример #1
0
        public clsLine TangentToPointUp(clsPoint pt1)
        {
            //Goes on a transition up
            double  a;
            double  x;
            clsLine l1 = new clsLine();

            if (pt1.X < Centre.X + mdlGeometry.myTol)
            {
                return(null);
            }
            a = Atan((pt1.Y - Centre.Y) / Abs((pt1.X - Centre.X)));
            x = Radius / pt1.Dist(Centre);
            if (x >= 1)
            {
                return(null);
            }

            a       = a - Acos(x);
            l1.P1.X = Centre.X + Radius * Cos(a);
            l1.P1.Y = Centre.Y + Radius * Sin(a);
            l1.P2.X = pt1.X;
            l1.P2.Y = pt1.Y;
            return(l1);
        }
Пример #2
0
        static int GetSquareForDatum(ARParam arParams, double[,] model, clsPoint pt)
        {
            var cpt = ModelToImageSpace(arParams, model, pt);
            var pt1 = ModelToImageSpace(arParams, model, new clsPoint(pt.x - 8, pt.y - 8));
            var pt2 = ModelToImageSpace(arParams, model, new clsPoint(pt.x + 8, pt.y - 8));
            var pt3 = ModelToImageSpace(arParams, model, new clsPoint(pt.x + 8, pt.y + 8));
            var pt4 = ModelToImageSpace(arParams, model, new clsPoint(pt.x - 8, pt.y + 8));
            var l1  = new clsLine(pt1, pt2);
            var l2  = new clsLine(pt2, pt3);
            var l3  = new clsLine(pt3, pt4);
            var l4  = new clsLine(pt4, pt1);

            double d  = 100;
            var    l  = new clsLine(cpt, new clsPoint(cpt.x - 1, cpt.y - 1));
            var    p1 = l.Intersect(l1);

            if (p1 != null && p1.Dist(cpt) < d)
            {
                d = p1.Dist(cpt);
            }
            p1 = l.Intersect(l2);
            if (p1 != null && p1.Dist(cpt) < d)
            {
                d = p1.Dist(cpt);
            }
            p1 = l.Intersect(l3);
            if (p1 != null && p1.Dist(cpt) < d)
            {
                d = p1.Dist(cpt);
            }
            p1 = l.Intersect(l4);
            if (p1 != null && p1.Dist(cpt) < d)
            {
                d = p1.Dist(cpt);
            }

            l  = new clsLine(cpt, new clsPoint(cpt.x + 1, cpt.y - 1));
            p1 = l.Intersect(l1);
            if (p1 != null && p1.Dist(cpt) < d)
            {
                d = p1.Dist(cpt);
            }
            p1 = l.Intersect(l2);
            if (p1 != null && p1.Dist(cpt) < d)
            {
                d = p1.Dist(cpt);
            }
            p1 = l.Intersect(l3);
            if (p1 != null && p1.Dist(cpt) < d)
            {
                d = p1.Dist(cpt);
            }
            p1 = l.Intersect(l4);
            if (p1 != null && p1.Dist(cpt) < d)
            {
                d = p1.Dist(cpt);
            }

            return((int)(d / Sqrt(2.0) + 0.5));
        }
Пример #3
0
        public bool IsOnShortLine(clsPoint pt1, double aTol = 0, bool excludeEnds = false)
        {
            clsLine l1 = default(clsLine);
            clsLine l2 = default(clsLine);
            double  d  = 0;

            if (aTol == 0)
            {
                aTol = mdlGeometry.myTol;
            }
            if (Abs(pt1.Dist(this)) > aTol)
            {
                return(false);
            }
            l1 = new clsLine(P1, pt1);
            l2 = Copy();
            l2.Normalise();
            d = l1.Dot(l2);
            if (d < -aTol)
            {
                return(false);
            }
            if (d > Length + aTol)
            {
                return(false);
            }
            if (excludeEnds && (P1 == pt1 | P2 == pt1))
            {
                return(false);
            }
            return(true);
        }
Пример #4
0
        public double DistanceToNearestSegment(clsPoint p1, ref int nSeg, ref int nPt, int avoidPt1 = -1, int avoidPt2 = -1, int includePt = -1)
        {
            int     i;
            int     j;
            clsLine l1;
            double  d;
            double  minD;

            //Find the point nearest
            nPt = GetNearestPointIndex(p1);

            //Find the segment closest to the point to add (ignore riser segments)
            nSeg = 0;
            minD = 10000;
            for (i = 0; i <= NumPoints; i++)
            {
                if ((i != avoidPt1 & i != avoidPt2) & (includePt == -1 || (i == includePt | i == includePt - 1 | (includePt == 0 & i == NumPoints))))
                {
                    j = i + 1;
                    if (j > NumPoints)
                    {
                        j = 0;
                    }
                    l1 = new clsLine(Point(i), Point(j));
                    d  = l1.DistanceToShortLine(p1);
                    if (d < minD)
                    {
                        minD = d;
                        nSeg = i;
                    }
                }
            }
            return(minD);
        }
Пример #5
0
 //Moves the line
 public void Move(clsLine l2)
 {
     X1 = X1 + l2.DX();
     X2 = X2 + l2.DX();
     Y1 = Y1 + l2.DY();
     Y2 = Y2 + l2.DY();
 }
Пример #6
0
        public bool IsPointInside(clsPoint p1)
        {
            //Uses the "winding number" to check if a point lies inside or outside the sketch
            int     i;
            double  a;
            double  a1;
            clsLine l1;
            clsLine l2;

            a  = 0;
            l1 = new clsLine(p1, Point(0));
            for (i = 1; i <= myPoints.Count - 1; i++)
            {
                l2 = new clsLine(p1, Point(i));
                a1 = mdlGeometry.Angle(l1, l2);
                a  = a + a1;
                l1 = l2.Copy();
            }
            l2 = new clsLine(p1, Point(0));
            a1 = mdlGeometry.Angle(l1, l2);
            a  = a + a1;
            if (mdlGeometry.IsSameDbl(a, 0))
            {
                return(false);
            }
            return(true);
        }
Пример #7
0
        public clsPoint PointFromLambda(double l)
        {
            clsLine l1 = default(clsLine);

            l1 = Copy();
            l1.Scale(l);
            return(l1.P2);
        }
Пример #8
0
        public clsPoint DistanceAlongLine(double d)
        {
            clsLine l1 = default(clsLine);

            l1 = Copy();
            l1.Normalise();
            return(new clsPoint(X1 + d * l1.DX(), Y1 + d * l1.DY()));
        }
Пример #9
0
        public double Dist(clsLine l1)
        {
            clsLine l2 = default(clsLine);
            clsLine l3 = default(clsLine);

            l2 = l1.Normal();
            l3 = new clsLine(l1.P1, this);
            return(Abs(l2.Dot(l3)));
        }
Пример #10
0
 public clsPoint IntersectShortLines(clsLine l1)
 {
     //Both truncated
     if (IntersectShortLine1(l1) == null)
     {
         return(null);
     }
     return(IntersectShortLine2(l1));
 }
Пример #11
0
 public bool IsSame(clsLine l1)
 {
     //Is this line the same as another (up to orientation)?
     if ((P1 == l1.P1 & P2 == l1.P2) | (P1 == l1.P2 & P2 == l1.P1))
     {
         return(true);
     }
     return(false);
 }
Пример #12
0
        public static double Dist(clsPoint p1, clsLine l1)
        {
            //+ve for outside the wall, left handed; Also, +ve for above straight.
            clsLine l2 = new clsLine();
            clsLine l3 = new clsLine();

            l2 = (clsLine)l1.Normal();
            l3 = new clsLine(l1.P1, p1);

            return(l2.Dot(l3));
        }
Пример #13
0
        public clsLine Normal()
        {
            clsLine functionReturnValue = default(clsLine);
            //Special routine to help with finding "signed" distance of points to lines
            double theta = 0;

            theta = Angle;
            functionReturnValue = new clsLine(0, 0, 0, 1);
            functionReturnValue.Rotate(Angle);
            return(functionReturnValue);
        }
Пример #14
0
        public clsPoint IntersectQuick(clsLine l1)
        {
            //Both infinite
            double lambda = 0;

            if (Abs((X2 - X1) * (l1.Y1 - l1.Y2) + (Y2 - Y1) * (l1.X2 - l1.X1)) < mdlGeometry.myTol / 10)
            {
                return(null);
            }
            //No intersection

            lambda = ((l1.X2 - X1) * (l1.Y1 - l1.Y2) + (l1.Y2 - Y1) * (l1.X2 - l1.X1)) / ((X2 - X1) * (l1.Y1 - l1.Y2) + (Y2 - Y1) * (l1.X2 - l1.X1));
            return(new clsPoint(X1 + lambda * (X2 - X1), Y1 + lambda * (Y2 - Y1)));
        }
Пример #15
0
        public static clsPoint ProjectPoint(clsPoint p1, clsLine l1)
        {
            double   d   = 0;
            clsPoint pt1 = new clsPoint();
            clsLine  l2  = new clsLine();

            d   = Dist(p1, l1);
            pt1 = p1.Copy();
            l2  = (clsLine)l1.Normal();
            l2.Normalise();
            l2.Scale(-d);
            pt1.Move(l2.P2.X, l2.P2.Y);
            return(pt1);
        }
Пример #16
0
        public clsPoint FilletPoint()
        {
            clsLine  l1;
            clsLine  l2;
            clsPoint p1;
            clsPoint p2;

            p1 = StartPoint();
            p2 = Tangent(Angle1);
            l1 = new clsLine(p1.X, p1.Y, p1.X + p2.X, p1.Y + p2.Y);
            p1 = EndPoint();
            p2 = Tangent(Angle2);
            l2 = new clsLine(p1.X, p1.Y, p1.X + p2.X, p1.Y + p2.Y);
            return(l1.Intersect(l2));
        }
Пример #17
0
        public List <clsPoint> Intersect(clsLine l1, bool sortByDistToL1P1 = false)
        {
            List <clsPoint> myPts = new List <clsPoint>();
            int             i;
            int             j;
            clsLine         l2;
            clsPoint        p1;
            double          d1;
            double          d2;

            for (i = 0; i <= NumPoints; i++)
            {
                j = i + 1;
                if (j > NumPoints)
                {
                    j = 0;
                }
                l2 = new clsLine(Point(i), Point(j));
                p1 = l1.IntersectShortLine1(l2);
                if (p1 != null)
                {
                    myPts.Add(p1);
                }
            }

            if (sortByDistToL1P1)
            {
                for (i = 0; i <= myPts.Count - 2; i++)
                {
                    d1 = myPts[i].Dist(l1.P1);
                    for (j = i + 1; j <= myPts.Count - 1; j++)
                    {
                        d2 = myPts[j].Dist(l1.P1);
                        if (d2 < d1)
                        {
                            p1       = myPts[i];
                            myPts[i] = myPts[j];
                            myPts[j] = p1;
                        }
                    }
                }
            }

            return(myPts);
        }
Пример #18
0
        public clsPoint IntersectShortLine1(clsLine l1)
        {
            //Leaves Me as infinite, but truncates l1
            double   l   = 0;
            clsPoint pt1 = default(clsPoint);

            pt1 = Intersect(l1);
            if (pt1 == null)
            {
                return(null);
            }
            l = l1.Lambda(pt1);
            if (l < 0 | l > 1)
            {
                return(null);
            }
            return(pt1);
        }
Пример #19
0
        public clsPoint IntersectShortLine2(clsLine l1)
        {
            //Truncates Me but leaves l1 infinite
            double   l   = 0;
            clsPoint pt1 = default(clsPoint);

            pt1 = Intersect(l1);
            if (pt1 == null)
            {
                return(null);
            }
            l = Lambda(pt1);
            if (l < 0 | l > 1)
            {
                return(null);
            }
            return(pt1);
        }
Пример #20
0
        public clsLine TangentToPoint(clsPoint pt1)
        {
            double  a;
            double  x;
            clsLine l1 = new clsLine();

            if (pt1.X == Centre.X)
            {
                if (pt1.Y > Centre.Y)
                {
                    a = PI / 2;
                }
                else
                {
                    a = 3 * PI / 2;
                }
            }
            else
            {
                a = Atan((pt1.Y - Centre.Y) / Abs((pt1.X - Centre.X)));
                if (pt1.X > Centre.X)
                {
                    a = PI - a;
                }
            }
            x = Radius / pt1.Dist(Centre);
            if (x >= 1)
            {
                return(null);
            }

            a       = a - (Atan(-x / Sqrt(-x * x + 1)) + 2 * Atan(1));
            l1.P1.X = Centre.X - Radius * Cos(a);
            l1.P1.Y = Centre.Y + Radius * Sin(a);
            l1.P2.X = pt1.X;
            l1.P2.Y = pt1.Y;
            //l1.p2.y = l1.p1.y - (pt1.x - l1.p1.x) * Tan((180 - a) * Pi / 180)
            Angle2 = a;
            return(l1);
        }
Пример #21
0
        public static clsLine LinePointToTangent(clsPoint p1, clsCircle c1)
        {
            double   a  = 0;
            double   b  = 0;
            double   r  = 0;
            double   d  = 0;
            clsLine  l1 = new clsLine();
            clsPoint p2 = new clsPoint();

            r = c1.Radius;
            d = p1.Dist(c1.Centre);
            if (d < r)
            {
                return(null);
            }
            a  = Asin(r / d);
            l1 = new clsLine(p1, c1.Centre);
            b  = l1.Angle;

            p2 = c1.Point(PI / 2 + a + b);
            return(new clsLine(p1, p2));
        }
Пример #22
0
        public clsLine TangentToPointDown(clsPoint pt1)
        {
            //Goes on the downside of a transition down
            double  a;
            double  x;
            clsLine l1;

            if (pt1.x > Centre.x - mdlGeometry.myTol)
            {
                return(null);
            }
            a = Atan((Centre.y - pt1.y) / Abs((Centre.x - pt1.x)));
            x = Radius / pt1.Dist(Centre);
            if (x >= 1)
            {
                return(null);
            }

            a  = Acos(x) - a;
            l1 = new clsLine(pt1.Copy(), new clsPoint(Centre.x - Radius * Cos(a), Centre.y + Radius * Sin(a)));
            return(l1);
        }
Пример #23
0
        public bool Overlaps(clsLine aLine, double aTol = 0)
        {
            clsLine  l1 = default(clsLine);
            clsPoint p3 = default(clsPoint);
            clsPoint p4 = default(clsPoint);

            if (aTol == 0)
            {
                aTol = mdlGeometry.myTol;
            }
            l1 = aLine.Copy();
            if ((!IsOnLine(l1.P1, aTol)) | (!IsOnLine(l1.P2, aTol)))
            {
                return(false);
            }
            if (Dot(l1) < 0)
            {
                l1.Reverse();
            }
            p3 = l1.P1;
            p4 = l1.P2;
            if (P1 == p3)
            {
                return(true);
            }
            if (P1 == p4 | P2 == p3)
            {
                return(false);
            }
            if (IsOnShortLine(p4, aTol))
            {
                return(true);
            }
            if (l1.IsOnShortLine(P1, aTol) | l1.IsOnShortLine(P2, aTol))
            {
                return(true);
            }
            return(false);
        }
Пример #24
0
        public bool SelfIntersects()
        {
            int     i;
            int     i1;
            int     j;
            int     j1;
            int     n;
            clsLine l1;
            clsLine l2;

            for (i = 0; i <= NumPoints - 2; i++)
            {
                i1 = i + 1;
                l1 = new clsLine(Point(i), Point(i1));

                n = NumPoints;
                if (i == 0)
                {
                    n = n - 1;
                }
                //Don't need to intersect the first line with the last, because they touch
                for (j = i + 2; j <= n; j++)
                {
                    j1 = j + 1;
                    if (j1 > NumPoints)
                    {
                        j1 = 0;
                    }
                    l2 = new clsLine(Point(j), Point(j1));

                    if (l1.IntersectShortLines(l2) != null)
                    {
                        return(true);
                    }
                }
            }
            return(false);
        }
Пример #25
0
        public clsPoint Intersect(clsLine l1, bool getSecond = false)
        {
            double a       = 0;
            double b       = 0;
            double c       = 0;
            double xc      = 0;
            double yc      = 0;
            double lambda1 = 0;
            double lambda2 = 0;

            if (mdlGeometry.Dist(Centre, l1) > Radius)
            {
                return(null);
            }
            xc = Centre.x;
            yc = Centre.y;

            a       = Pow((l1.X2 - l1.X1), 2) + Pow((l1.Y2 - l1.Y1), 2);
            b       = 2 * ((l1.X2 - l1.X1) * (l1.X1 - xc) + (l1.Y2 - l1.Y1) * (l1.Y1 - yc));
            c       = Pow((l1.X1 - xc), 2) + Pow((l1.Y1 - yc), 2) - Pow((Radius), 2);
            lambda1 = (-b + Sqrt(Abs(Pow(b, 2) - 4 * a * c))) / (2 * a);
            lambda2 = (-b - Sqrt(Abs(Pow(b, 2) - 4 * a * c))) / (2 * a);
            if (getSecond == false)
            {
                if (lambda2 < lambda1 & lambda2 > 0)
                {
                    lambda1 = lambda2;
                }
            }
            else
            {
                if (lambda1 < lambda2)
                {
                    lambda1 = lambda2;
                }
            }
            return(new clsPoint(l1.X1 + lambda1 * (l1.X2 - l1.X1), l1.Y1 + lambda1 * (l1.Y2 - l1.Y1)));
        }
Пример #26
0
        public double VerticalHeight(clsPoint pt1)
        {
            //Returns the height of the line where is passes over p1
            clsLine l1 = default(clsLine);
            clsLine l2 = default(clsLine);
            double  d  = 0;
            double  d1 = 0;
            double  d2 = 0;

            l1 = new clsLine(P1.X, P1.Y, P2.X, P2.Y);
            if (l1.IsOnLine(pt1) == false)
            {
                return(0);
            }

            d1 = l1.Length;
            l1.Normalise();

            l2 = new clsLine(l1.P1, pt1);
            d2 = l1.Dot(l2);
            d  = d2 / d1;
            return(P1.Z + (P2.Z - P1.Z) * d);
        }
Пример #27
0
        public clsPoint Intersect(clsLine l1)
        {
            //Limits the intersection to the arc
            clsPoint aPt;

            aPt = base.Intersect(l1);
            if (aPt == null)
            {
                return(null);
            }
            if (PointLiesOnArc(aPt) == false)
            {
                aPt = base.Intersect(l1, true);
                if (aPt == null)
                {
                    return(null);
                }
                if (PointLiesOnArc(aPt) == false)
                {
                    return(null);
                }
            }
            return(aPt);
        }
Пример #28
0
        public clsPoint Intersect(clsCircle c1, bool firstSolution)
        {
            double  a  = 0;
            clsLine l1 = default(clsLine);

            if (mdlGeometry.Dist(Centre, c1.Centre) > Radius + c1.Radius)
            {
                return(null);
            }
            if (mdlGeometry.Dist(Centre, c1.Centre) < Abs(Radius - c1.Radius))
            {
                return(null);
            }
            l1 = new clsLine(Centre.Copy(), c1.Centre.Copy());
            a  = Acos((Radius * Radius + l1.Length * l1.Length - c1.Radius * c1.Radius) / (2 * Radius * l1.Length));
            //Cosine rule
            if (firstSolution == false)
            {
                a = -a;
            }
            l1.Rotate(a);
            l1.Length = Radius;
            return(l1.P2);
        }
Пример #29
0
        //Public Function IntersectShortLine1(ByVal l1 As clsLine) As clsPoint  'Leaves Me as infinite, but truncates l1
        //    Dim lambda As Double

        //    If Abs((l1.X2 - l1.X1) * (Y1 - Y2) + (l1.Y2 - l1.Y1) * (X2 - X1)) < mdlGeometry.myTol Then Return Nothing 'No intersection
        //    lambda = ((X2 - l1.X1) * (Y1 - Y2) + (Y2 - l1.Y1) * (X2 - X1)) / ((l1.X2 - l1.X1) * (Y1 - Y2) + (l1.Y2 - l1.Y1) * (X2 - X1))
        //    If lambda < 0 Or lambda > 1 Then Return Nothing
        //    Return New clsPoint(l1.X1 + lambda * (l1.X2 - l1.X1), l1.Y1 + lambda * (l1.Y2 - l1.Y1))
        //End Function

        //Public Function IntersectShortLine2(ByVal l1 As clsLine) As clsPoint 'Truncates Me but leaves l1 infinite
        //    Dim lambda As Double

        //    If Abs((X2 - X1) * (l1.Y1 - l1.Y2) + (Y2 - Y1) * (l1.X2 - l1.X1)) < mdlGeometry.myTol Then Return Nothing 'No intersection
        //    lambda = ((l1.X2 - X1) * (l1.Y1 - l1.Y2) + (l1.Y2 - Y1) * (l1.X2 - l1.X1)) / ((X2 - X1) * (l1.Y1 - l1.Y2) + (Y2 - Y1) * (l1.X2 - l1.X1))
        //    If lambda < 0 Or lambda > 1 Then Return Nothing
        //    Return New clsPoint(X1 + lambda * (X2 - X1), Y1 + lambda * (Y2 - Y1))
        //End Function

        public clsPoint Intersect(clsLine l1)
        {
            //Both infinite. More accurate that IntersectQuick
            double  l  = 0;
            clsLine l2 = default(clsLine);
            clsLine l3 = default(clsLine);

            if (Length < mdlGeometry.myTol | l1.Length < mdlGeometry.myTol)
            {
                return(null);
            }
            l2        = Copy();
            l3        = l1.Copy();
            l2.Length = 1000;
            l3.Length = 1000;

            if (Abs(((l2.X2 - l2.X1) * (l3.Y1 - l3.Y2) + (l2.Y2 - l2.Y1) * (l3.X2 - l3.X1))) < mdlGeometry.myTol / 10)
            {
                return(null);
            }
            //No intersection
            l = ((l3.X2 - l2.X1) * (l3.Y1 - l3.Y2) + (l3.Y2 - l2.Y1) * (l3.X2 - l3.X1)) / ((l2.X2 - l2.X1) * (l3.Y1 - l3.Y2) + (l2.Y2 - l2.Y1) * (l3.X2 - l3.X1));
            return(new clsPoint(l2.X1 + l * (l2.X2 - l2.X1), l2.Y1 + l * (l2.Y2 - l2.Y1)));
        }
Пример #30
0
        public bool IsOnHalfLine(clsPoint pt1, double aTol = 0)
        {
            clsLine l1 = default(clsLine);
            clsLine l2 = default(clsLine);
            double  d  = 0;

            if (aTol == 0)
            {
                aTol = mdlGeometry.myTol;
            }
            if (Abs(pt1.Dist(this)) > aTol)
            {
                return(false);
            }
            l1 = new clsLine(P1, pt1);
            l2 = Copy();
            l2.Normalise();
            d = l1.Dot(l2);
            if (d < -aTol)
            {
                return(false);
            }
            return(true);
        }