Пример #1
0
        public CLine(CPoint2D point1, CPoint2D point2)
        {
            try {
                if (CPoint2D.SamePoints(point1, point2)) {
                    string errMsg = "The input points are the same";
                    InvalidInputGeometryDataException ex = new InvalidInputGeometryDataException(errMsg);
                    throw ex;
                }

                //Point1 and Point2 are different points:
                if (Math.Abs(point1.X - point2.X)
                    < ConstantValue.SmallValue) //vertical line
                {
                    Initialize(Math.PI/2, point1);
                }
                else if (Math.Abs(point1.Y - point2.Y)
                         < ConstantValue.SmallValue) //Horizontal line
                {
                    Initialize(0, point1);
                }
                else //normal line
                {
                    double m = (point2.Y - point1.Y)/(point2.X - point1.X);
                    double alphaInRad = Math.Atan(m);
                    Initialize(alphaInRad, point1);
                }
            }
            catch (Exception e) {
                Trace.WriteLine(e.Message + e.StackTrace);
            }
        }
Пример #2
0
        /*****************************************
        To check given points make a clock-wise polygon or
        count clockwise polygon

        Restriction: the polygon is not self intersecting
        *****************************************/
        public static PolygonDirection PointsDirection(CPoint2D[] points)
        {
            int nCount = 0, j = 0, k = 0;
            int nPoints = points.Length;

            if (nPoints < 3) {
                return PolygonDirection.Unknown;
            }

            for (int i = 0; i < nPoints; i++) {
                j = (i + 1)%nPoints; //j:=i+1;
                k = (i + 2)%nPoints; //k:=i+2;

                double crossProduct = (points[j].X - points[i].X)*(points[k].Y - points[j].Y);
                crossProduct = crossProduct - ((points[j].Y - points[i].Y)*(points[k].X - points[j].X));

                if (crossProduct > 0) {
                    nCount++;
                }
                else {
                    nCount--;
                }
            }

            if (nCount < 0) {
                return PolygonDirection.Count_Clockwise;
            }
            else if (nCount > 0) {
                return PolygonDirection.Clockwise;
            }
            else {
                return PolygonDirection.Unknown;
            }
        }
Пример #3
0
 /*** chagne the line's direction ***/
 public void ChangeLineDirection()
 {
     CPoint2D tempPt;
     tempPt = this.m_startPoint;
     this.m_startPoint = this.m_endPoint;
     this.m_endPoint = tempPt;
 }
Пример #4
0
        /**********************************************************
            Get point location, using windows coordinate system:
            y-axes points down.
            Return Value:
            -1:point at the left of the line (or above the line if the line is horizontal)
             0: point in the line segment or in the line segment 's extension
             1: point at right of the line (or below the line if the line is horizontal)
         ***********************************************************/
        public int GetPointLocation(CPoint2D point)
        {
            double Ax, Ay, Bx, By, Cx, Cy;
            Bx = m_endPoint.X;
            By = m_endPoint.Y;

            Ax = m_startPoint.X;
            Ay = m_startPoint.Y;

            Cx = point.X;
            Cy = point.Y;

            if (this.HorizontalLine()) {
                if (Math.Abs(Ay - Cy)
                    < ConstantValue.SmallValue) //equal
                {
                    return 0;
                }
                else if (Ay > Cy) {
                    return -1; //Y Axis points down, point is above the line
                }
                else //Ay<Cy
                {
                    return 1; //Y Axis points down, point is below the line
                }
            }
            else //Not a horizontal line
            {
                //make the line direction bottom->up
                if (m_endPoint.Y
                    > m_startPoint.Y) {
                    this.ChangeLineDirection();
                }

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

                //Note: the Y axis is pointing down:
                if (Math.Abs(s - 0)
                    < ConstantValue.SmallValue) //s=0
                {
                    return 0; //point is in the line or line extension
                }
                else if (s > 0) {
                    return -1; //point is left of line or above the horizontal line
                }
                else //s<0
                {
                    return 1;
                }
            }
        }
Пример #5
0
        public static bool SamePoints(CPoint2D Point1, CPoint2D Point2)
        {
            double dDeff_X = Math.Abs(Point1.X - Point2.X);
            double dDeff_Y = Math.Abs(Point1.Y - Point2.Y);

            if ((dDeff_X < ConstantValue.SmallValue)
                && (dDeff_Y < ConstantValue.SmallValue)) {
                return true;
            }
            else {
                return false;
            }
        }
Пример #6
0
 /*********** Sort points from Xmin->Xmax ******/
 public static void SortPointsByX(CPoint2D[] points)
 {
     if (points.Length > 1) {
         CPoint2D tempPt;
         for (int i = 0; i < points.Length - 2; i++) {
             for (int j = i + 1; j < points.Length - 1; j++) {
                 if (points[i].X
                     > points[j].X) {
                     tempPt = points[j];
                     points[j] = points[i];
                     points[i] = tempPt;
                 }
             }
         }
     }
 }
Пример #7
0
 public CPolygon(CPoint2D[] points)
 {
     int nNumOfPoitns = points.Length;
     try {
         if (nNumOfPoitns < 3) {
             InvalidInputGeometryDataException ex = new InvalidInputGeometryDataException();
             throw ex;
         }
         else {
             m_aVertices = new CPoint2D[nNumOfPoitns];
             for (int i = 0; i < nNumOfPoitns; i++) {
                 m_aVertices[i] = points[i];
             }
         }
     }
     catch (Exception e) {
         Trace.WriteLine(e.Message + e.StackTrace);
     }
 }
Пример #8
0
        public CPolygonShape(CPoint2D[] vertices)
        {
            int nVertices = vertices.Length;
            if (nVertices < 3) {
                Trace.WriteLine("To make a polygon, " + " at least 3 points are required!");
                return;
            }

            //initalize the 2D points
            m_aInputVertices = new CPoint2D[nVertices];

            for (int i = 0; i < nVertices; i++) {
                m_aInputVertices[i] = vertices[i];
            }

            //make a working copy,  m_aUpdatedPolygonVertices are
            //in count clock direction from user view
            SetUpdatedPolygonVertices();
        }
Пример #9
0
        /*******************************************************
        To cut an ear from polygon to make ears and an updated polygon:
        *******************************************************/
        public void CutEar()
        {
            CPolygon polygon = new CPolygon(m_aUpdatedPolygonVertices);
            bool bFinish = false;

            //if (polygon.GetPolygonType()==PolygonType.Convex) //don't have to cut ear
            //	bFinish=true;

            if (m_aUpdatedPolygonVertices.Length == 3) //triangle, don't have to cut ear
            {
                bFinish = true;
            }

            CPoint2D pt = new CPoint2D();
            while (bFinish == false) //UpdatedPolygon
            {
                int i = 0;
                bool bNotFound = true;
                while (bNotFound && (i < m_aUpdatedPolygonVertices.Length)) //loop till find an ear
                {
                    pt = m_aUpdatedPolygonVertices[i];
                    if (IsEarOfUpdatedPolygon(pt)) {
                        bNotFound = false; //got one, pt is an ear
                    }
                    else {
                        i++;
                    }
                } //bNotFount
                //An ear found:}
                if (pt != null) {
                    UpdatePolygonVertices(pt);
                }

                polygon = new CPolygon(m_aUpdatedPolygonVertices);
                //if ((polygon.GetPolygonType()==PolygonType.Convex)
                //	&& (m_aUpdatedPolygonVertices.Length==3))
                if (m_aUpdatedPolygonVertices.Length == 3) {
                    bFinish = true;
                }
            } //bFinish=false
            SetPolygons();
        }
Пример #10
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;
        }
Пример #11
0
 public CLineSegment(CPoint2D startPoint, CPoint2D endPoint)
     : base(startPoint, endPoint)
 {
     this.m_startPoint = startPoint;
     this.m_endPoint = endPoint;
 }
Пример #12
0
        /****************************************************************
        To check whether the Vertex is an ear or not based updated Polygon vertices

        ref. www-cgrl.cs.mcgill.ca/~godfried/teaching/cg-projects/97/Ian
        /algorithm1.html

        If it is an ear, return true,
        If it is not an ear, return false;
        *****************************************************************/
        private bool IsEarOfUpdatedPolygon(CPoint2D vertex)
        {
            CPolygon polygon = new CPolygon(m_aUpdatedPolygonVertices);

            if (polygon.PolygonVertex(vertex)) {
                bool bEar = true;
                if (polygon.PolygonVertexType(vertex)
                    == VertexType.ConvexPoint) {
                    CPoint2D pi = vertex;
                    CPoint2D pj = polygon.PreviousPoint(vertex); //previous vertex
                    CPoint2D pk = polygon.NextPoint(vertex); //next vertex

                    for (int i = m_aUpdatedPolygonVertices.GetLowerBound(0); i < m_aUpdatedPolygonVertices.GetUpperBound(0); i++) {
                        CPoint2D pt = m_aUpdatedPolygonVertices[i];
                        if (!(pt.EqualsPoint(pi) || pt.EqualsPoint(pj) || pt.EqualsPoint(pk))) {
                            if (TriangleContainsPoint(new CPoint2D[] {pj, pi, pk}, pt)) {
                                bEar = false;
                            }
                        }
                    }
                } //ThePolygon.getVertexType(Vertex)=ConvexPt
                else //concave point
                {
                    bEar = false; //not an ear/
                }
                return bEar;
            }
            else //not a polygon vertex;
            {
                Trace.WriteLine("IsEarOfUpdatedPolygon: " + "Not a polygon vertex");
                return false;
            }
        }
Пример #13
0
        /****************************************************
        Set up m_aPolygons:
        add ears and been cut Polygon togather
        ****************************************************/
        private void SetPolygons()
        {
            int nPolygon = m_alEars.Count + 1; //ears plus updated polygon
            m_aPolygons = new CPoint2D[nPolygon][];

            for (int i = 0; i < nPolygon - 1; i++) //add ears
            {
                CPoint2D[] points = (CPoint2D[]) m_alEars[i];

                m_aPolygons[i] = new CPoint2D[3]; //3 vertices each ear
                m_aPolygons[i][0] = points[0];
                m_aPolygons[i][1] = points[1];
                m_aPolygons[i][2] = points[2];
            }

            //add UpdatedPolygon:
            m_aPolygons[nPolygon - 1] = new CPoint2D[m_aUpdatedPolygonVertices.Length];

            for (int i = 0; i < m_aUpdatedPolygonVertices.Length; i++) {
                m_aPolygons[nPolygon - 1][i] = m_aUpdatedPolygonVertices[i];
            }
        }
Пример #14
0
        /*** calculate the distance from a given point to the line ***/
        public double GetDistance(CPoint2D point)
        {
            double x0 = point.X;
            double y0 = point.Y;

            double d = Math.Abs(a*x0 + b*y0 + c);
            d = d/(Math.Sqrt(a*a + b*b));

            return d;
        }
Пример #15
0
        private void UpdateVertices()
        {
            m_verticalExaggeration = World.Settings.VerticalExaggeration;

            CPoint2D[] polygonVertices = new CPoint2D[m_polygonPoints.Length];
            for (int i = 0; i < polygonVertices.Length; i++) {
                polygonVertices[i] = new CPoint2D(m_polygonPoints[i].X, m_polygonPoints[i].Y);
            }

            CPolygonShape cutPolygon = new CPolygonShape(polygonVertices);
            cutPolygon.CutEar();

            ArrayList vertexList = new ArrayList();

            for (int i = 0; i < cutPolygon.NumberOfPolygons; i++) {
                int nPoints = cutPolygon.Polygons(i).Length;

                for (int j = 0; j < nPoints; j++) {
                    Point3d point = new Point3d(cutPolygon.Polygons(i)[j].X, cutPolygon.Polygons(i)[j].Y, 0);

                    foreach (Point3d sourcePoint in m_polygonPoints) {
                        if (sourcePoint.X.Equals(point.X)
                            && sourcePoint.Y.Equals(point.Y)) {
                            point.Z = sourcePoint.Z;
                            break;
                        }
                    }

                    vertexList.Add(point);
                }
            }

            if (m_extrudeHeight > 0) {
                CustomVertex.PositionNormalColored[] vertices = new CustomVertex.PositionNormalColored[vertexList.Count*2];
                int polygonColor = Color.FromArgb(Opacity, m_polygonColor.R, m_polygonColor.G, m_polygonColor.B).ToArgb();
                int vertexOffset = vertices.Length/2;

                // build bottom vertices
                for (int i = 0; i < vertices.Length/2; i++) {
                    Point3d sphericalPoint = (Point3d) vertexList[i];
                    Vector3 xyzVector = MathEngine.SphericalToCartesian(sphericalPoint.Y, sphericalPoint.X, World.EquatorialRadius + m_verticalExaggeration*(sphericalPoint.Z + m_distanceAboveSurface));

                    vertices[i].Color = polygonColor;
                    vertices[i].X = xyzVector.X;
                    vertices[i].Y = xyzVector.Y;
                    vertices[i].Z = xyzVector.Z;
                }

                //build top vertices
                for (int i = vertexOffset; i < vertices.Length; i++) {
                    Point3d sphericalPoint = (Point3d) vertexList[i - vertexOffset];
                    Vector3 xyzVector = MathEngine.SphericalToCartesian(sphericalPoint.Y, sphericalPoint.X, World.EquatorialRadius + m_verticalExaggeration*(sphericalPoint.Z + m_distanceAboveSurface + m_extrudeHeight));

                    vertices[i].Color = polygonColor;
                    vertices[i].X = xyzVector.X;
                    vertices[i].Y = xyzVector.Y;
                    vertices[i].Z = xyzVector.Z;
                }

                m_vertices = vertices;
            }
            else {
                CustomVertex.PositionNormalColored[] vertices = new CustomVertex.PositionNormalColored[vertexList.Count];
                int polygonColor = Color.FromArgb(Opacity, m_polygonColor.R, m_polygonColor.G, m_polygonColor.B).ToArgb();

                for (int i = 0; i < vertices.Length; i++) {
                    Point3d sphericalPoint = (Point3d) vertexList[i];
                    Vector3 xyzVector = MathEngine.SphericalToCartesian(sphericalPoint.Y, sphericalPoint.X, World.EquatorialRadius + m_verticalExaggeration*(sphericalPoint.Z + m_distanceAboveSurface));

                    vertices[i].Color = polygonColor;
                    vertices[i].X = xyzVector.X;
                    vertices[i].Y = xyzVector.Y;
                    vertices[i].Z = xyzVector.Z;
                }

                m_vertices = vertices;
            }

            if (m_extrudeHeight > 0 || m_outline) {
                Point3d[] linePoints = new Point3d[m_polygonPoints.Length + 1];
                for (int i = 0; i < m_polygonPoints.Length; i++) {
                    linePoints[i] = m_polygonPoints[i];
                }

                linePoints[linePoints.Length - 1] = m_polygonPoints[0];

                m_lineFeature = new LineFeature(Name, World, linePoints, m_polygonColor);
                m_lineFeature.ExtrudeHeight = m_extrudeHeight;
                m_lineFeature.DistanceAboveSurface = m_distanceAboveSurface;
                m_lineFeature.ExtrudeUpwards = m_extrudeUpwards;
                m_lineFeature.MinimumDisplayAltitude = m_minimumDisplayAltitude;
                m_lineFeature.MaximumDisplayAltitude = m_maximumDisplayAltitude;
                m_lineFeature.Opacity = Opacity;
                m_lineFeature.Outline = m_outline;
                m_lineFeature.OutlineColor = m_outlineColor;
            }
            else {
                if (m_lineFeature != null) {
                    m_lineFeature.Dispose();
                    m_lineFeature = null;
                }
            }
        }
Пример #16
0
        /***********************************************
            To check a vertex concave point or a convex point
            -----------------------------------------------------------
            The out polygon is in count clock-wise direction
        ************************************************/
        public VertexType PolygonVertexType(CPoint2D vertex)
        {
            VertexType vertexType = VertexType.ErrorPoint;

            if (PolygonVertex(vertex)) {
                CPoint2D pti = vertex;
                CPoint2D ptj = PreviousPoint(vertex);
                CPoint2D ptk = NextPoint(vertex);

                double dArea = PolygonArea(new CPoint2D[] {ptj, pti, ptk});

                if (dArea < 0) {
                    vertexType = VertexType.ConvexPoint;
                }
                else if (dArea > 0) {
                    vertexType = VertexType.ConcavePoint;
                }
            }
            return vertexType;
        }
Пример #17
0
        /***************************************
             From a given vertex, get its next vertex point.
             If the given point is the last one,
             it will return  the first vertex;
             If the given point is not a polygon vertex,
             it will return null;
        ***************************************/
        public CPoint2D NextPoint(CPoint2D vertex)
        {
            CPoint2D nextPt = new CPoint2D();

            int nIndex;
            nIndex = VertexIndex(vertex);
            if (nIndex == -1) {
                return null;
            }
            else //a valid vertex
            {
                int nNumOfPt = m_aVertices.Length;
                if (nIndex == nNumOfPt - 1) //the last vertex
                {
                    return m_aVertices[0];
                }
                else //not the last vertex
                {
                    return m_aVertices[nIndex + 1];
                }
            }
        }
Пример #18
0
        /**************************************
         Calculate intersection point of two lines
         if two lines are parallel, return null
         * ************************************/
        public CPoint2D IntersecctionWith(CLine line)
        {
            CPoint2D point = new CPoint2D();
            double a1 = this.a;
            double b1 = this.b;
            double c1 = this.c;

            double a2 = line.a;
            double b2 = line.b;
            double c2 = line.c;

            if (!(this.Parallel(line))) //not parallen
            {
                point.X = (c2*b1 - c1*b2)/(a1*b2 - a2*b1);
                point.Y = (a1*c2 - c1*a2)/(a2*b2 - a1*b2);
            }
            return point;
        }
Пример #19
0
        /********************************************************
        To update m_aUpdatedPolygonVertices:
        Take out Vertex from m_aUpdatedPolygonVertices array, add 3 points
        to the m_aEars
        **********************************************************/
        private void UpdatePolygonVertices(CPoint2D vertex)
        {
            ArrayList alTempPts = new ArrayList();

            for (int i = 0; i < m_aUpdatedPolygonVertices.Length; i++) {
                if (vertex.EqualsPoint(m_aUpdatedPolygonVertices[i])) //add 3 pts to FEars
                {
                    CPolygon polygon = new CPolygon(m_aUpdatedPolygonVertices);
                    CPoint2D pti = vertex;
                    CPoint2D ptj = polygon.PreviousPoint(vertex); //previous point
                    CPoint2D ptk = polygon.NextPoint(vertex); //next point

                    CPoint2D[] aEar = new CPoint2D[3]; //3 vertices of each ear
                    aEar[0] = ptj;
                    aEar[1] = pti;
                    aEar[2] = ptk;

                    m_alEars.Add(aEar);
                }
                else {
                    alTempPts.Add(m_aUpdatedPolygonVertices[i]);
                } //not equal points
            }

            if (m_aUpdatedPolygonVertices.Length - alTempPts.Count == 1) {
                int nLength = m_aUpdatedPolygonVertices.Length;
                m_aUpdatedPolygonVertices = new CPoint2D[nLength - 1];

                for (int i = 0; i < alTempPts.Count; i++) {
                    m_aUpdatedPolygonVertices[i] = (CPoint2D) alTempPts[i];
                }
            }
        }
Пример #20
0
        /*********************************************
        To check the Line of vertex1, vertex2 is a Diagonal or not

        To be a diagonal, Line vertex1-vertex2 has no intersection
        with polygon lines.

        If it is a diagonal, return true;
        If it is not a diagonal, return false;
        reference: www.swin.edu.au/astronomy/pbourke
        /geometry/lineline2d
        *********************************************/
        public bool Diagonal(CPoint2D vertex1, CPoint2D vertex2)
        {
            bool bDiagonal = false;
            int nNumOfVertices = m_aVertices.Length;
            int j = 0;
            for (int i = 0; i < nNumOfVertices; i++) //each point
            {
                bDiagonal = true;
                j = (i + 1)%nNumOfVertices; //next point of i

                //Diagonal line:
                double x1 = vertex1.X;
                double y1 = vertex1.Y;
                double x2 = vertex1.X;
                double y2 = vertex1.Y;

                //CPolygon line:
                double x3 = m_aVertices[i].X;
                double y3 = m_aVertices[i].Y;
                double x4 = m_aVertices[j].X;
                double y4 = m_aVertices[j].Y;

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

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

                if ((ub > 0)
                    && (ub < 1)) {
                    bDiagonal = false;
                }
            }
            return bDiagonal;
        }
Пример #21
0
        /***********************************
         From a given point, get its vertex index.
         If the given point is not a polygon vertex,
         it will return -1
         ***********************************/
        public int VertexIndex(CPoint2D vertex)
        {
            int nIndex = -1;

            int nNumPts = m_aVertices.Length;
            for (int i = 0; i < nNumPts; i++) //each vertex
            {
                if (CPoint2D.SamePoints(m_aVertices[i], vertex)) {
                    nIndex = i;
                }
            }
            return nIndex;
        }
Пример #22
0
        /*****************************************************
        To reverse polygon vertices to different direction:
        clock-wise <------->count-clock-wise
        ******************************************************/
        public void ReverseVerticesDirection()
        {
            int nVertices = m_aVertices.Length;
            CPoint2D[] aTempPts = new CPoint2D[nVertices];

            for (int i = 0; i < nVertices; i++) {
                aTempPts[i] = m_aVertices[i];
            }

            for (int i = 0; i < nVertices; i++) {
                m_aVertices[i] = aTempPts[nVertices - 1 - i];
            }
        }
Пример #23
0
        /***************************************************
        Check a Vertex is a principal vertex or not
        ref. www-cgrl.cs.mcgill.ca/~godfried/teaching/
        cg-projects/97/Ian/glossay.html

        PrincipalVertex: a vertex pi of polygon P is a principal vertex if the
        diagonal pi-1, pi+1 intersects the boundary of P only at pi-1 and pi+1.
        *********************************************************/
        public bool PrincipalVertex(CPoint2D vertex)
        {
            bool bPrincipal = false;
            if (PolygonVertex(vertex)) //valid vertex
            {
                CPoint2D pt1 = PreviousPoint(vertex);
                CPoint2D pt2 = NextPoint(vertex);

                if (Diagonal(pt1, pt2)) {
                    bPrincipal = true;
                }
            }
            return bPrincipal;
        }
Пример #24
0
        /***********************************
         From a given vertex, get its previous vertex point.
         If the given point is the first one,
         it will return  the last vertex;
         If the given point is not a polygon vertex,
         it will return null;
         ***********************************/
        public CPoint2D PreviousPoint(CPoint2D vertex)
        {
            int nIndex;

            nIndex = VertexIndex(vertex);
            if (nIndex == -1) {
                return null;
            }
            else //a valid vertex
            {
                if (nIndex == 0) //the first vertex
                {
                    int nPoints = m_aVertices.Length;
                    return m_aVertices[nPoints - 1];
                }
                else //not the first vertex
                {
                    return m_aVertices[nIndex - 1];
                }
            }
        }
Пример #25
0
        /******************************************
        To calculate the area of polygon made by given points

        Good for polygon with holes, but the vertices make the
        hole  should be in different direction with bounding
        polygon.

        Restriction: the polygon is not self intersecting
        ref: www.swin.edu.au/astronomy/pbourke/
            geometry/polyarea/

        As polygon in different direction, the result coulb be
        in different sign:
        If dblArea>0 : polygon in clock wise to the user
        If dblArea<0: polygon in count clock wise to the user
        *******************************************/
        public static double PolygonArea(CPoint2D[] points)
        {
            double dblArea = 0;
            int nNumOfPts = points.Length;

            int j;
            for (int i = 0; i < nNumOfPts; i++) {
                j = (i + 1)%nNumOfPts;
                dblArea += points[i].X*points[j].Y;
                dblArea -= (points[i].Y*points[j].X);
            }

            dblArea = dblArea/2;
            return dblArea;
        }
Пример #26
0
        /*********************************************
        To check whether a given point is a CPolygon Vertex
        **********************************************/
        public bool PolygonVertex(CPoint2D point)
        {
            bool bVertex = false;
            int nIndex = VertexIndex(point);

            if ((nIndex >= 0)
                && (nIndex <= m_aVertices.Length - 1)) {
                bVertex = true;
            }

            return bVertex;
        }
Пример #27
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;
        }
Пример #28
0
 public CLine(Double angleInRad, CPoint2D point)
 {
     Initialize(angleInRad, point);
 }
Пример #29
0
        private void Initialize(Double angleInRad, CPoint2D point)
        {
            //angleInRad should be between 0-Pi

            try {
                //if ((angleInRad<0) ||(angleInRad>Math.PI))
                if (angleInRad > 2*Math.PI) {
                    string errMsg = string.Format("The input line angle" + " {0} is wrong. It should be between 0-2*PI.", angleInRad);

                    InvalidInputGeometryDataException ex = new InvalidInputGeometryDataException(errMsg);

                    throw ex;
                }

                if (Math.Abs(angleInRad - Math.PI/2)
                    < ConstantValue.SmallValue) //vertical line
                {
                    a = 1;
                    b = 0;
                    c = -point.X;
                }
                else //not vertical line
                {
                    a = -Math.Tan(angleInRad);
                    b = 1;
                    c = -a*point.X - b*point.Y;
                }
            }
            catch (Exception e) {
                Trace.WriteLine(e.Message + e.StackTrace);
            }
        }
Пример #30
0
        /*****************************************************
        To reverse points to different direction (order) :
        ******************************************************/
        public static void ReversePointsDirection(CPoint2D[] points)
        {
            int nVertices = points.Length;
            CPoint2D[] aTempPts = new CPoint2D[nVertices];

            for (int i = 0; i < nVertices; i++) {
                aTempPts[i] = points[i];
            }

            for (int i = 0; i < nVertices; i++) {
                points[i] = aTempPts[nVertices - 1 - i];
            }
        }