其他分享
首页 > 其他分享> > 计算贝塞尔曲线上点坐标

计算贝塞尔曲线上点坐标

作者:互联网

 

贝塞尔曲线上控制点坐标分别为:P0(3,8),P1(2,3),P2(2,7),想要返回 10 个在贝塞尔曲线上的点

javascript代码如下:(从项目copy的代码,仅仅针对二维坐标dimersion = 2)

 1  /**
 2      * @param poss      贝塞尔曲线控制点坐标
 3      * @param precision 精度,需要计算的该条贝塞尔曲线上的点的数目
 4      * @return 该条贝塞尔曲线上的点(二维坐标)
 5      */
 6     function bezierCalculate(poss:Array<Point>, precision:number) {
 7 
 8         //维度,坐标轴数(二维坐标,三维坐标...)
 9         let dimersion = 2;
10 
11         //贝塞尔曲线控制点数(阶数)
12         let number = poss.length;
13 
14         //控制点数不小于 2 ,至少为二维坐标系
15         if (number < 2 || dimersion < 2)
16             return null;
17 
18         let result = new Array();
19 
20         //计算杨辉三角
21         let mi = new Array();
22         mi[0] = mi[1] = 1;
23         for (let i = 3; i <= number; i++) {
24 
25             let t = new Array();
26             for (let j = 0; j < i - 1; j++) {
27                 t[j] = mi[j];
28             }
29 
30             mi[0] = mi[i - 1] = 1;
31             for (let j = 0; j < i - 2; j++) {
32                 mi[j + 1] = t[j] + t[j + 1];
33             }
34         }
35 
36         //计算坐标点
37         for (let i = 0; i < precision; i++) {
38             let t = i / precision;
39             let p = new Point(0, 0);
40             result.push(p);
41             for (let j = 0; j < dimersion; j++) {
42                 let temp = 0.0;
43                 for (let k = 0; k < number; k++) {
44                     temp += Math.pow(1 - t, number - k - 1) * (j == 0 ? poss[k].x : poss[k].y) * Math.pow(t, k) * mi[k];
45                 }
46                 j == 0 ? p.x = temp : p.y = temp;
47             }
48             p.x = this.toDecimal(p.x);
49             p.y = this.toDecimal(p.y);
50         }
51 
52         return result;
53     }

 

java代码:

  /**
     * @param poss      贝塞尔曲线控制点坐标
     * @param precision 精度,需要计算的该条贝塞尔曲线上的点的数目
     * @return 该条贝塞尔曲线上的点(二维坐标)
     */
public float[][] calculate(float[][] poss, int precision) {

        //维度,坐标轴数(二维坐标,三维坐标...)
        int dimersion = poss[0].length;

        //贝塞尔曲线控制点数(阶数)
        int number = poss.length;

        //控制点数不小于 2 ,至少为二维坐标系
        if (number < 2 || dimersion < 2)
            return null;

        float[][] result = new float[precision][dimersion];

        //计算杨辉三角
        int[] mi = new int[number];
        mi[0] = mi[1] = 1;
        for (int i = 3; i <= number; i++) {

            int[] t = new int[i - 1];
            for (int j = 0; j < t.length; j++) {
                t[j] = mi[j];
            }

            mi[0] = mi[i - 1] = 1;
            for (int j = 0; j < i - 2; j++) {
                mi[j + 1] = t[j] + t[j + 1];
            }
        }

        //计算坐标点
        for (int i = 0; i < precision; i++) {
            float t = (float) i / precision;
            for (int j = 0; j < dimersion; j++) {
                float temp = 0.0f;
                for (int k = 0; k < number; k++) {
                    temp += Math.pow(1 - t, number - k - 1) * poss[k][j] * Math.pow(t, k) * mi[k];
                }
                result[i][j] = temp;
            }
        }

        return result;
    }

 

标签:dimersion,int,曲线,贝塞尔,坐标,poss
来源: https://www.cnblogs.com/fangsmile/p/11642784.html