Example #1
0
        /********************************************************
         * To check whether 2 lines segments have an intersection
         *********************************************************/

        public bool IntersectedWith(CLineSegment line)
        {
            double x1 = this.m_startPoint.X;
            double y1 = this.m_startPoint.Y;
            double x2 = this.m_endPoint.X;
            double y2 = this.m_endPoint.Y;
            double x3 = line.m_startPoint.X;
            double y3 = line.m_startPoint.Y;
            double x4 = line.m_endPoint.X;
            double y4 = line.m_endPoint.Y;

            double de = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);

            //if de<>0 then //lines are not parallel
            if (Math.Abs(de - 0)
                < ConstantValue.SmallValue)             //not parallel
            {
                double ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / de;
                double ub = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / de;

                if ((ub > 0) &&
                    (ub < 1))
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
            else             //lines are parallel
            {
                return(false);
            }
        }
Example #2
0
        /***To check whether the point is in a line segment***/

        public bool InLine(CLineSegment lineSegment)
        {
            bool bInline = false;

            double Ax, Ay, Bx, By, Cx, Cy;

            Bx = lineSegment.EndPoint.X;
            By = lineSegment.EndPoint.Y;
            Ax = lineSegment.StartPoint.X;
            Ay = lineSegment.StartPoint.Y;
            Cx = this.m_dCoordinate_X;
            Cy = this.m_dCoordinate_Y;

            double L = lineSegment.GetLineSegmentLength();
            double s = Math.Abs(((Ay - Cy) * (Bx - Ax) - (Ax - Cx) * (By - Ay)) / (L * L));

            if (Math.Abs(s - 0)
                < ConstantValue.SmallValue)
            {
                if ((SamePoints(this, lineSegment.StartPoint)) ||
                    (SamePoints(this, lineSegment.EndPoint)))
                {
                    bInline = true;
                }
                else if ((Cx < lineSegment.GetXmax()) && (Cx > lineSegment.GetXmin()) && (Cy < lineSegment.GetYmax()) &&
                         (Cy > lineSegment.GetYmin()))
                {
                    bInline = true;
                }
            }
            return(bInline);
        }
Example #3
0
        /***Check whether this line is in a longer line***/

        public bool InLine(CLineSegment longerLineSegment)
        {
            bool bInLine = false;

            if ((m_startPoint.InLine(longerLineSegment)) &&
                (m_endPoint.InLine(longerLineSegment)))
            {
                bInLine = true;
            }
            return(bInLine);
        }
Example #4
0
        /**********************************************************
         * To check the Pt is in the Triangle or not.
         * If the Pt is in the line or is a vertex, then return true.
         * If the Pt is out of the Triangle, then return false.
         *
         * This method is used for triangle only.
         ***********************************************************/

        private bool TriangleContainsPoint(CPoint2D[] trianglePts, CPoint2D pt)
        {
            if (trianglePts.Length != 3)
            {
                return(false);
            }

            for (int i = trianglePts.GetLowerBound(0); i < trianglePts.GetUpperBound(0); i++)
            {
                if (pt.EqualsPoint(trianglePts[i]))
                {
                    return(true);
                }
            }

            bool bIn = false;

            CLineSegment line0 = new CLineSegment(trianglePts[0], trianglePts[1]);
            CLineSegment line1 = new CLineSegment(trianglePts[1], trianglePts[2]);
            CLineSegment line2 = new CLineSegment(trianglePts[2], trianglePts[0]);

            if (pt.InLine(line0) || pt.InLine(line1) ||
                pt.InLine(line2))
            {
                bIn = true;
            }
            else             //point is not in the lines
            {
                double dblArea0 = CPolygon.PolygonArea(new CPoint2D[] { trianglePts[0], trianglePts[1], pt });
                double dblArea1 = CPolygon.PolygonArea(new CPoint2D[] { trianglePts[1], trianglePts[2], pt });
                double dblArea2 = CPolygon.PolygonArea(new CPoint2D[] { trianglePts[2], trianglePts[0], pt });

                if (dblArea0 > 0)
                {
                    if ((dblArea1 > 0) &&
                        (dblArea2 > 0))
                    {
                        bIn = true;
                    }
                }
                else if (dblArea0 < 0)
                {
                    if ((dblArea1 < 0) &&
                        (dblArea2 < 0))
                    {
                        bIn = true;
                    }
                }
            }
            return(bIn);
        }
Example #5
0
        /************************************************
         * Offset the line segment to generate a new line segment
         * If the offset direction is along the x-axis or y-axis,
         * Parameter is true, other wise it is false
         * ***********************************************/
        public CLineSegment OffsetLine(double distance, bool rightOrDown)
        {
            //offset a line with a given distance, generate a new line
            //rightOrDown=true means offset to x incress direction,
            // if the line is horizontal, offset to y incress direction

            CLineSegment line;
            CPoint2D newStartPoint = new CPoint2D();
            CPoint2D newEndPoint = new CPoint2D();

            double alphaInRad = this.GetLineAngle(); // 0-PI
            if (rightOrDown) {
                if (this.HorizontalLine()) //offset to y+ direction
                {
                    newStartPoint.X = this.m_startPoint.X;
                    newStartPoint.Y = this.m_startPoint.Y + distance;

                    newEndPoint.X = this.m_endPoint.X;
                    newEndPoint.Y = this.m_endPoint.Y + distance;
                    line = new CLineSegment(newStartPoint, newEndPoint);
                }
                else //offset to x+ direction
                {
                    if (Math.Sin(alphaInRad) > 0) {
                        newStartPoint.X = m_startPoint.X + Math.Abs(distance*Math.Sin(alphaInRad));
                        newStartPoint.Y = m_startPoint.Y - Math.Abs(distance*Math.Cos(alphaInRad));

                        newEndPoint.X = m_endPoint.X + Math.Abs(distance*Math.Sin(alphaInRad));
                        newEndPoint.Y = m_endPoint.Y - Math.Abs(distance*Math.Cos(alphaInRad));

                        line = new CLineSegment(newStartPoint, newEndPoint);
                    }
                    else //sin(FalphaInRad)<0
                    {
                        newStartPoint.X = m_startPoint.X + Math.Abs(distance*Math.Sin(alphaInRad));
                        newStartPoint.Y = m_startPoint.Y + Math.Abs(distance*Math.Cos(alphaInRad));
                        newEndPoint.X = m_endPoint.X + Math.Abs(distance*Math.Sin(alphaInRad));
                        newEndPoint.Y = m_endPoint.Y + Math.Abs(distance*Math.Cos(alphaInRad));

                        line = new CLineSegment(newStartPoint, newEndPoint);
                    }
                }
            } //{rightOrDown}
            else //leftOrUp
            {
                if (this.HorizontalLine()) //offset to y directin
                {
                    newStartPoint.X = m_startPoint.X;
                    newStartPoint.Y = m_startPoint.Y - distance;

                    newEndPoint.X = m_endPoint.X;
                    newEndPoint.Y = m_endPoint.Y - distance;
                    line = new CLineSegment(newStartPoint, newEndPoint);
                }
                else //offset to x directin
                {
                    if (Math.Sin(alphaInRad) >= 0) {
                        newStartPoint.X = m_startPoint.X - Math.Abs(distance*Math.Sin(alphaInRad));
                        newStartPoint.Y = m_startPoint.Y + Math.Abs(distance*Math.Cos(alphaInRad));
                        newEndPoint.X = m_endPoint.X - Math.Abs(distance*Math.Sin(alphaInRad));
                        newEndPoint.Y = m_endPoint.Y + Math.Abs(distance*Math.Cos(alphaInRad));

                        line = new CLineSegment(newStartPoint, newEndPoint);
                    }
                    else //sin(FalphaInRad)<0
                    {
                        newStartPoint.X = m_startPoint.X - Math.Abs(distance*Math.Sin(alphaInRad));
                        newStartPoint.Y = m_startPoint.Y - Math.Abs(distance*Math.Cos(alphaInRad));
                        newEndPoint.X = m_endPoint.X - Math.Abs(distance*Math.Sin(alphaInRad));
                        newEndPoint.Y = m_endPoint.Y - Math.Abs(distance*Math.Cos(alphaInRad));

                        line = new CLineSegment(newStartPoint, newEndPoint);
                    }
                }
            }
            return line;
        }
Example #6
0
        /********************************************************
        To check whether 2 lines segments have an intersection
        *********************************************************/
        public bool IntersectedWith(CLineSegment line)
        {
            double x1 = this.m_startPoint.X;
            double y1 = this.m_startPoint.Y;
            double x2 = this.m_endPoint.X;
            double y2 = this.m_endPoint.Y;
            double x3 = line.m_startPoint.X;
            double y3 = line.m_startPoint.Y;
            double x4 = line.m_endPoint.X;
            double y4 = line.m_endPoint.Y;

            double de = (y4 - y3)*(x2 - x1) - (x4 - x3)*(y2 - y1);
            //if de<>0 then //lines are not parallel
            if (Math.Abs(de - 0)
                < ConstantValue.SmallValue) //not parallel
            {
                double ua = ((x4 - x3)*(y1 - y3) - (y4 - y3)*(x1 - x3))/de;
                double ub = ((x2 - x1)*(y1 - y3) - (y2 - y1)*(x1 - x3))/de;

                if ((ub > 0)
                    && (ub < 1)) {
                    return true;
                }
                else {
                    return false;
                }
            }
            else //lines are parallel
            {
                return false;
            }
        }
Example #7
0
 /***Check whether this line is in a longer line***/
 public bool InLine(CLineSegment longerLineSegment)
 {
     bool bInLine = false;
     if ((m_startPoint.InLine(longerLineSegment))
         && (m_endPoint.InLine(longerLineSegment))) {
         bInLine = true;
     }
     return bInLine;
 }
Example #8
0
        /**********************************************************
        To check the Pt is in the Triangle or not.
        If the Pt is in the line or is a vertex, then return true.
        If the Pt is out of the Triangle, then return false.

        This method is used for triangle only.
        ***********************************************************/
        private bool TriangleContainsPoint(CPoint2D[] trianglePts, CPoint2D pt)
        {
            if (trianglePts.Length != 3) {
                return false;
            }

            for (int i = trianglePts.GetLowerBound(0); i < trianglePts.GetUpperBound(0); i++) {
                if (pt.EqualsPoint(trianglePts[i])) {
                    return true;
                }
            }

            bool bIn = false;

            CLineSegment line0 = new CLineSegment(trianglePts[0], trianglePts[1]);
            CLineSegment line1 = new CLineSegment(trianglePts[1], trianglePts[2]);
            CLineSegment line2 = new CLineSegment(trianglePts[2], trianglePts[0]);

            if (pt.InLine(line0) || pt.InLine(line1)
                || pt.InLine(line2)) {
                bIn = true;
            }
            else //point is not in the lines
            {
                double dblArea0 = CPolygon.PolygonArea(new CPoint2D[] {trianglePts[0], trianglePts[1], pt});
                double dblArea1 = CPolygon.PolygonArea(new CPoint2D[] {trianglePts[1], trianglePts[2], pt});
                double dblArea2 = CPolygon.PolygonArea(new CPoint2D[] {trianglePts[2], trianglePts[0], pt});

                if (dblArea0 > 0) {
                    if ((dblArea1 > 0)
                        && (dblArea2 > 0)) {
                        bIn = true;
                    }
                }
                else if (dblArea0 < 0) {
                    if ((dblArea1 < 0)
                        && (dblArea2 < 0)) {
                        bIn = true;
                    }
                }
            }
            return bIn;
        }
Example #9
0
        /************************************************
         * Offset the line segment to generate a new line segment
         * If the offset direction is along the x-axis or y-axis,
         * Parameter is true, other wise it is false
         * ***********************************************/

        public CLineSegment OffsetLine(double distance, bool rightOrDown)
        {
            //offset a line with a given distance, generate a new line
            //rightOrDown=true means offset to x incress direction,
            // if the line is horizontal, offset to y incress direction

            CLineSegment line;
            CPoint2D     newStartPoint = new CPoint2D();
            CPoint2D     newEndPoint   = new CPoint2D();

            double alphaInRad = this.GetLineAngle();             // 0-PI

            if (rightOrDown)
            {
                if (this.HorizontalLine())                 //offset to y+ direction
                {
                    newStartPoint.X = this.m_startPoint.X;
                    newStartPoint.Y = this.m_startPoint.Y + distance;

                    newEndPoint.X = this.m_endPoint.X;
                    newEndPoint.Y = this.m_endPoint.Y + distance;
                    line          = new CLineSegment(newStartPoint, newEndPoint);
                }
                else                 //offset to x+ direction
                {
                    if (Math.Sin(alphaInRad) > 0)
                    {
                        newStartPoint.X = m_startPoint.X + Math.Abs(distance * Math.Sin(alphaInRad));
                        newStartPoint.Y = m_startPoint.Y - Math.Abs(distance * Math.Cos(alphaInRad));

                        newEndPoint.X = m_endPoint.X + Math.Abs(distance * Math.Sin(alphaInRad));
                        newEndPoint.Y = m_endPoint.Y - Math.Abs(distance * Math.Cos(alphaInRad));

                        line = new CLineSegment(newStartPoint, newEndPoint);
                    }
                    else                     //sin(FalphaInRad)<0
                    {
                        newStartPoint.X = m_startPoint.X + Math.Abs(distance * Math.Sin(alphaInRad));
                        newStartPoint.Y = m_startPoint.Y + Math.Abs(distance * Math.Cos(alphaInRad));
                        newEndPoint.X   = m_endPoint.X + Math.Abs(distance * Math.Sin(alphaInRad));
                        newEndPoint.Y   = m_endPoint.Y + Math.Abs(distance * Math.Cos(alphaInRad));

                        line = new CLineSegment(newStartPoint, newEndPoint);
                    }
                }
            }                              //{rightOrDown}
            else                           //leftOrUp
            {
                if (this.HorizontalLine()) //offset to y directin
                {
                    newStartPoint.X = m_startPoint.X;
                    newStartPoint.Y = m_startPoint.Y - distance;

                    newEndPoint.X = m_endPoint.X;
                    newEndPoint.Y = m_endPoint.Y - distance;
                    line          = new CLineSegment(newStartPoint, newEndPoint);
                }
                else                 //offset to x directin
                {
                    if (Math.Sin(alphaInRad) >= 0)
                    {
                        newStartPoint.X = m_startPoint.X - Math.Abs(distance * Math.Sin(alphaInRad));
                        newStartPoint.Y = m_startPoint.Y + Math.Abs(distance * Math.Cos(alphaInRad));
                        newEndPoint.X   = m_endPoint.X - Math.Abs(distance * Math.Sin(alphaInRad));
                        newEndPoint.Y   = m_endPoint.Y + Math.Abs(distance * Math.Cos(alphaInRad));

                        line = new CLineSegment(newStartPoint, newEndPoint);
                    }
                    else                     //sin(FalphaInRad)<0
                    {
                        newStartPoint.X = m_startPoint.X - Math.Abs(distance * Math.Sin(alphaInRad));
                        newStartPoint.Y = m_startPoint.Y - Math.Abs(distance * Math.Cos(alphaInRad));
                        newEndPoint.X   = m_endPoint.X - Math.Abs(distance * Math.Sin(alphaInRad));
                        newEndPoint.Y   = m_endPoint.Y - Math.Abs(distance * Math.Cos(alphaInRad));

                        line = new CLineSegment(newStartPoint, newEndPoint);
                    }
                }
            }
            return(line);
        }
Example #10
0
        /***To check whether the point is in a line segment***/
        public bool InLine(CLineSegment lineSegment)
        {
            bool bInline = false;

            double Ax, Ay, Bx, By, Cx, Cy;
            Bx = lineSegment.EndPoint.X;
            By = lineSegment.EndPoint.Y;
            Ax = lineSegment.StartPoint.X;
            Ay = lineSegment.StartPoint.Y;
            Cx = this.m_dCoordinate_X;
            Cy = this.m_dCoordinate_Y;

            double L = lineSegment.GetLineSegmentLength();
            double s = Math.Abs(((Ay - Cy)*(Bx - Ax) - (Ax - Cx)*(By - Ay))/(L*L));

            if (Math.Abs(s - 0)
                < ConstantValue.SmallValue) {
                if ((SamePoints(this, lineSegment.StartPoint))
                    || (SamePoints(this, lineSegment.EndPoint))) {
                    bInline = true;
                }
                else if ((Cx < lineSegment.GetXmax()) && (Cx > lineSegment.GetXmin()) && (Cy < lineSegment.GetYmax())
                         && (Cy > lineSegment.GetYmin())) {
                    bInline = true;
                }
            }
            return bInline;
        }