C# ICurve.InsertControlPoint方法代码示例

        /// <summary>
        /// Create and add new control point to the given curve at a given Vec2F gpt</summary>
        /// <param name="curve">Curve to modify</param>
        /// <param name="gpt">Location on the x-axis at which to add a control point. Whether
        /// or not the y-coordinate is used depends on 'insert' parameter.</param>
        /// <param name="insert">If true, the y-value is inserted on the existing curve, using
        /// curve.Evaluate(gpt.X). If false, the y-value comes from gpt.Y.</param>
        /// <param name="computeTangent">Whether ComputeTangent() should be called</param>
        public static void AddControlPoint(ICurve curve, Vec2F gpt, bool insert, bool computeTangent)
        {
            if (curve == null)
                throw new ArgumentNullException("curve");

            // add/insert new control point to the given curve. Using the following rules.
            // if adding then add the point at gpt and set is tangent type to spline.
            // if inserting then add the point at (gpt.x,curve.eval(gpt.x)) and compute its tangent at the point.            
            // recompute tangents for the curve.
            // find insersion index.
            int index = GetValidInsertionIndex(curve, gpt.X);
            if (index >= 0)
            {
                IControlPoint p = curve.CreateControlPoint();
                p.EditorData.SelectedRegion = PointSelectionRegions.None;
                if (insert)
                {
                    p.X = gpt.X;
                    ICurveEvaluator cv = CurveUtils.CreateCurveEvaluator(curve);
                    
                    float prevY = cv.Evaluate(gpt.X - s_epsilone);
                    float nextY = cv.Evaluate(gpt.X + s_epsilone);
                    p.Y = cv.Evaluate(gpt.X);
                    p.TangentInType = CurveTangentTypes.Fixed;
                    p.TangentOutType = CurveTangentTypes.Fixed;
                    Vec2F tanIn = new Vec2F(s_epsilone, p.Y - prevY);
                    tanIn.Normalize();
                    Vec2F tanOut = new Vec2F(s_epsilone, nextY - p.Y);
                    tanOut.Normalize();
                    p.TangentIn = tanIn;
                    p.TangentOut = tanOut;                                                            
                }
                else
                {
                    p.X = gpt.X;
                    p.Y = gpt.Y;
                    p.TangentInType = CurveTangentTypes.Spline;
                    p.TangentOutType = CurveTangentTypes.Spline;
                }               
                curve.InsertControlPoint(index, p);
                if (computeTangent)
                    ComputeTangent(curve);
            }
        }

        /// <summary>
        /// Sort control points along x axis</summary>       
        /// <param name="curve">Curve whose control points are sorted</param>
        public static void Sort(ICurve curve)
        {
            if (curve == null) return;

            ReadOnlyCollection<IControlPoint> points = curve.ControlPoints;
            if (points.Count < 2)
                return;

            try
            {
                s_points.Clear();
                s_points.AddRange(points);

                // note about "insertion sort"
                // this type of sort is most efficient for Substantially sorted data
                // in this case the data is Substantially sorted, only few elements need fixing.
                for (int i = 1; i < s_points.Count; i++)
                {
                    IControlPoint val = s_points[i];
                    int j = i - 1;
                    while (j >= 0 && s_points[j].X > val.X)
                    {
                        s_points[j + 1] = s_points[j];
                        j--;
                    }
                    s_points[j + 1] = val;
                }

                for (int i = 0; i < s_points.Count; i++)
                {
                    IControlPoint scpt = s_points[i];
                    IControlPoint cpt = points[i];
                    if (scpt != cpt)
                    {                        
                        curve.InsertControlPoint(i, scpt);
                    }
                }
            }
            finally
            {
                s_points.Clear();
            }            
        }