手工画扇型(2)

画扇型的类，前提是中心点，半径点，变化点都已经确定。Graphic.DrawPie(),必须知道起始角，这个起始角是X正轴的角度 ，顺时针角度 ，还必须知道张角。张角和起始角可以为正负，把第一个点看成圆心点（0，0）。

    public class Sector
    {
        private ESRI.MapObjects2.Core.Point firstPoint;    //the center 

        private ESRI.MapObjects2.Core.Point secondPoint;  // get radius
                                                           
        private ESRI.MapObjects2.Core.Point varietyPoint;

        private float startAngle,sweepAngle,radius;

        //1 represents the first axis,2 represents the second axis.
        //5 represents positive y-axis. 6 represents positive x-axis.
        //7 represents nagative    y-axis. 8 represents nagative x-axis.
        private int radiusDirection = 0;


        #region property
        public ESRI.MapObjects2.Core.Point FirstPoint
        {
            get
            {
                return firstPoint;
            }
            set
            {
                firstPoint = value;
            }
        }

        public ESRI.MapObjects2.Core.Point SecondPoint
        {
            get
            {
                return secondPoint;
            }
            set
            {
                secondPoint = value;
            }
        }

        public ESRI.MapObjects2.Core.Point VarietyPoint
        {
            get
            {
                return varietyPoint;
            }
            set
            {
                varietyPoint = value;
            }
        }
        

         public float StartAngle
        {
            get
            {
                return startAngle;
            }
        }

        public float SweepAngle
        {
            get
            {
                return sweepAngle;
            }
        }

        public float Radius
        {
            get
            {
                return radius;
            }
        }

        #endregion

        public Sector()
        {
        }

        /// <summary>
        /// draw sector
        /// </summary>
        /// <param name="axMap"></param>
        public void DrawVarietySector(ESRI.MapObjects2.Core.AxMap axMap)
        {
            //Decause it is wrong with client point to calculate angle.
            double distanceX = secondPoint.X - firstPoint.X;
            double distanceY = secondPoint.Y - firstPoint.Y;

            float deedAngle = 0.0f; //    angle with x-axis
            float startAngle = 0.0f; // This angle is in deasil condition.
            int startDirection = 0;     // need kown the first point and the second point driection.

            //deedAngle maybe positive number or nagative.
            deedAngle = (float)((180*Math.Atan(distanceY/distanceX))/Math.PI);

            if(distanceX >= 0)    // the frist and the fourth axis.
            {
                //deedAngle is equal to 90 or -90. deedAngle maybe equal to 0.
                // including y-axis and positive x-axis.
                startAngle = -deedAngle;
                startDirection = 0;
            }
            else if( distanceX < 0) // the second and the third axis.
            {
                // including nagative x-axis.
                startAngle = 180 - deedAngle;
                startDirection = 1;
            }
            

            //Need to calculate distance between the center and position with mouse.          
            //change to client point
            float clientCenterX =0.0f ,clientCenterY =0.0f,clientRadiusX = 0.0f,clientRadiusY = 0.0f;
            axMap.FromMapPoint(firstPoint,ref clientCenterX,ref clientCenterY);
            axMap.FromMapPoint(secondPoint,ref clientRadiusX,ref clientRadiusY);

            int clientRadius = (int)Math.Sqrt(Math.Pow((clientCenterX -clientRadiusX),2)+Math.Pow((clientCenterY -clientRadiusY),2));

            double varietyX = varietyPoint.X - firstPoint.X;
            double varietyY = varietyPoint.Y - firstPoint.Y;

            float sweepAngle = 0.0f;
            float originalSweepAngle = (float)(180*Math.Atan(varietyY/varietyX)/Math.PI);

            switch (startDirection)
            {
                case 0:
                    if (deedAngle == 0) // positive x-axis
                    {
                        radiusDirection = 6;

                        if (varietyX >= 0)
                        {
                            sweepAngle = -originalSweepAngle;
                        }
                        else
                        {
                            sweepAngle =180-originalSweepAngle;

                        }
                        if (sweepAngle > 180) //When angle is greater than 180,the sector must be oppositional driection.
                        {
                            sweepAngle = -(360 - sweepAngle);
                        }
                    }
                    else if (deedAngle == 90)   // positive y-axis
                    {
                        radiusDirection = 5;

                        if (varietyX >= 0)
                        {
                            sweepAngle = 90 - originalSweepAngle;
                        }
                        else
                        {
                            sweepAngle = -(90 + originalSweepAngle);
                        }
                    }
                    else if (deedAngle == -90)     // negative y-axis
                    {
                        radiusDirection = 7;

                        if (varietyX >= 0)
                        {
                            sweepAngle = -(90 + originalSweepAngle);
                        }
                        else
                        {
                            sweepAngle = 90 - originalSweepAngle;
                        }
                    }
                    else if (deedAngle > 0 && deedAngle < 90)   //the frist axis
                    {
                        radiusDirection = 1;

                        if (varietyX >= 0)
                        {
                            //the first axis
                            sweepAngle = deedAngle - originalSweepAngle;
                        }
                        else if (varietyX < 0)
                        {
                            if (varietyY >= 0)
                            {
                                sweepAngle = -(180 - deedAngle + originalSweepAngle);
                            }
                            else
                            {       // west and north direction
                                if (deedAngle >= originalSweepAngle)   //sector is oppositional direction.
                                {
                                    sweepAngle = -(180 + originalSweepAngle - deedAngle);
                                }
                                else
                                {
                                    sweepAngle = 180 + deedAngle - originalSweepAngle;
                                }
                            }
                        }
                    }
                    else if (deedAngle < 0 && deedAngle > -90) // the fourth axis
                    {
                        radiusDirection = 4;

                        if (varietyX >= 0)   // first and fourth
                        {
                            sweepAngle = deedAngle - originalSweepAngle;
                        }
                        else     //second and third axis
                        {
                            if (varietyY >= 0)
                            {
                                if (deedAngle >= originalSweepAngle) // now deedAngle and originalSweepAngle are negative.
                                {
                                    //north and east  direction
                                    sweepAngle = -(180 + originalSweepAngle -deedAngle);
                                }
                                else
                                {       // west and south direction
                                    sweepAngle = 180 - originalSweepAngle + deedAngle ;
                                }
                            }
                            else    //the third axis
                            {
                                sweepAngle = 180 - originalSweepAngle + deedAngle; // deedAngle is negative.
                            }
                        }
                    }
                    break;
                case 1: // negative x-axis and second and third axis
                    if (deedAngle == 0)    // negative x-axis
                    {
                        radiusDirection = 8 ;

                        if (varietyX >= 0)
                        {
                            sweepAngle = 180 - originalSweepAngle;
                        }
                        else
                        {
                            sweepAngle = - originalSweepAngle;
                        }
                        if (sweepAngle > 180)  //sweepAngle is oppositional driection. west and east nouth direction.
                        {
                            sweepAngle = -(360 - sweepAngle);
                        }
                    }
                    else if (deedAngle > 0 && deedAngle < 90) // third axis
                    {
                        radiusDirection = 3;

                        if (varietyX >= 0)
                        {
                            if (varietyY >= 0)
                            {
                                if (deedAngle >= originalSweepAngle)
                                {
                                    sweepAngle = -(180 - deedAngle + originalSweepAngle);
                                }
                                else
                                {
                                    sweepAngle = 180 - originalSweepAngle + deedAngle;
                                }
                            }
                            else
                            {
                                sweepAngle = -(180 - deedAngle + originalSweepAngle);//originalSweepAngle is negative.
                            }
                        }
                        else
                        {
                            if (varietyY >= 0)
                            {
                                sweepAngle = deedAngle - originalSweepAngle; // originalSweepAngle is negative.
                            }
                            else
                            {
                                sweepAngle = deedAngle - originalSweepAngle;
                            }
                        }
                    }
                    else if (deedAngle< 0 && deedAngle > -90) // the second axis
                    {
                        radiusDirection = 2;

                        if (varietyX >= 0)
                        {
                            if (varietyY >= 0)
                            {
                                sweepAngle = 180 + deedAngle - originalSweepAngle;
                            }
                            else
                            {
                                // the second and fourth axis
                                if (deedAngle >= originalSweepAngle)
                                {      
                                    sweepAngle = -(180 + originalSweepAngle -deedAngle);
                                }
                                else
                                {
                                    sweepAngle = 180 + deedAngle - originalSweepAngle ;
                                }
                            }
                        }
                        else
                        {
                            sweepAngle = deedAngle - originalSweepAngle;
                        }
                    }
                    break;
            }

            this.startAngle = startAngle ;
            this.sweepAngle = sweepAngle;
            this.radius = (float)(Math.Sqrt(Math.Pow(distanceX,2) + Math.Pow(distanceY,2)));
            //calculate angle with radius.
            axMap.Refresh();
            Graphics gpArc = axMap.CreateGraphics();
            Pen pen = new Pen(Color.Black,1);
            pen.EndCap    = System.Drawing.Drawing2D.LineCap.ArrowAnchor;
            pen.StartCap    = System.Drawing.Drawing2D.LineCap.RoundAnchor;
            gpArc.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
            //draw pie

            System.Drawing.Rectangle rectangle = new System.Drawing.Rectangle(((int)clientCenterX-clientRadius),
             ((int)clientCenterY -clientRadius),clientRadius*2,clientRadius*2); 

            gpArc.DrawPie(pen,rectangle,startAngle,sweepAngle);

        }
}