vislite 0.1.0 → 0.2.0-alpha.7

package/src/interpolation/Cardinal.ts

@@ -1,92 +1,92 @@
-/**
- * Cardinal三次插值
- * ----------------------------
- * Hermite拟合的计算是，确定两个点和两个点的斜率
- * 用一个y=ax(3)+bx(2)+cx+d的三次多项式来求解
- * 而Cardinal是建立在此基础上
- * 给定需要拟合的两个点和第一个点的前一个点+最后一个点的后一个点
- * 第一个点的斜率由第一个点的前一个点和第二个点的斜率确定
- * 第二个点的斜率由第一个点和第二个点的后一个点的斜率确定
- */
-
-import CardinalType from '../../types/Cardinal'
-import Hermite from './Hermite'
-
-class Cardinal implements CardinalType {
-    readonly name: string = 'Cardinal'
-
-    // 该参数用于调整曲线走势，默认数值t=0，分水岭t=-1，|t-(-1)|的值越大，曲线走势调整的越严重
-    private __t: number
-
-    private __HS: {
-        x: number[],
-        h: Hermite[]
-    }
-    private __i: number
-
-    constructor(t: number = 0) {
-        this.__t = t
-    }
-
-    // 设置点的位置
-    // 参数格式：[[x1, y1], [x2, y2], ... ]
-    // 至少两个点
-    setP(points: number[][]) {
-
-        this.__HS = {
-            "x": [],
-            "h": []
-        };
-        var flag: number,
-            slope = (points[1][1] - points[0][1]) / (points[1][0] - points[0][0]),
-            temp: number
-        this.__HS.x[0] = points[0][0]
-        for (flag = 1; flag < points.length; flag++) {
-            if (points[flag][0] <= points[flag - 1][0]) throw new Error('The point position should be increamented!')
-            this.__HS.x[flag] = points[flag][0]
-
-            // 求点斜率
-            temp = flag < points.length - 1 ?
-                (points[flag + 1][1] - points[flag - 1][1]) / (points[flag + 1][0] - points[flag - 1][0]) :
-                (points[flag][1] - points[flag - 1][1]) / (points[flag][0] - points[flag - 1][0])
-
-            // 求解两个点直接的拟合方程
-            // 第一个点的前一个点直接取第一个点
-            // 最后一个点的后一个点直接取最后一个点
-            this.__HS.h[flag - 1] = new Hermite((1 - this.__t) * 0.5).setP(points[flag - 1][0], points[flag - 1][1], points[flag][0], points[flag][1], slope, temp)
-            slope = temp
-        }
-        return this
-
-    }
-
-    // 根据x值返回y值
-    use(x: number) {
-        if (this.__HS) {
-            this.__i = -1
-
-            // 寻找记录x所在位置的区间
-            // 这里就是寻找对应的拟合函数
-            while (this.__i + 1 < this.__HS.x.length && (x > this.__HS.x[this.__i + 1] || (this.__i == -1 && x >= this.__HS.x[this.__i + 1]))) {
-                this.__i += 1
-            }
-
-            // 由于js浮点运算不准确，我们对于越界的情况进行兼容
-
-            if (this.__i < 0) {
-                return this.__HS.h[0].use(this.__HS.x[0])
-            }
-
-            else if (this.__i >= this.__HS.h.length) {
-                return this.__HS.h[this.__HS.h.length - 1].use(this.__HS.x[this.__HS.x.length - 1])
-            }
-
-            return this.__HS.h[this.__i].use(x)
-        } else {
-            throw new Error('You shoud first set the position!')
-        }
-    }
-
-}
-
+/**
+ * Cardinal三次插值
+ * ----------------------------
+ * Hermite拟合的计算是，确定两个点和两个点的斜率
+ * 用一个y=ax(3)+bx(2)+cx+d的三次多项式来求解
+ * 而Cardinal是建立在此基础上
+ * 给定需要拟合的两个点和第一个点的前一个点+最后一个点的后一个点
+ * 第一个点的斜率由第一个点的前一个点和第二个点的斜率确定
+ * 第二个点的斜率由第一个点和第二个点的后一个点的斜率确定
+ */
+
+import CardinalType from '../../types/Cardinal'
+import Hermite from './Hermite'
+
+class Cardinal implements CardinalType {
+    readonly name: string = 'Cardinal'
+
+    // 该参数用于调整曲线走势，默认数值t=0，分水岭t=-1，|t-(-1)|的值越大，曲线走势调整的越严重
+    private __t: number
+
+    private __HS: {
+        x: number[],
+        h: Hermite[]
+    }
+    private __i: number
+
+    constructor(t: number = 0) {
+        this.__t = t
+    }
+
+    // 设置点的位置
+    // 参数格式：[[x1, y1], [x2, y2], ... ]
+    // 至少两个点
+    setP(points: number[][]) {
+
+        this.__HS = {
+            "x": [],
+            "h": []
+        };
+        var flag: number,
+            slope = (points[1][1] - points[0][1]) / (points[1][0] - points[0][0]),
+            temp: number
+        this.__HS.x[0] = points[0][0]
+        for (flag = 1; flag < points.length; flag++) {
+            if (points[flag][0] <= points[flag - 1][0]) throw new Error('The point position should be increamented!')
+            this.__HS.x[flag] = points[flag][0]
+
+            // 求点斜率
+            temp = flag < points.length - 1 ?
+                (points[flag + 1][1] - points[flag - 1][1]) / (points[flag + 1][0] - points[flag - 1][0]) :
+                (points[flag][1] - points[flag - 1][1]) / (points[flag][0] - points[flag - 1][0])
+
+            // 求解两个点直接的拟合方程
+            // 第一个点的前一个点直接取第一个点
+            // 最后一个点的后一个点直接取最后一个点
+            this.__HS.h[flag - 1] = new Hermite((1 - this.__t) * 0.5).setP(points[flag - 1][0], points[flag - 1][1], points[flag][0], points[flag][1], slope, temp)
+            slope = temp
+        }
+        return this
+
+    }
+
+    // 根据x值返回y值
+    use(x: number) {
+        if (this.__HS) {
+            this.__i = -1
+
+            // 寻找记录x所在位置的区间
+            // 这里就是寻找对应的拟合函数
+            while (this.__i + 1 < this.__HS.x.length && (x > this.__HS.x[this.__i + 1] || (this.__i == -1 && x >= this.__HS.x[this.__i + 1]))) {
+                this.__i += 1
+            }
+
+            // 由于js浮点运算不准确，我们对于越界的情况进行兼容
+
+            if (this.__i < 0) {
+                return this.__HS.h[0].use(this.__HS.x[0])
+            }
+
+            else if (this.__i >= this.__HS.h.length) {
+                return this.__HS.h[this.__HS.h.length - 1].use(this.__HS.x[this.__HS.x.length - 1])
+            }
+
+            return this.__HS.h[this.__i].use(x)
+        } else {
+            throw new Error('You shoud first set the position!')
+        }
+    }
+
+}
+
 export default Cardinal

package/src/interpolation/Hermite.ts

@@ -1,66 +1,66 @@
-import HermiteType from '../../types/Hermite'
-
-class Hermite implements HermiteType {
-    readonly name: string = 'Hermite'
-
-    private __u: number // 张弛系数
-
-    private __MR: number[]
-    private __a: number
-    private __b: number
-
-    constructor(u: number = 0.5) {
-        this.__u = u
-    }
-
-    /**
-    * 设置点的位置
-    * @param {Number} x1 左边点的位置
-    * @param {Number} y1
-    * @param {Number} x2 右边点的位置
-    * @param {Number} y2
-    * @param {Number} s1 两个点的斜率
-    * @param {Number} s2
-    */
-    setP(x1: number, y1: number, x2: number, y2: number, s1: number, s2: number) {
-        if (x1 < x2) {
-            // 记录原始尺寸
-            this.__a = x1
-            this.__b = x2
-            let p3 = this.__u * s1,
-                p4 = this.__u * s2
-            // 缩放到[0,1]定义域
-            y1 /= (x2 - x1)
-            y2 /= (x2 - x1)
-            // MR是提前计算好的多项式通解矩阵
-            // 为了加速计算
-            // 如上面说的
-            // 统一在[0,1]上计算后再通过缩放和移动恢复
-            // 避免了动态求解矩阵的麻烦
-            this.__MR = [
-                2 * y1 - 2 * y2 + p3 + p4,
-                3 * y2 - 3 * y1 - 2 * p3 - p4,
-                p3,
-                y1
-            ]
-        } else throw new Error('The point x-position should be increamented!')
-        return this
-    }
-
-
-    /**
-     * 根据x值返回y值
-     * @param {Number} x
-     */
-    use(x: number) {
-        if (this.__MR) {
-            let sx = (x - this.__a) / (this.__b - this.__a),
-                sx2 = sx * sx,
-                sx3 = sx * sx2
-            let sResult = sx3 * this.__MR[0] + sx2 * this.__MR[1] + sx * this.__MR[2] + this.__MR[3]
-            return sResult * (this.__b - this.__a)
-        } else throw new Error('You shoud first set the position!')
-    }
-}
-
+import HermiteType from '../../types/Hermite'
+
+class Hermite implements HermiteType {
+    readonly name: string = 'Hermite'
+
+    private __u: number // 张弛系数
+
+    private __MR: number[]
+    private __a: number
+    private __b: number
+
+    constructor(u: number = 0.5) {
+        this.__u = u
+    }
+
+    /**
+    * 设置点的位置
+    * @param {Number} x1 左边点的位置
+    * @param {Number} y1
+    * @param {Number} x2 右边点的位置
+    * @param {Number} y2
+    * @param {Number} s1 两个点的斜率
+    * @param {Number} s2
+    */
+    setP(x1: number, y1: number, x2: number, y2: number, s1: number, s2: number) {
+        if (x1 < x2) {
+            // 记录原始尺寸
+            this.__a = x1
+            this.__b = x2
+            let p3 = this.__u * s1,
+                p4 = this.__u * s2
+            // 缩放到[0,1]定义域
+            y1 /= (x2 - x1)
+            y2 /= (x2 - x1)
+            // MR是提前计算好的多项式通解矩阵
+            // 为了加速计算
+            // 如上面说的
+            // 统一在[0,1]上计算后再通过缩放和移动恢复
+            // 避免了动态求解矩阵的麻烦
+            this.__MR = [
+                2 * y1 - 2 * y2 + p3 + p4,
+                3 * y2 - 3 * y1 - 2 * p3 - p4,
+                p3,
+                y1
+            ]
+        } else throw new Error('The point x-position should be increamented!')
+        return this
+    }
+
+
+    /**
+     * 根据x值返回y值
+     * @param {Number} x
+     */
+    use(x: number) {
+        if (this.__MR) {
+            let sx = (x - this.__a) / (this.__b - this.__a),
+                sx2 = sx * sx,
+                sx3 = sx * sx2
+            let sResult = sx3 * this.__MR[0] + sx2 * this.__MR[1] + sx * this.__MR[2] + this.__MR[3]
+            return sResult * (this.__b - this.__a)
+        } else throw new Error('You shoud first set the position!')
+    }
+}
+
 export default Hermite

package/src/rotate.ts

@@ -1,8 +1,8 @@
-// 点（x,y）围绕中心（cx,cy）旋转deg度
-export default function (cx: number, cy: number, deg: number, x: number, y: number) {
-    let cos = Math.cos(deg), sin = Math.sin(deg)
-    return [
-        (x - cx) * cos - (y - cy) * sin + cx,
-        (x - cx) * sin + (y - cy) * cos + cy
-    ]
+// 点（x,y）围绕中心（cx,cy）旋转deg度
+export default function (cx: number, cy: number, deg: number, x: number, y: number) {
+    let cos = Math.cos(deg), sin = Math.sin(deg)
+    return [
+        (x - cx) * cos - (y - cy) * sin + cx,
+        (x - cx) * sin + (y - cy) * cos + cy
+    ]
 }

package/src/ruler.ts

@@ -1,99 +1,99 @@
-// 刻度尺刻度求解
-
-// 需要注意的是，实际的间距个数可能是 num-1 或 num 或 num+1 或 1
-export default function (maxValue: number, minValue: number, num: number) {
-
-    // 如果最大值最小值反了
-    if (maxValue < minValue) {
-        let temp = minValue
-        minValue = maxValue
-        maxValue = temp
-    }
-
-    // 如果相等
-    else if (maxValue == minValue) {
-        return [maxValue]
-    }
-
-    // 为了变成 -100 ~ 100 需要放大或者缩小的倍数
-    let times100 =
-
-        (function (_value) {
-
-            // 先确定基调，是放大还是缩小
-            let _times100_base = (_value < 100 && _value > -100) ? 10 : 0.1
-
-            // 记录当前缩放倍数
-            let _times100 = -1, _tiemsValue = _value
-
-            while (_times100_base == 10 ?
-                // 如果是放大，超过 -100 ~ 100 就应该停止
-                (_tiemsValue >= -100 && _tiemsValue <= 100)
-                :
-                // 如果是缩小，进入 -100 ~ 100 就应该停止
-                (_tiemsValue <= -100 || _tiemsValue >= 100)
-            ) {
-
-                _times100 += 1
-                _tiemsValue *= _times100_base
-
-            }
-
-            if (_times100_base == 10) {
-                return Math.pow(10, _times100)
-            } else {
-
-                // 解决类似 0.1 * 0.1 = 0.010000000000000002 浮点运算不准确问题
-                let temp = "0."
-                for (let i = 1; i < _times100; i++) {
-                    temp += "0";
-                }
-                return +(temp + "1")
-            }
-        })
-
-            // 根据差值来缩放
-            (maxValue - minValue)
-
-
-    // 求解出 -100 ~ 100 的最佳间距值 后直接转换原来的倍数
-    let distance100 = Math.ceil((maxValue - minValue) * times100 / num)
-
-    // 校对一下
-    distance100 = {
-        3: 2,
-        4: 5,
-        6: 5,
-        7: 5,
-        8: 10,
-        9: 10,
-        11: 10,
-        12: 10,
-        13: 15,
-        14: 15,
-        16: 15,
-        17: 15,
-        18: 20,
-        19: 20,
-        21: 20,
-        22: 20,
-        23: 25,
-        24: 25,
-        26: 25,
-        27: 25
-    }[distance100] || distance100
-
-    let distance = distance100 / times100
-
-    // 最小值，也就是起点
-    let begin = Math.floor(minValue / distance) * distance
-
-    let rulerArray = []
-    // 获取最终的刻度尺数组
-    rulerArray.push(begin)
-    for (let index = 1; rulerArray[rulerArray.length - 1] < maxValue; index++) {
-        rulerArray.push(begin + distance * index)
-    }
-
-    return rulerArray
-}
+// 刻度尺刻度求解
+
+// 需要注意的是，实际的间距个数可能是 num-1 或 num 或 num+1 或 1
+export default function (maxValue: number, minValue: number, num: number) {
+
+    // 如果最大值最小值反了
+    if (maxValue < minValue) {
+        let temp = minValue
+        minValue = maxValue
+        maxValue = temp
+    }
+
+    // 如果相等
+    else if (maxValue == minValue) {
+        return [maxValue]
+    }
+
+    // 为了变成 -100 ~ 100 需要放大或者缩小的倍数
+    let times100 =
+
+        (function (_value) {
+
+            // 先确定基调，是放大还是缩小
+            let _times100_base = (_value < 100 && _value > -100) ? 10 : 0.1
+
+            // 记录当前缩放倍数
+            let _times100 = -1, _tiemsValue = _value
+
+            while (_times100_base == 10 ?
+                // 如果是放大，超过 -100 ~ 100 就应该停止
+                (_tiemsValue >= -100 && _tiemsValue <= 100)
+                :
+                // 如果是缩小，进入 -100 ~ 100 就应该停止
+                (_tiemsValue <= -100 || _tiemsValue >= 100)
+            ) {
+
+                _times100 += 1
+                _tiemsValue *= _times100_base
+
+            }
+
+            if (_times100_base == 10) {
+                return Math.pow(10, _times100)
+            } else {
+
+                // 解决类似 0.1 * 0.1 = 0.010000000000000002 浮点运算不准确问题
+                let temp = "0."
+                for (let i = 1; i < _times100; i++) {
+                    temp += "0";
+                }
+                return +(temp + "1")
+            }
+        })
+
+            // 根据差值来缩放
+            (maxValue - minValue)
+
+
+    // 求解出 -100 ~ 100 的最佳间距值 后直接转换原来的倍数
+    let distance100 = Math.ceil((maxValue - minValue) * times100 / num)
+
+    // 校对一下
+    distance100 = {
+        3: 2,
+        4: 5,
+        6: 5,
+        7: 5,
+        8: 10,
+        9: 10,
+        11: 10,
+        12: 10,
+        13: 15,
+        14: 15,
+        16: 15,
+        17: 15,
+        18: 20,
+        19: 20,
+        21: 20,
+        22: 20,
+        23: 25,
+        24: 25,
+        26: 25,
+        27: 25
+    }[distance100] || distance100
+
+    let distance = distance100 / times100
+
+    // 最小值，也就是起点
+    let begin = Math.floor(minValue / distance) * distance
+
+    let rulerArray = []
+    // 获取最终的刻度尺数组
+    rulerArray.push(begin)
+    for (let index = 1; rulerArray[rulerArray.length - 1] < maxValue; index++) {
+        rulerArray.push(begin + distance * index)
+    }
+
+    return rulerArray
+}

package/src/viewHandler.ts

@@ -0,0 +1,140 @@
+import { callbackFun } from '../types/viewHandler'
+
+let mousePosition = (el: HTMLElement, event: any) => {
+    let bounding = el.getBoundingClientRect()
+    return {
+        "x": event.clientX - bounding.left,
+        "y": event.clientY - bounding.top
+    }
+}
+
+let getKeyString = (event: any) => {
+    return {
+        37: "left",
+        38: "up",
+        39: "right",
+        40: "down",
+    }[event.keyCode || event.which]
+}
+
+export default function (callback: callbackFun) {
+
+    let el = document.getElementsByTagName('body')[0]
+
+    // 键盘控制
+    el.addEventListener("keydown", function (event) {
+        let keyCode = getKeyString(event)
+
+        // 视角向上
+        if (keyCode == 'up') {
+            callback({
+                type: "lookUp",
+                normal: [],
+                value: 0.1
+            })
+        }
+
+        // 视角向下
+        else if (keyCode == 'down') {
+            callback({
+                type: "lookDown",
+                normal: [],
+                value: 0.1
+            })
+        }
+
+        // 视角向左
+        else if (keyCode == 'left') {
+            callback({
+                type: "lookLeft",
+                normal: [],
+                value: 0.1
+            })
+        }
+
+        // 视角向右
+        else if (keyCode == 'right') {
+            callback({
+                type: "lookRight",
+                normal: [],
+                value: 0.1
+            })
+        }
+
+    })
+
+    // 鼠标控制
+    let mouseP = null;
+    let doMove = function (event) {
+        if (mouseP == null) return
+
+        let tempMouseP = mousePosition(el, event)
+
+        // 先求解出轨迹向量
+        let normal = [tempMouseP.x - mouseP.x, mouseP.y - tempMouseP.y]
+
+        // 方向向量旋转90deg得到旋转向量
+        let rotateNormal = [
+            normal[1],
+            normal[0] * -1,
+            0
+        ]
+
+        // 非法射线忽略
+        if (rotateNormal[0] == 0 && rotateNormal[1] == 0) return
+
+        callback({
+            type: "rotate",
+            normal: rotateNormal,
+            value: (Math.abs(tempMouseP.x - mouseP.x) + Math.abs(tempMouseP.y - mouseP.y)) * 0.01
+        })
+
+        mouseP = tempMouseP
+    }
+
+    el.addEventListener("mousedown", (event) => {
+        mouseP = mousePosition(el, event)
+    })
+    el.addEventListener("mouseup", (event) => {
+        mouseP = null
+    })
+    el.addEventListener("mousemove", (event) => {
+        doMove(event)
+    })
+
+    // 手指控制
+    el.addEventListener("touchend", (event) => {
+        mouseP = null;
+    })
+    el.addEventListener("touchstart", (event) => {
+        mouseP = mousePosition(el, event)
+    })
+    el.addEventListener("touchmove", (event) => {
+        doMove(event.touches[0])
+    })
+
+    let doScale = function (value: number) {
+        if (value == 0) return
+
+        let baseTimes = 0.899
+        callback({
+            type: "scale",
+            value: value < 0 ? baseTimes : 2 - baseTimes,
+            normal: []
+        })
+    }
+
+    // 滚轮控制
+    el.addEventListener("mousewheel", function (event: any) {
+        doScale(event.wheelDelta)
+    })
+
+    if (window.addEventListener) {
+
+        // 针对火狐浏览器
+        window.addEventListener('DOMMouseScroll', function (event: any) {
+            doScale(-1 * event.detail)
+        }, false)
+    }
+
+}