js 以图片上的某个位置来缩放这个图片

"use strict";

var __emptyPoint = null, __emptyContext = null, __emptyPointA = null;

const ColorRefTable = {
    "aliceblue": "#f0f8ff",
    "antiquewhite": "#faebd7",
    "aqua": "#00ffff",
    "aquamarine": "#7fffd4",
    "azure": "#f0ffff",
    "beige": "#f5f5dc",
    "bisque": "#ffe4c4",
    "black": "#000000",
    "blanchedalmond": "#ffebcd",
    "blue": "#0000ff",
    "blueviolet": "#8a2be2",
    "brown": "#a52a2a",
    "burlywood": "#deb887",
    "cadetblue": "#5f9ea0",
    "chartreuse": "#7fff00",
    "chocolate": "#d2691e",
    "coral": "#ff7f50",
    "cornsilk": "#fff8dc",
    "crimson": "#dc143c",
    "cyan": "#00ffff",
    "darkblue": "#00008b",
    "darkcyan": "#008b8b",
    "darkgoldenrod": "#b8860b",
    "darkgray": "#a9a9a9",
    "darkgreen": "#006400",
    "darkgrey": "#a9a9a9",
    "darkkhaki": "#bdb76b",
    "darkmagenta": "#8b008b",
    "firebrick": "#b22222",
    "darkolivegreen": "#556b2f",
    "darkorange": "#ff8c00",
    "darkorchid": "#9932cc",
    "darkred": "#8b0000",
    "darksalmon": "#e9967a",
    "darkseagreen": "#8fbc8f",
    "darkslateblue": "#483d8b",
    "darkslategray": "#2f4f4f",
    "darkslategrey": "#2f4f4f",
    "darkturquoise": "#00ced1",
    "darkviolet": "#9400d3",
    "deeppink": "#ff1493",
    "deepskyblue": "#00bfff",
    "dimgray": "#696969",
    "dimgrey": "#696969",
    "dodgerblue": "#1e90ff",
    "floralwhite": "#fffaf0",
    "forestgreen": "#228b22",
    "fuchsia": "#ff00ff",
    "gainsboro": "#dcdcdc",
    "ghostwhite": "#f8f8ff",
    "gold": "#ffd700",
    "goldenrod": "#daa520",
    "gray": "#808080",
    "green": "#008000",
    "greenyellow": "#adff2f",
    "grey": "#808080",
    "honeydew": "#f0fff0",
    "hotpink": "#ff69b4",
    "indianred": "#cd5c5c",
    "indigo": "#4b0082",
    "ivory": "#fffff0",
    "khaki": "#f0e68c",
    "lavender": "#e6e6fa",
    "lavenderblush": "#fff0f5",
    "lawngreen": "#7cfc00",
    "lemonchiffon": "#fffacd",
    "lightblue": "#add8e6",
    "lightcoral": "#f08080",
    "lightcyan": "#e0ffff",
    "lightgoldenrodyellow": "#fafad2",
    "lightgray": "#d3d3d3",
    "lightgreen": "#90ee90",
    "lightgrey": "#d3d3d3",
    "lightpink": "#ffb6c1",
    "lightsalmon": "#ffa07a",
    "lightseagreen": "#20b2aa",
    "lightskyblue": "#87cefa",
    "lightslategray": "#778899",
    "lightslategrey": "#778899",
    "lightsteelblue": "#b0c4de",
    "lightyellow": "#ffffe0",
    "lime": "#00ff00",
    "limegreen": "#32cd32",
    "linen": "#faf0e6",
    "magenta": "#ff00ff",
    "maroon": "#800000",
    "mediumaquamarine": "#66cdaa",
    "mediumblue": "#0000cd",
    "mediumorchid": "#ba55d3",
    "mediumpurple": "#9370db",
    "mediumseagreen": "#3cb371",
    "mediumslateblue": "#7b68ee",
    "mediumspringgreen": "#00fa9a",
    "mediumturquoise": "#48d1cc",
    "mediumvioletred": "#c71585",
    "midnightblue": "#191970",
    "mintcream": "#f5fffa",
    "mistyrose": "#ffe4e1",
    "moccasin": "#ffe4b5",
    "navajowhite": "#ffdead",
    "navy": "#000080",
    "oldlace": "#fdf5e6",
    "olive": "#808000",
    "olivedrab": "#6b8e23",
    "orange": "#ffa500",
    "orangered": "#ff4500",
    "orchid": "#da70d6",
    "palegoldenrod": "#eee8aa",
    "palegreen": "#98fb98",
    "paleturquoise": "#afeeee",
    "palevioletred": "#db7093",
    "papayawhip": "#ffefd5",
    "peachpuff": "#ffdab9",
    "peru": "#cd853f",
    "pink": "#ffc0cb",
    "plum": "#dda0dd",
    "powderblue": "#b0e0e6",
    "purple": "#800080",
    "red": "#ff0000",
    "rosybrown": "#bc8f8f",
    "royalblue": "#4169e1",
    "saddlebrown": "#8b4513",
    "salmon": "#fa8072",
    "sandybrown": "#f4a460",
    "seagreen": "#2e8b57",
    "seashell": "#fff5ee",
    "sienna": "#a0522d",
    "silver": "#c0c0c0",
    "skyblue": "#87ceeb",
    "slateblue": "#6a5acd",
    "slategray": "#708090",
    "slategrey": "#708090",
    "snow": "#fffafa",
    "springgreen": "#00ff7f",
    "steelblue": "#4682b4",
    "tan": "#d2b48c",
    "teal": "#008080",
    "thistle": "#d8bfd8",
    "tomato": "#ff6347",
    "turquoise": "#40e0d0",
    "violet": "#ee82ee",
    "wheat": "#f5deb3",
    "white": "#ffffff",
    "whitesmoke": "#f5f5f5",
    "yellow": "#ffff00",
    "yellowgreen": "#9acd32"
},

UTILS = {

    get isMobile(){
        return /Android|webOS|iPhone|iPod|BlackBerry|SymbianOS|Windows Phone|iPad/i.test(navigator.userAgent);
    },
    
    emptyArray(arr){
        return !Array.isArray(arr) || arr.length === 0;
    },

    isObject(obj){
        
        return obj !== null && typeof obj === "object" && Array.isArray(obj) === false;
        
    },
    
    isNumber(num){

        return typeof num === "number" && isNaN(num) === false;

    },

    //获取最后一个点后面的字符
    getFileType(string){
        let type = "", str = string.split('').reverse().join('');
        for(let k = 0, len = str.length; k < len; k++){
            if(str[k] === ".") break;
            type += str[k];
        }
        return type.split('').reverse().join('');
    },

    //删除 string 所有的空格
    deleteSpaceAll(str){
        const len = str.length;
        var result = '';
        for(let i = 0; i < len; i++){
            if(str[i] !== '') result += str[i]
        }

        return result
    },

    //删除 string 两边空格
    removeSpaceSides(string){

        return string.replace(/(^\s*)|(\s*$)/g, "");

    },

    //返回 num 与 num1 之间的随机数
    random(num, num1){
        
        if(num < num1) return Math.random() * (num1 - num) + num;

        else if(num > num1) return Math.random() * (num - num1) + num1;

        else return num;
        
    },

    //生成 UUID
    generateUUID: function (){
        const _lut = [];
    
        for ( let i = 0; i < 256; i ++ ) {
    
            _lut[ i ] = ( i < 16 ? '0' : '' ) + ( i ).toString( 16 );
    
        }
    
        return function (){
            const d0 = Math.random() * 0xffffffff | 0;
            const d1 = Math.random() * 0xffffffff | 0;
            const d2 = Math.random() * 0xffffffff | 0;
            const d3 = Math.random() * 0xffffffff | 0;
            const uuid = _lut[ d0 & 0xff ] + _lut[ d0 >> 8 & 0xff ] + _lut[ d0 >> 16 & 0xff ] + _lut[ d0 >> 24 & 0xff ] + '-' +
            _lut[ d1 & 0xff ] + _lut[ d1 >> 8 & 0xff ] + '-' + _lut[ d1 >> 16 & 0x0f | 0x40 ] + _lut[ d1 >> 24 & 0xff ] + '-' +
            _lut[ d2 & 0x3f | 0x80 ] + _lut[ d2 >> 8 & 0xff ] + '-' + _lut[ d2 >> 16 & 0xff ] + _lut[ d2 >> 24 & 0xff ] +
            _lut[ d3 & 0xff ] + _lut[ d3 >> 8 & 0xff ] + _lut[ d3 >> 16 & 0xff ] + _lut[ d3 >> 24 & 0xff ];
    
            return uuid.toLowerCase(); //toLowerCase() 这里展平连接的字符串以节省堆内存空间
        }
    }(),

    //欧几里得距离(两点的直线距离)
    distance(x, y, x1, y1){
        
        return Math.sqrt(Math.pow(x - x1, 2) + Math.pow(y - y1, 2));

    },

    downloadFile(blob, fileName){
        const link = document.createElement("a");
        link.href = URL.createObjectURL(blob);
        link.download = fileName;
        link.click();
    },

    loadFileJSON(callback){
        const input = document.createElement("input");
        input.type = "file";
        input.accept = ".json";
        
        input.onchange = a => {
            if(a.target.files.length === 0) return;
            const fr = new FileReader();
            fr.onloadend = b => callback(b.target.result);
            fr.readAsText(a.target.files[0]); //fr.readAsDataURL(a.target.files[0]);
        }
        
        input.click();
    },

    get emptyPoint(){
        if(__emptyPoint === null) __emptyPoint = new Point();
        return __emptyPoint;
    },

    get emptyPointA(){
        if(__emptyPointA === null) __emptyPointA = new Point();
        return __emptyPointA;
    },

    get emptyContext(){
        if(__emptyContext === null) __emptyContext = document.createElement("canvas").getContext('2d')
        return __emptyContext;
    },

    /* 把 target 以相等的比例缩放至 result 大小
        target, result: Object{width, height}; //也可以是img元素
    */
    setSizeToSameScale(target, result = {width: 100, height: 100}){
        //if(!target) return result;
        const width = target.width,
        height = target.height,
        ratio = width / height,
        scale = ratio < 1 ? ratio * result.width / width : result.width / width;

        result.width = width * scale;
        result.height = height * scale;

        return result;
    },

    //小数保留 count 位
    floatKeep(float, count = 3){
        count = Math.pow(10, count);
        return Math.ceil(float * count) / count;
    },

}




/* SecurityDoor 安检门
作用: 有时候我们要给一个功能加一个启禁用锁, 就比如用一个.enable属性表示此功能是否启用, 
a, b是两个使用此功能的人; a 需要把此功能禁用(.enable = false), 
过了一会b也要禁用此功能(.enable = false), 又过了一会a又要在次启用此功能,
此时a让此功能启用了(.enable = true), 很显然这违背了b, 对于b来说此功能还在禁用状态,
实际并非如b所想, 所以当多个人使用此功能时一个.enable满足不了它们;
或许还有其它解决方法就比如让所有使用此功能的人(a,b)加一个属性表示自己是否可以使用此功能,
但我更希望用一个专门的数组去装载它们, 而不是在某个使用者身上都添加一个属性;

parameter:
    list: Array[];

attribute:
    list: Array; //私有, 默认 null
    empty: Bool; //只读, 列表是否为空

method:
    clear()
    equals(v)
    add(v)
    remove(v)
*/
class SecurityDoor{

    #list = null;
    #onchange = null;

    get empty(){
        return this.#list === null;
    }

    constructor(list, onchange){
        if(UTILS.emptyArray(list) === false) this.#list = list;
        if(typeof onchange === "function") this.#onchange = onchange;
    }

    add(sign){
        if(this.#list !== null){
            if(this.#list.includes(sign) === false) this.#list.push(sign);
        }
        else{
            this.#list = [sign];
            if(this.#onchange !== null) this.#onchange(false);
        }
    }
    
    clear(){
        this.#list = null;
    }

    equals(sign){
        return this.#list !== null && this.#list.includes(sign);
    }

    remove(sign){
        if(this.#list !== null){
            sign = this.#list.indexOf(sign);
            if(sign !== -1){
                if(this.#list.length > 1) this.#list.splice(sign, 1);
                else{
                    this.#list = null;
                    if(this.#onchange !== null) this.#onchange(true);
                }
            }
        }
    }

}




/* RunningList

*/
class RunningList{

    #runName = "";
    #running = false;
    #list = [];
    #disabls = [];

    constructor(runName = 'update'){
        this.#runName = runName;
    }

    clear(){
        this.#list.length = 0;
        this.#disabls.length = 0;
    }

    add(v){
        if(this.#list.includes(v) === false) this.#list.push(v);
        else{
            const i = this.#disabls.indexOf(v);
            if(i !== -1) this.#disabls.splice(i, 1);
        }
    }

    remove(v){
        if(this.#running) this.#disabls.push(v);
        else{
            const i = this.#list.indexOf(v);
            if(i !== -1) this.#list.splice(i, 1);
        }
    }

    update(){
        var len = this.#list.length;
        if(len === 0) return;

        var k;
        this.#running = true;
        if(this.#runName !== ''){
            for(k = 0; k < len; k++) this.#list[k][this.#runName]();
        }else{
            for(k = 0; k < len; k++) this.#list[k]();
        }
        this.#running = false;

        var i;
        len = this.#disabls.length;
        for(k = 0; k < len; k++){
            i = this.#list.indexOf(this.#disabls[k]);
            if(i !== -1) this.#list.splice(i, 1);
        }
        this.#disabls.length = 0;
    }

}




/* AnimateLoop 动画循环
attributes:
    onupdate: Func;
    //只读:
    running: Bool;
    
method:
    play(onupdate: Func): this; //onupdate 可选
    stop(): this;
    update(): undefined; //使用前必须已定义.onupdate 属性
*/
class AnimateLoop{

    #id = -1;
    #animate = null;

    get running(){
        return this.#id !== -1;
    }

    constructor(onupdate = null){
        const animate = () => {
            this.#id = requestAnimationFrame(animate);
            this.onupdate();
        }

        this.#animate = animate;
        this.onupdate = onupdate;
    }

    stop(){
        if(this.#id !== -1){
            cancelAnimationFrame(this.#id);
            this.#id = -1;
        }
        return this;
    }

    play(onupdate){
        if(typeof onupdate === "function") this.onupdate = onupdate;
        if(this.onupdate !== null){
            this.stop();
            this.#animate();
        }
        return this;
    }

    update(){
        if(this.#id === -1){
            this.onupdate();
        }
    }

}




/** Ajax
parameter:
    option = {
        url:        可选, 默认 ''
        method:        可选, post 或 get请求， 默认 post
        asy:        可选, 是否异步执行, 默认 true
        success:    可选, 成功回调, 默认 null
        error:        可选, 超时或失败调用, 默认 null
        change:        可选, 请求状态改变时调用, 默认 null
        data:        可选, 如果定义则在初始化时自动执行.send(data)方法
    }

demo:
    const data = `email=${email}&password=${password}`,

    //默认 post 请求:
    ajax = new Ajax({
        url: './login',
        data: data,
        success: mes => console.log(mes),
    });
    
    //get 请求:
    ajax.method = "get";
    ajax.send(data);
*/
class Ajax{
    
    constructor(option = {}){
        this.url = option.url || "";
        this.method = option.method || "post";
        this.asy = typeof option.asy === "boolean" ? option.asy : true;
        this.success = option.success || null;
        this.error = option.error || null;
        this.change = option.change || null;

        //init XML
        this.xhr = new XMLHttpRequest();

        this.xhr.onerror = this.xhr.ontimeout = option.error || null;

        this.xhr.onreadystatechange = event => {
        
            if(event.target.readyState === 4 && event.target.status === 200){

                if(this.success !== null) this.success(event.target.responseText, event);
                
            }

            else if(this.change !== null) this.change(event);

        }

        if(option.data) this.send(option.data);
    }

    send(data = ""){
        if(this.method === "get"){
            this.xhr.open(this.method, this.url+"?"+data, this.asy);
            this.xhr.send();
        }
        
        else if(this.method === "post"){
            this.xhr.open(this.method, this.url, this.asy);
            this.xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
            this.xhr.send(data);
        }
    }
    
}




/* IndexedDB 本地数据库

parameter:
    name: String;                //需要打开的数据库名称(如果不存在则会新建一个) 必须
    done: Function(IndexedDB);    //链接数据库成功时的回调 默认 null
    version: Number;             //数据库版本(高版本数据库将覆盖低版本的数据库) 默认 1 

attribute:
    database: IndexedDB;            //链接完成的数据库对象
    transaction: IDBTransaction;    //事务管理(读和写)
    objectStore: IDBObjectStore;    //当前的事务

method:
    set(data, key, callback)        //添加或更新
    get(key, callback)                //获取
    delete(key, callback)            //删除

    traverse(callback)                //遍历
    getAll(callback)                //获取全部
    clear(callback)                    //清理所以数据
    close()                         //关闭数据库链接

readOnly:

static:
    indexedDB: Object;

demo:
    
    new IndexedDB('TEST', db => {

        conosle.log(db);

    });

*/
class IndexedDB{

    static indexedDB = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;

    get objectStore(){ //每个事务只能使用一次, 所以每次都需要重新创建
        return this.database.transaction(this.name, 'readwrite').objectStore(this.name);
    }

    constructor(name, done = null, version = 1){

        if(IndexedDB.indexedDB === undefined) return console.error("IndexedDB: 不支持IndexedDB");
        
        if(typeof name !== 'string') return console.warn('IndexedDB: 参数错误');

        this.name = name;
        this.database = null;

        const request = IndexedDB.indexedDB.open(name, version);
        
        request.onupgradeneeded = (e)=>{ //数据库不存在 或 版本号不同时 触发
            if(!this.database) this.database = e.target.result;
            if(this.database.objectStoreNames.contains(name) === false) this.database.createObjectStore(name);
        }
        
        request.onsuccess = (e)=>{
            this.database = e.target.result;
            if(typeof done === 'function') done(this);
        }
        
        request.onerror = (e)=>{
            console.error(e);
        }
        
    }

    close(){

        return this.database.close();

    }

    clear(callback){
        
        this.objectStore.clear().onsuccess = callback;
        
    }

    traverse(callback){
        
        this.objectStore.openCursor().onsuccess = callback;

    }

    set(data, key = 0, callback){
        
        this.objectStore.put(data, key).onsuccess = callback;

    }
    
    get(key = 0, callback){

        this.objectStore.get(key).onsuccess = callback;
        
    }

    del(key = 0, callback){

        this.objectStore.delete(key).onsuccess = callback;

    }
    
    getAll(callback){

        this.objectStore.getAll().onsuccess = callback;

    }

}




/* TreeStruct 树结构基类

attribute:
    parent: TreeStruct;
    children: Array[TreeStruct];

method:
    add(v: TreeStruct): v;         //v添加到自己的子集
    remove(v: TreeStruct): v;     //删除v, 前提v必须是自己的子集
    export(): Array[Object];    //TreeStruct 转为 可导出的结构, 包括其所有的后代

    getPath(v: TreeStruct): Array[TreeStruct];     //获取自己到v的路径

    traverse(callback: Function): undefined;  //迭代自己的每一个后代, 包括自己
        callback(value: TreeStruct); //如返回 "continue" 则不在迭代其后代(不是结束迭代, 而是只结束当前节点的后代);

    traverseUp(callback): undefined; //向上遍历每一个父, 包括自己
        callback(value: TreeStruct); //如返回 "break" 立即停止遍历;

static:
    import(arr: Array[Object]): TreeStruct; //.export() 返回的 arr 转为 TreeStruct

*/
class TreeStruct{

    static import(arr){

        //json = JSON.parse(json);
        const len = arr.length;

        for(let k = 0, v; k < len; k++){
            v = Object.assign(new TreeStruct(), arr[k]);
            v.parent = arr[arr[k].parent] || null;
            if(v.parent !== null) v.parent.appendChild(v);
            arr[k] = v;
        }

        return arr[0];

    }

    constructor(){
        this.parent = null;
        this.children = [];
    }

    getPath(v){

        var path;

        const pathA = [];
        this.traverseUp(tar => {
            if(v === tar){
                path = pathA;
                return "break";
            }
            pathA.push(tar);
        });

        if(path) return path;

        const pathB = [];
        v.traverseUp(tar => {
            if(this === tar){
                path = pathB.reverse();
                return "break";
            }
            else{
                let i = pathA.indexOf(tar);
                if(i !== -1){
                    pathA.splice(i);
                    pathA.push(tar);
                    path = pathA.concat(pathB.reverse());
                    return "break";
                }
            }
            pathB.push(tar);
        });

        return path;
        
    }

    appendChild(v){
        v.parent = this;
        if(this.children.includes(v) === false) this.children.push(v);
        
        return v;
    }

    removeChild(v){
        const i = this.children.indexOf(v);
        if(i !== -1) this.children.splice(i, 1);
        v.parent = null;

        return v;
    }

    traverse(callback){

        if(callback(this) !== "continue"){

            for(let k = 0, len = this.children.length; k < len; k++){

                this.children[k].traverse(callback);
    
            }

        }

    }

    traverseUp(callback){

        var par = this.parent;

        while(par !== null){
            if(callback(par) === "break") return;
            par = par.parent;
        }

    }

    export(){

        const result = [], arr = [];
        var obj = null;

        this.traverse(v => {
            obj = Object.assign({}, v);
            obj.parent = arr.indexOf(v.parent);
            delete obj.children;
            result.push(obj);
            arr.push(v);
        });
        
        return result; //JSON.stringify(result);

    }

}




/* Point
parameter: 
    x = 0, y = 0;

attribute
    x, y: Number;

method:
    set(x, y): this;
    angle(origin): Number;
    copy(point): this;
    clone(): Point;
    distance(point): Number;            //获取欧几里得距离
    distanceMHD(point): Number;            //获取曼哈顿距离
    distanceCompare(point): Number;        //获取用于比较的距离(相对于.distance() 效率更高)
    equals(point): Bool;                //是否恒等
    reverse(): this;                    //取反值
    rotate(origin: Object{x,y}, angle): this;    //旋转点
    normalize(): this;                    //归一
*/
class Point{

    constructor(x = 0, y = 0){
        this.x = x;
        this.y = y;
    }

    set(x = 0, y = 0){
        this.x = x;
        this.y = y;

        return this;
    }

    angle(origin){

        return Math.atan2(this.y - origin.y, this.x - origin.x);

    }

    copy(point){
        
        this.x = point.x;
        this.y = point.y;
        return this;
        //return Object.assign(this, point);

    }
    
    clone(){

        return new this.constructor().copy(this);
        //return Object.assign(new this.constructor(), this);
        
    }

    distance(point){
        
        return Math.sqrt(Math.pow(point.x - this.x, 2) + Math.pow(point.y - this.y, 2));

    }

    distanceMHD(point){

        return Math.abs(this.x - point.x) + Math.abs(this.y - point.y);

    }

    distanceCompare(point){
    
        return Math.pow(this.x - point.x, 2) + Math.pow(this.y - point.y, 2);

    }

    equals(point){

        return point.x === this.x && point.y === this.y;

    }

    reverse(){
        this.x = -this.x;
        this.y = -this.y;

        return this;
    }

    rotate(origin, angle){
        const c = Math.cos(angle), s = Math.sin(angle), 
        x = this.x - origin.x, y = this.y - origin.y;

        this.x = x * c - y * s + origin.x;
        this.y = x * s + y * c + origin.y;

        return this;
    }

    normalize(){
        const len = 1 / (Math.sqrt(this.x * this.x + this.y * this.y) || 1);
        this.x *= len;
        this.y *= len;

        return this;
    }

/*     add(point){
        this.x += point.x;
        this.y += point.y;
        return this;
    }

    sub(point){
        this.x -= point.x;
        this.y -= point.y;
        return this;
    }

    multiply(point){
        this.x *= point.x;
        this.y *= point.y;
        return this;
    }

    divide(point){
        this.x /= point.x;
        this.y /= point.y;
        return this;
    } */

}




/* Rotate
parameter:
    x, y, a = 0

attribute:
    angle: Number;
    origin: Point;

method:
    set(x, y, a): this;
*/
class Rotate{

    constructor(x, y, a = 0){
        this.angle = a;
        this.origin = new Point(x, y);
    }

    set(x, y, a){
        this.origin.x = x;
        this.origin.y = y;
        this.angle = a;
        return this;
    }

    pos(x, y){
        this.origin.x = x;
        this.origin.y = y;
        return this;
    }

    copy(rotate){
        this.angle = rotate.angle;
        this.origin.copy(rotate.origin);
        return this;
    }
    
    clone(){
        return new this.constructor().copy(this);
    }

    toAngle(v){
        this.angle = v / 180 * Math.PI;
        return this;
    }

}




/* Line
parameter: x, y, x1, y1: Number;
attribute: x, y, x1, y1: Number;
method:
    set(x, y, x1, y1): this;                    
    copy(line): this;
    clone(): Line;
    containsPoint(x, y): Bool;                             //点是否在线上
    intersectPoint(line: Line, point: Point): Point;    //如果不相交则返回null, 否则返回交点Point
    isIntersect(line): Bool;                             //this与line是否相交
*/
class Line{

    constructor(x = 0, y = 0, x1 = 0, y1 = 0){
        this.x = x;
        this.y = y;
        this.x1 = x1;
        this.y1 = y1;
    }

    set(x = 0, y = 0, x1 = 0, y1 = 0){
        this.x = x;
        this.y = y;
        this.x1 = x1;
        this.y1 = y1;
        return this;
    }

    copy(line){
        this.x = line.x;
        this.y = line.y;
        this.x1 = line.x1;
        this.y1 = line.y1;
        return this;
        //return Object.assign(this, line);
    }
    
    clone(){
        return new this.constructor().copy(this);
        //return Object.assign(new this.constructor(), this);
    }

    containsPoint(x, y){
        return (x - this.x) * (x - this.x1) <= 0 && (y - this.y) * (y - this.y1) <= 0;
    }

    intersectPoint(line, point){
        //解线性方程组, 求线段交点
        //如果分母为0则平行或共线, 不相交
        var denominator = (this.y1 - this.y) * (line.x1 - line.x) - (this.x - this.x1) * (line.y - line.y1);
        if(denominator === 0) return null;

        //线段所在直线的交点坐标 (x , y)
        const x = ((this.x1 - this.x) * (line.x1 - line.x) * (line.y - this.y) 
        + (this.y1 - this.y) * (line.x1 - line.x) * this.x 
        - (line.y1 - line.y) * (this.x1 - this.x) * line.x) / denominator;

        const y = -((this.y1 - this.y) * (line.y1 - line.y) * (line.x - this.x) 
        + (this.x1 - this.x) * (line.y1 - line.y) * this.y 
        - (line.x1 - line.x) * (this.y1 - this.y) * line.y) / denominator;

        //判断交点是否在两条线段上
        if(this.containsPoint(x, y) && line.containsPoint(x, y)){
            point.x = x;
            point.y = y;
            return point;
        }

        return null;
    }

    isIntersect(line){
        //快速排斥：
        //两个线段为对角线组成的矩形，如果这两个矩形没有重叠的部分，那么两条线段是不可能出现重叠的

        //这里的确如此，这一步是判定两矩形是否相交
        //1.线段ab的低点低于cd的最高点（可能重合）
        //2.cd的最左端小于ab的最右端（可能重合）
        //3.cd的最低点低于ab的最高点（加上条件1，两线段在竖直方向上重合）
        //4.ab的最左端小于cd的最右端（加上条件2，两直线在水平方向上重合）
        //综上4个条件，两条线段组成的矩形是重合的
        //特别要注意一个矩形含于另一个矩形之内的情况
        if(!(Math.min(this.x,this.x1)<=Math.max(line.x,line.x1) && Math.min(line.y,line.y1)<=Math.max(this.y,this.y1) && Math.min(line.x,line.x1)<=Math.max(this.x,this.x1) && Math.min(this.y,this.y1)<=Math.max(line.y,line.y1))) return false;

        //跨立实验：
        //如果两条线段相交，那么必须跨立，就是以一条线段为标准，另一条线段的两端点一定在这条线段的两段
        //也就是说a b两点在线段cd的两端，c d两点在线段ab的两端
        var u=(line.x-this.x)*(this.y1-this.y)-(this.x1-this.x)*(line.y-this.y),
        v = (line.x1-this.x)*(this.y1-this.y)-(this.x1-this.x)*(line.y1-this.y),
        w = (this.x-line.x)*(line.y1-line.y)-(line.x1-line.x)*(this.y-line.y),
        z = (this.x1-line.x)*(line.y1-line.y)-(line.x1-line.x)*(this.y1-line.y);
        
        return u*v <= 0.00000001 && w*z <= 0.00000001;
    }

}




/* Box 矩形
parameter: 
    x = 0, y = 0, w = 0, h = 0;

attribute:
    x,y: Number; 位置
    w,h: Number; 大小

    只读
    mx, my: Number; //

method:
    set(x, y, w, h): this;
    pos(x, y): this; //设置位置
    size(w, h): this; //设置大小
    setFromRotate(rotate: Rotate): this;        //根据 rotate 旋转自己
    setFromShapeRect(shapeRect): this;            //ShapeRect 转为 Box (忽略 ShapeRect 的旋转和缩放)
    setFromCircle(circle, inner: Bool): this;    //
    setFromPolygon(polygon, inner = true): this;//
    toArray(array: Array, index: Integer): this;
    copy(box): this;                             //复制
    clone(): Box;                                  //克隆
    center(box): this;                            //设置位置在box居中
    distance(x, y): Number;                     //左上角原点 与 x,y 的直线距离
    isEmpty(): Boolean;                         //.w.h是否小于等于零
    maxX(): Number;                             //返回 max x(this.x+this.w);
    maxY(): Number;                             //返回 max y(this.y+this.h);
    expand(box): undefined;                     //扩容; 把box合并到this
    equals(box): Boolean;                         //this与box是否恒等
    intersectsBox(box): Boolean;                 //box与this是否相交(box在this内部也会返回true)
    containsPoint(x, y): Boolean;                 //x,y点是否在this内
    containsBox(box): Boolean;                    //box是否在this内(只是相交返回fasle)
    computeOverflow(b: Box, r: Box): undefined;    //this相对b超出的部分赋值到r; r的size小于或等于0的话说明完全超出
*/
class Box{

    get mx(){
        return this.x + this.w;
    }

    get my(){
        return this.y + this.h;
    }

    get cx(){
        return this.w / 2 + this.x;
    }

    get cy(){
        return this.h / 2 + this.y;
    }

    constructor(x = 0, y = 0, w = 0, h = 0){
        //this.set(x, y, w, h);
        this.x = x;
        this.y = y;
        this.w = w;
        this.h = h;
    }
    
    set(x, y, w, h){
        this.x = x;
        this.y = y;
        this.w = w;
        this.h = h;
        return this;
    }

    pos(x, y){
        this.x = x;
        this.y = y;
        return this;
    }
    
    size(w, h){
        this.w = w;
        this.h = h;
        return this;
    }

    setFromRotate(rotate){
        var minX = this.x, minY = this.y, maxX = 0, maxY = 0;
        const point = UTILS.emptyPoint,
        run = function (){
            if(point.x < minX) minX = point.x;
            else if(point.x > maxX) maxX = point.x;
            if(point.y < minY) minY = point.y;
            else if(point.y > maxY) maxY = point.y;
        }

        point.set(this.x, this.y).rotate(rotate.origin, rotate.angle); run();
        point.set(this.mx, this.y).rotate(rotate.origin, rotate.angle); run();
        point.set(this.mx, this.my).rotate(rotate.origin, rotate.angle); run();
        point.set(this.x, this.my).rotate(rotate.origin, rotate.angle); run();

        this.x = minX;
        this.y = minY;
        this.w = maxX - minX;
        this.h = maxY - minY;

        return this;
    }

    setFromShapeRect(shapeRect){
        this.width = shapeRect.width;
        this.height = shapeRect.height;
        this.x = shapeRect.position.x - this.width / 2;
        this.y = shapeRect.position.y - this.height / 2;
        return this;
    }

    setFromCircle(circle, inner = true){
        if(inner === true){
            this.x = Math.sin(-135 / 180 * Math.PI) * circle.r + circle.x;
            this.y = Math.cos(-135 / 180 * Math.PI) * circle.r + circle.y;
            this.w = this.h = Math.sin(135 / 180 * Math.PI) * circle.r + circle.x - this.x;
        }

        else{
            this.x = circle.x - circle.r;
            this.y = circle.y - circle.r;
            this.w = this.h = circle.r * 2;
        }
        return this;
    }

    setFromPolygon(polygon, inner = true){
        if(inner === true){
            console.warn('Box: 暂不支持第二个参数为true');
        }

        else{
            const len = polygon.path.length;
            let x = Infinity, y = Infinity, mx = 0, my = 0;
            for(let k = 0, v; k < len; k+=2){
                v = polygon.path[k];
                if(v < x) x = v;
                else if(v > mx) mx = v;

                v = polygon.path[k+1];
                if(v < y) y = v;
                else if(v > my) my = v;

            }

            this.set(x, y, mx - x, my - y);

        }
        return this;
    }

    toArray(array, index){
        array[index] = this.x;
        array[index+1] = this.y;
        array[index+2] = this.w;
        array[index+3] = this.h;

        return this;
    }

    copy(box){
        this.x = box.x;
        this.y = box.y;
        this.w = box.w;
        this.h = box.h;
        return this;
        //return Object.assign(this, box); //this.set(box.x, box.y, box.w, box.h);
    }
    
    clone(){
        return new this.constructor().copy(this);
        //return Object.assign(new this.constructor(), this);
    }

    center(box){
        this.x = (box.w - this.w) / 2 + box.x;
        this.y = (box.h - this.h) / 2 + box.y;
        return this;
    }

    distance(x, y){
        return Math.sqrt(Math.pow(this.x - x, 2) + Math.pow(this.y - y, 2));
    }

    isEmpty(){
        return this.w <= 0 || this.h <= 0;
    }

    maxX(){
        return this.x + this.w;
    }

    maxY(){
        return this.y + this.h;
    }

    equals(box){
        return this.x === box.x && this.w === box.w && this.y === box.y && this.h === box.h;
    }

    expand(box){
        var v = Math.min(this.x, box.x);
        this.w = Math.max(this.x + this.w - v, box.x + box.w - v);
        this.x = v;

        v = Math.min(this.y, box.y);
        this.h = Math.max(this.y + this.h - v, box.y + box.h - v);
        this.y = v;
    }

    intersectsBox(box){
        return box.x + box.w < this.x || box.x > this.x + this.w || box.y + box.h < this.y || box.y > this.y + this.h ? false : true;
    }

    containsPoint(x, y){
        return x < this.x || x > this.x + this.w || y < this.y || y > this.y + this.h ? false : true;
    }

    containsBox(box){
        return this.x <= box.x && box.x + box.w <= this.x + this.w && this.y <= box.y && box.y + box.h <= this.y + this.h;
    }

    computeOverflow(p, r){
        r["copy"](this);
        
        if(this["x"] < p["x"]){
            r["x"] = p["x"];
            r["w"] -= p["x"] - this["x"];
        }

        if(this["y"] < p["y"]){
            r["y"] = p["y"];
            r["h"] -= p["y"] - this["y"];
        }

        var m = p["x"] + p["w"];
        if(r["x"] + r["w"] > m) r["w"] = m - r["x"];

        m = p["y"] + p["h"];
        if(r["y"] + r["h"] > m) r["h"] = m - r["y"];
    }
    
}




/* Circle 圆形
parameter:
attribute:
    x,y: Number; 中心点
    r: Number; 半径

    //只读
    r2: Number; //返回直径 r*2

method:
    set(x, y, r): this;
    pos(x, y): this;
    copy(circle: Circle): this;
    clone(): Circle;
    distance(x, y): Number;
    equals(circle: Circle): Bool;
    expand(circle: Circle): undefined;                     //扩容; 把circle合并到this
    containsPoint(x, y): Bool; 
    intersectsCircle(circle: Circle): Bool;
    intersectsBox(box: Box): Bool;
    setFromBox(box, inner = true): this;

*/
class Circle{

    get r2(){
        return this.r * 2;
    }

    constructor(x = 0, y = 0, r = -1){
        //this.set(0, 0, -1);
        this.x = x;
        this.y = y;
        this.r = r;
    }

    set(x, y, r){
        this.x = x;
        this.y = y;
        this.r = r;

        return this;
    }

    setFromBox(box, world = true, inner = true){
        this.x = box.w / 2 + (world === true ? box.x : 0);
        this.y = box.h / 2 + (world === true ? box.y : 0);
        this.r = inner === true ? Math.min(box.w, box.h) / 2 : UTILS.distance(0, 0, box.w, box.h) / 2;
    
        return this;
    }

    toArray(array, index){
        array[index] = this.x;
        array[index+1] = this.y;
        array[index+2] = this.r;
        
        return this;
    }

    pos(x, y){
        this.x = x;
        this.y = y;

        return this;
    }

    copy(circle){
        this.r = circle.r;
        this.x = circle.x;
        this.y = circle.y;

        return this;
    }

    clone(){

        return new this.constructor().copy(this);

    }

    distance(x, y){
        
        return Math.sqrt(Math.pow(this.x - x, 2) + Math.pow(this.y - y, 2));

    }

    expand(circle){

    }

    equals(circle){

        return circle.x === this.x && circle.y === this.y && circle.r === this.r;

    }

    containsPoint(x, y){

        return (Math.pow(x - this.x, 2) + Math.pow(y - this.y, 2) <= Math.pow(this.r, 2));

    }

    intersectsCircle(circle){

        return (Math.pow(circle.x - this.x, 2) + Math.pow(circle.y - this.y, 2) <= Math.pow(circle.r + this.r, 2));

    }

    intersectsBox(box){
        
        return (Math.pow(Math.max(box.x, Math.min(box.x + box.w, this.x)) - this.x, 2) + Math.pow(Math.max(box.y, Math.min(box.y + box.h, this.y)) - this.y, 2) <= Math.pow(this.r, 2));
    
    }

}




/* Polygon 多边形

parameter: 
    path: Array[x, y];

attribute:

    //只读属性
    path: Array[x, y]; 

method:
    add(x, y): this;             //x,y添加至path;
    containsPoint(x, y): Bool;    //x,y是否在多边形的内部(注意: 在路径上也返回 true)
    
*/
class Polygon{

    #position = null;
    #path2D = null;

    get path(){
        
        return this.#position;

    }

    constructor(path = []){
        this.#position = path;

        this.#path2D = new Path2D();
        
        var len = path.length;
        if(len >= 2){
            if(len % 2 !== 0){
                len -= 1;
                path.splice(len, 1);
            }

            const con = this.#path2D;
            con.moveTo(path[0], path[1]);
            for(let k = 2; k < len; k+=2) con.lineTo(path[k], path[k+1]);
            
        }

    }

    add(x, y){
        this.#position.push(x, y);
        this.#path2D.lineTo(x, y);
        return this;
    }

    containsPoint(x, y){
        
        return UTILS.emptyContext.isPointInPath(this.#path2D, x, y);

    }

    isInPolygon(checkPoint, polygonPoints) {
        var counter = 0;
        var i;
        var xinters;
        var p1, p2;
        var pointCount = polygonPoints.length;
        p1 = polygonPoints[0];
        for (i = 1; i <= pointCount; i++) {
            p2 = polygonPoints[i % pointCount];
            if (
                checkPoint[0] > Math.min(p1[0], p2[0]) &&
                checkPoint[0] <= Math.max(p1[0], p2[0])
            ) {
                if (checkPoint[1] <= Math.max(p1[1], p2[1])) {
                    if (p1[0] != p2[0]) {
                        xinters =
                            (checkPoint[0] - p1[0]) *
                                (p2[1] - p1[1]) /
                                (p2[0] - p1[0]) +
                            p1[1];
                        if (p1[1] == p2[1] || checkPoint[1] <= xinters) {
                            counter++;
                        }
                    }
                }
            }
            p1 = p2;
        }
        if (counter % 2 == 0) {
            return false;
        } else {
            return true;
        }
    }

    containsPolygon(polygon){
        const path = polygon.path, len = path.length;
        for(let k = 0; k < len; k += 2){
            if(this.containsPoint(path[k], path[k+1]) === false) return false;
        }

        return true;
    }

    toPoints(){
        const path = this.path, len = path.length, result = [];
        
        for(let k = 0; k < len; k += 2) result.push(new Point(path[k], path[k+1]));

        return result;
    }

    toLines(){
        const path = this.path, len = path.length, result = [];
        
        for(let k = 0, x = NaN, y; k < len; k += 2){

            if(isNaN(x)){
                x = path[k];
                y = path[k+1];
                continue;
            }

            const line = new Line(x, y, path[k], path[k+1]);
            
            x = line.x1;
            y = line.y1;

            result.push(line);

        }

        return result;
    }

    merge(polygon){

        const linesA = this.toLines(), linesB = polygon.toLines(), nodes = [], newLines = [],
        
        pointA = new Point(), pointB = new Point(),

        forEachNodes = (pathA, pathB, funcA = null, funcB = null) => {
            for(let k = 0, lenA = pathA.length, lenB = pathB.length; k < lenA; k++){
                if(funcA !== null) funcA(pathA[k]);

                for(let i = 0; i < lenB; i++){
                    if(funcB !== null) funcB(pathB[i], pathA[k]);
                }
    
            }
        }

        if(this.containsPolygon(polygon)){console.log('this -> polygon');
            forEachNodes(linesA, linesB, lineA => newLines.push(lineA), (lineB, lineA) => {
                if(lineA.intersectPoint(lineB, pointA) === pointA) newLines.push(pointA.clone());
            });

            return newLines;
        }

        //收集所有的交点 (保存至 line)
        forEachNodes(linesA, linesB, lineA => lineA.nodes = [], (lineB, lineA) => {
            if(lineB.nodes === undefined) lineB.nodes = [];
            if(lineA.intersectPoint(lineB, pointA) === pointA){
                const node = {
                    lineA: lineA, 
                    lineB: lineB, 
                    point: pointA.clone(),
                    disA: pointA.distanceCompare(pointB.set(lineA.x, lineA.y)),
                    disB: pointA.distanceCompare(pointB.set(lineB.x, lineB.y)),
                }
                lineA.nodes.push(node);
                lineB.nodes.push(node);
                nodes.push(node);
            }
        });

        //交点以原点为目标排序
        for(let k = 0, sotr = function (a,b){return a.disA - b.disA;}, countA = linesA.length; k < countA; k++) linesA[k].nodes.sort(sotr);
        for(let k = 0, sotr = function (a,b){return a.disB - b.disB;}, countB = linesB.length; k < countB; k++) linesB[k].nodes.sort(sotr);

        var _loopTypeA, _loopTypeB;
        const result_loop = {
            lines: null,
            loopType: '',
            line: null,
            count: 0,
            indexed: 0,
        },
        
        //遍历某条线
        loop = (lines, index, loopType) => {
            const length = lines.length, indexed = lines.length, model = lines === linesA ? polygon : this;
        
            var line, i = 1;
            while(true){
                if(loopType === 'next') index = index === length - 1 ? 0 : index + 1;
                else if(loopType === 'back') index = index === 0 ? length - 1 : index - 1;
                line = lines[index];

                result_loop.count = line.nodes.length;
                if(result_loop.count !== 0){
                    result_loop.lines = lines;
                    result_loop.loopType = loopType;
                    result_loop.line = line;
                    result_loop.indexed = index;
                    if(loopType === 'next') addLine(line, model);

                    return result_loop;
                }
                
                addLine(line, model);
                if(indexed === i++) break;

            }
            
        },

        //更新或创建交点的索引
        setNodeIndex = (lines, index, loopType) => {
            const line = lines[index], count = line.nodes.length;
            if(loopType === undefined) loopType = lines === linesA ? _loopTypeA : _loopTypeB;

            if(loopType === undefined) return;
            
            if(line.nodeIndex === undefined){
                line.nodeIndex = loopType === 'next' ? 0 : count - 1;
                line.nodeState = count === 1 ? 'end' : 'start';
            
            }

            else{
                if(line.nodeState === 'end' || line.nodeState === ''){
                    line.nodeState = '';
                    return;
                }

                if(loopType === 'next'){
                    line.nodeIndex += 1;

                    if(line.nodeIndex === count - 1) line.nodeState = 'end';
                    else line.nodeState = 'run';
                }

                else if(loopType === 'back'){
                    line.nodeIndex -= 1;

                    if(line.nodeIndex === 0) line.nodeState = 'end';
                    else line.nodeState = 'run';
                }

            }

        },

        //只有在跳线的时候才执行此方法, 如果跳线的话: 某条线上的交点必然在两端;
        getLoopType = (lines, index, nodePoint) => {
            const line = lines[index], lineNext = lines[index === lines.length - 1 ? 0 : index + 1],

            model = lines === linesA ? polygon : this,
            isLineBack = newLines.includes(line) === false && model.containsPoint(line.x, line.y) === false,
            isLineNext = newLines.includes(lineNext) === false && model.containsPoint(lineNext.x, lineNext.y) === false;
            
            if(isLineBack && isLineNext){
                const len = line.nodes.length;
                if(len >= 2){
                    if(line.nodes[len - 1].point.equals(nodePoint)) return 'next';
                    else if(line.nodes[0].point.equals(nodePoint)) return 'back';
                }
                
                else console.warn('路径复杂', line);
                
            }

            else if(isLineNext){
                return 'next';
            }

            else if(isLineBack){
                return 'back';
            }

            return '';
        },

        //添加线至新的形状数组
        addLine = (line, model) => {
            //if(newLines.includes(line) === false && model.containsPoint(line.x, line.y) === false) newLines.push(line);
            if(line.nodes.length === 0) newLines.push(line);
            else if(model.containsPoint(line.x, line.y) === false) newLines.push(line);
            
        },

        //处理拥有交点的线
        computeNodes = v => {
            if(v === undefined || v.count === 0) return;
            
            setNodeIndex(v.lines, v.indexed, v.loopType);
        
            //添加交点
            const node = v.line.nodes[v.line.nodeIndex];
            if(newLines.includes(node.point) === false) newLines.push(node.point);
            else return;

            var lines = v.lines === linesA ? linesB : linesA, 
            line = lines === linesA ? node.lineA : node.lineB, 
            index = lines.indexOf(line);

            setNodeIndex(lines, index);
        
            //选择交点状态
            var nodeState = line.nodeState !== undefined ? line.nodeState : v.line.nodeState;
            if((v.count <= 2 && line.nodes.length > 2) || (v.count > 2 && line.nodes.length <= 2)){
                if(line.nodeState === 'start'){
                    const backLine = v.loopType === 'next' ? v.lines[v.indexed === 0 ? v.lines.length-1 : v.indexed-1] : v.lines[v.indexed === v.lines.length-1 ? 0 : v.indexed+1];
                    
                    if(newLines.includes(backLine) && backLine.nodes.length === 0){
                        nodeState = 'run';
                    }

                }
                else if(line.nodeState === 'end'){
                    const nextLine = v.loopType === 'next' ? v.lines[v.indexed === v.lines.length-1 ? 0 : v.indexed+1] : v.lines[v.indexed === 0 ? v.lines.length-1 : v.indexed-1];
                    const model = v.lines === linesA ? polygon : this;
                    if(model.containsPoint(nextLine.x, nextLine.y) === false && nextLine.nodes.length === 0){
                        nodeState = 'run';
                    }
                    
                }
            }

            switch(nodeState){

                //不跳线
                case 'run': 
                    if(v.loopType === 'back') addLine(v.line, v.lines === linesA ? polygon : this);
                    return computeNodes(loop(v.lines, v.indexed, v.loopType));

                //跳线
                case 'start': 
                case 'end': 
                    const loopType = getLoopType(lines, index, node.point);
                    if(loopType !== ''){
                        if(lines === linesA) _loopTypeA = loopType;
                        else _loopTypeB = loopType;
                        if(loopType === 'back') addLine(line, v.lines === linesA ? this : polygon);
                        return computeNodes(loop(lines, index, loopType));
                    }
                    break;

            }

        }
        
        //获取介入点
        var startLine = null;
        for(let k = 0, len = nodes.length, node; k < len; k++){
            node = nodes[k];
            if(node.lineA.nodes.length !== 0){
                startLine = node.lineA;
                if(node.lineA.nodes.length === 1 && node.lineB.nodes.length > 1){
                    startLine = node.lineB.nodes[0].lineB;
                    result_loop.lines = linesB;
                    result_loop.loopType = _loopTypeB = 'next';
                }
                else{
                    result_loop.lines = linesA;
                    result_loop.loopType = _loopTypeA = 'next';
                }
                result_loop.line = startLine;
                result_loop.count = startLine.nodes.length;
                result_loop.indexed = result_loop.lines.indexOf(startLine);
                break;
            }
        }

        if(startLine === null){
            console.warn('Polygon: 找不到介入点, 终止了合并');
            return newLines;
        }

        computeNodes(result_loop);
    
        return newLines;
    }

}




/* ShapeRect (一般2d矩形的原点在左上, 此矩形类的原点在中间)
parameter: 
    width = 0, height = 0

attribute: 
    width, height: Number;     //矩形的宽高
    position: Point;        //位置(是旋转和缩放的中心点)
    rotation: Number;        //旋转(绕 Z 轴旋转的弧度)
    scale: Point;            //缩放

method:
    setFromBox(box): this;                //Box 转为 ShapeRect
    compute(): undefined;                //计算出矩形
    applyCanvas(context): undefined;    //矩形应用到画布的上下文中

demo:
    const canvasRect = new ShapeRect(100, 150); console.log(canvasRect);

    const canvas = document.createElement("canvas");
    canvas.width = WORLD.width;
    canvas.height = WORLD.height;
    canvas.style = `
        position: absolute;
        z-index: 9999;
        background: rgb(127,127,127);
    `;
    document.body.appendChild(canvas);

    canvasRect.position.set(300, 300);
    canvasRect.rotation = UTILS.toAngle(45);
    canvasRect.scale.set(1.5, 1.5);
    canvasRect.compute();

    const context = canvas.getContext("2d");
    canvasRect.applyCanvas(context);

    context.strokeStyle = "red";
    context.stroke();
*/
class ShapeRect{

    #dots = [];
    #size = new Point();
    #min = new Point();
    #max = new Point();

    constructor(width = 0, height = 0){
        this.width = width;
        this.height = height;
        this.position = new Point();
        this.rotation = 0;
        this.scale = new Point(1, 1);
    }

    setFromBox(box){
        this.width = box.w;
        this.height = box.h;
        this.position.set(box.cx, box.cy);
        return this;
    }

    compute(){
        //scale
        this.#size.set(this.width * this.scale.x, this.height * this.scale.y);
        
        //position
        this.#min.set(this.position.x - this.#size.x / 2, this.position.y - this.#size.y / 2);
        this.#max.set(this.#min.x + this.#size.x, this.#min.y + this.#size.y);
        
        //rotation
        const point = UTILS.emptyPoint;
        this.#dots.length = 0;
        
        point.set(this.#min.x, this.#min.y).rotate(this.position, this.rotation);
        this.#dots.push(point.x, point.y);

        point.set(this.#max.x, this.#min.y).rotate(this.position, this.rotation);
        this.#dots.push(point.x, point.y);

        point.set(this.#max.x, this.#max.y).rotate(this.position, this.rotation);
        this.#dots.push(point.x, point.y);

        point.set(this.#min.x, this.#max.y).rotate(this.position, this.rotation);
        this.#dots.push(point.x, point.y);

        //缩放旋转后的 min 与 max
        //this.#min.set(Math.min(this.#dots[0], this.#dots[2], this.#dots[4], this.#dots[6]), Math.min(this.#dots[1], this.#dots[3], this.#dots[5], this.#dots[7]));
        //this.#max.set(Math.max(this.#dots[0], this.#dots[2], this.#dots[4], this.#dots[6]), Math.max(this.#dots[1], this.#dots[3], this.#dots[5], this.#dots[7]))
    }

    drawImage(img, context){
        UTILS.emptyContext.canvas.width = this.#size.x;
        UTILS.emptyContext.canvas.height = this.#size.y;
        UTILS.emptyContext.drawImage(img, 0, 0, this.#size.x, this.#size.y);

        const imageData = UTILS.emptyContext.getImageData(0, 0, this.#size.x, this.#size.y),
        width = imageData.width, height = imageData.height,
        len = width * height, point = UTILS.emptyPoint, center = UTILS.emptyPointA.set(width/2, height/2),

        newImageData = UTILS.emptyContext.createImageData(width, height);
        
        for(let k = 0; k < len; k++){
            point.set(k % width, Math.floor(k / width)).rotate(center, this.rotation);
            if(point.x < 0 || point.y < 0 || point.x > newImageData.width-1 || point.y > newImageData.height-1) continue;

            point.set((width * Math.round(point.y) + Math.round(point.x)) * 4, k * 4);
            newImageData.data[point.x] = imageData.data[point.y];
            newImageData.data[point.x + 1] = imageData.data[point.y + 1];
            newImageData.data[point.x + 2] = imageData.data[point.y + 2];
            newImageData.data[point.x + 3] = imageData.data[point.y + 3];
        }

        context.putImageData(newImageData, 20, 20);
    }

    applyCanvas(context){
        context.beginPath();
        context.moveTo(this.#dots[0], this.#dots[1]);

        for(let k = 2, len = this.#dots.length; k < len; k += 2){
            context.lineTo(this.#dots[k], this.#dots[k + 1]);
        }

        context.closePath();
    }

}




/* RGBColor
parameter: 
    r, g, b

method:
    set(r, g, b: Number): this;            //rgb: 0 - 255; 第一个参数可以为 css color
    setFormHex(hex: Number): this;         //
    setFormHSV(h, s, v: Number): this;    //h:0-360; s,v:0-100; 颜色, 明度, 暗度
    setFormString(str: String): Number;    //str: 英文|css color; 返回的是透明度 (如果为 rgba 则返回a; 否则总是返回1)

    copy(v: RGBColor): this;
    clone(): RGBColor;

    getHex(): Number;
    getHexString(): String;
    getHSV(result: Object{h, s, v}): result;    //result: 默认是一个新的Object
    getRGBA(alpha: Number): String;             //alpha: 0 - 1; 默认 1
    getStyle()                                     //.getRGBA()别名

    stringToColor(str: String): String; //str 转为 css color; 如果str不是color格式则返回 ""

*/
class RGBColor{

    constructor(r = 255, g = 255, b = 255){
        this.r = r;
        this.g = g;
        this.b = b;
    }

    copy(v){
        this.r = v.r;
        this.g = v.g;
        this.b = v.b;
        return this;
    }

    clone(){
        return new this.constructor().copy(this);
    }

    set(r, g, b){
        if(typeof r !== "string"){
            this.r = r || 255;
            this.g = g || 255;
            this.b = b || 255;
        }

        else this.setFormString(r);
        
        return this;
    }

    setFormHex(hex){
        hex = Math.floor( hex );

        this.r = hex >> 16 & 255;
        this.g = hex >> 8 & 255;
        this.b = hex & 255;
        return this;
    }

    setFormHSV(h, s, v){
        h = h >= 360 ? 0 : h;
        var s=s/100;
        var v=v/100;
        var h1=Math.floor(h/60) % 6;
        var f=h/60-h1;
        var p=v*(1-s);
        var q=v*(1-f*s);
        var t=v*(1-(1-f)*s);
        var r,g,b;
        switch(h1){
            case 0:
                r=v;
                g=t;
                b=p;
                break;
            case 1:
                r=q;
                g=v;
                b=p;
                break;
            case 2:
                r=p;
                g=v;
                b=t;
                break;
            case 3:
                r=p;
                g=q;
                b=v;
                break;
            case 4:
                r=t;
                g=p;
                b=v;
                break;
            case 5:
                r=v;
                g=p;
                b=q;
                break;
        }

        this.r = Math.round(r*255);
        this.g = Math.round(g*255);
        this.b = Math.round(b*255);
        return this;
    }

    setFormString(color){
        if(typeof color !== "string") return 1;
        var _color = this.stringToColor(color);
        
        if(_color[0] === "#"){
            const len = _color.length;
            if(len === 4){
                _color = _color.slice(1);
                this.setFormHex(parseInt("0x"+_color + "" + _color));
            }
            else if(len === 7) this.setFormHex(parseInt("0x"+_color.slice(1)));
        }

        else if(_color[0] === "r" && _color[1] === "g" && _color[2] === "b"){
            const arr = [];
            for(let k = 0, len = _color.length, v = "", is = false; k < len; k++){
                
                if(is === true){
                    if(_color[k] === "," || _color[k] === ")"){
                        arr.push(parseFloat(v));
                        v = "";
                    }
                    else v += _color[k];
                    
                }

                else if(_color[k] === "(") is = true;
                
            }

            this.set(arr[0], arr[1], arr[2]);
            return arr[3] === undefined ? 1 : arr[3];
        }
        
        return 1;
    }

    getHex(){

        return Math.max( 0, Math.min( 255, this.r ) ) << 16 ^ Math.max( 0, Math.min( 255, this.g ) ) << 8 ^ Math.max( 0, Math.min( 255, this.b ) ) << 0;

    }

    getHexString(){

        return '#' + ( '000000' + this.getHex().toString( 16 ) ).slice( - 6 );

    }

    getHSV(result){
        result = result || {}
        var r=this.r/255;
        var g=this.g/255;
        var b=this.b/255;
        var h,s,v;
        var min=Math.min(r,g,b);
        var max=v=Math.max(r,g,b);
        var l=(min+max)/2;
        var difference = max-min;
        
        if(max==min){
            h=0;
        }else{
            switch(max){
                case r: h=(g-b)/difference+(g < b ? 6 : 0);break;
                case g: h=2.0+(b-r)/difference;break;
                case b: h=4.0+(r-g)/difference;break;
            }
            h=Math.round(h*60);
        }
        if(max==0){
            s=0;
        }else{
            s=1-min/max;
        }
        s=Math.round(s*100);
        v=Math.round(v*100);
        result.h = h;
        result.s = s;
        result.v = v;
        return result;
    }

    getStyle(){
        return this.getRGBA(1);
    }

    getRGBA(alpha = 1){
        return `rgba(${this.r},${this.g},${this.b},${alpha})`;
    }

    stringToColor(str){
        var _color = "";
        for(let k = 0, len = str.length; k < len; k++){
            if(str[k] === " ") continue;
            _color += str[k];
        }
        
        if(_color[0] === "#" || (_color[0] === "r" && _color[1] === "g" && _color[2] === "b")) return _color;

        return ColorRefTable[_color] || "";
    }

}




/* Timer 定时器 

parameter:
    func: Function; //定时器运行时的回调; 默认 null, 如果定义构造器将自动调用一次.restart()方法
    speed: Number; //延迟多少毫秒执行一次 func; 默认 3000;
    step: Integer; //执行多少次: 延迟speed毫秒执行一次 func; 默认 Infinity;
    
attribute:
    func, speed, step;    //这些属性可以随时更改;

    //只读属性
    readyState: String;    //定时器状态; 可能值: '', 'start', 'running', 'done'; ''表示定时器从未启动
    number: Number;        //运行的次数

method:
    start(func, speed): this;    //启动定时器 (如果定时器正在运行则什么都不会做)
    restart(): undefined;        //重启定时器
    stop(): undefined;            //停止定时器

demo:
    //每 3000 毫秒 打印一次 timer.number
    new Timer(timer => {
        console.log(timer.number);
    }, 3000);

*/
class Timer{

    #restart = -1;
    #speed = 0;
    #isRun = false;
    #i = 0;
    #readyState = ''; //start|running

    get number(){
        return this.#i;
    }
    
    get readyState(){
        return this.#i >= this.step ? 'done' : this.#readyState;
    }

    get running(){
        return this.#isRun;
    }

    constructor(func = null, speed = 3000, step = Infinity){
        this.func = func;
        this.speed = speed;
        this.step = step;
        //this.onDone = null;
    
        if(typeof this.func === "function") this.restart();

    }

    start(func, time){
        if(typeof func === 'function') this.func = func;
        if(UTILS.isNumber(time) === true) this.speed = time;
        this.restart();

        return this;
    }

    restart(){
        if(this.#isRun === false){
            setTimeout(this._loop, this.speed);
            this.#isRun = true;
            this.#restart = -1;
            this.#i = 0;
            this.#readyState = 'start';
            
        }

        else{
            this.#restart = Date.now();
            this.#speed = this.speed;

        }

    }

    stop(){
        if(this.#isRun === true){
            this.#restart = -1;
            this.#i = this.step;
        }

    }

    _loop = () => {

        //重启计时器
        if(this.#restart !== -1){
            
            let gone = Date.now() - this.#restart;
            this.#restart = -1;
            
            if(gone >= this.#speed) gone = this.speed;
            else{
                if(this.#speed === this.speed) gone = this.#speed - gone;
                else gone = (this.#speed - gone) / this.#speed * this.speed;
            }
            
            setTimeout(this._loop, gone);
            
            this.#i = 1;
            if(this.func !== null) this.func(this);

        }

        //正在运行
        else if(this.#i < this.step){

            setTimeout(this._loop, this.speed);

            this.#i++;
            if(this.#readyState !== 'running') this.#readyState = 'running';
            if(this.func !== null) this.func(this);

        }

        //完成
        else this.#isRun = false;

    }

}




/* SeekPath A*寻路

parameter: 
    option: Object{
        angle: Number,         //8 || 16
        timeout: Number,     //单位为毫秒
        size: Number,         //每格的宽高
        lenX, lenY: Number,    //长度
        disables: Array[0||1],
        heights: Array[Number],
        path: Array[], //存放寻路结果 默认创建一个空数组
    }

attribute:
    size: Number;     //每个索引的大小
    lenX: Number;     //最大长度x (设置此属性时, 你需要重新.initMap(heights);)
    lenY: Number;     //最大长度y (设置此属性时, 你需要重新.initMap(heights);)

    //此属性已废弃 range: Box;            //本次的搜索范围, 默认: 0,0,lenX,lenY
    angle: Number;         //8四方向 或 16八方向 默认 16
    timeout: Number;     //超时毫秒 默认 500
    mapRange: Box;        //地图box
    //此属性已废弃(run函数不在检测相邻的高) maxHeight: Number;     //相邻可走的最大高 默认 6

    //只读属性
    success: Bool;            //只读; 本次搜索是否成功找到终点; (如果为false说明.run()返回的是 距终点最近的路径; 超时也会被判定为false)
    path: Array[x, y, z];    //存放.run()返回的路径
    map: Map;                 //地图的缓存数据

method:
    initMap(heights: Array[Number]): undefiend;     //初始化类时自动调用一次; heights:如果你的场景存在高请定义此参数
    run(x, y, x1, y1: Number): Array[x, y, z];         //参数索引坐标
    getDots(x, y, a, r): Array[ix, iy];             //获取周围的点 x,y, a:8|16, r:存放结果数组
    getLegalPoints(ix, iy, count): Array[x, y, z];    //获取 ix, iy 周围 合法的, 相邻的 count 个点

demo:
    const sp = new SeekPath({
        angle: 16,
        timeout: 500,
        //maxHeight: 6,
        size: 10,
        lenX: 1000,
        lenY: 1000,
    }),

    path = sp.run(0, 0, 1000, 1000);

    console.log(sp);

*/
class SeekPath{

    static _open = []
    static _dots = [] //.run() .getLegalPoints()
    static dots4 = []; //._check()
    static _sort = function (a, b){return a["f"] - b["f"];}

    #map = null;
    #path = null;
    #success = true;
    #halfX = 50;
    #halfY = 50;

    #size = 10;
    #lenX = 10;
    #lenY = 10;

    constructor(option = {}){
        this.angle = (option.angle === 8 || option.angle === 16) ? option.angle : 16; //8四方向 或 16八方向
        this.timeout = option.timeout || 500; //超时毫秒
        //this.maxHeight = option.maxHeight || 6;
        this.mapRange = new Box();
        this.size = option.size || 10;
        this.lenX = option.lenX || 10;
        this.lenY = option.lenY || 10;
        this.#path = Array.isArray(option.path) ? option.path : [];
        this.initMap(option.disable, option.height);
        option = undefined
    }

    //this.#map[x][y] = Object{height: 此点的高,默认0, is: 此点是否可走,默认1(disable)};
    get map(){
        return this.#map;
    }

    //this.#path = Array[x,y,z]
    get path(){
        return this.#path;
    }

    get success(){
        return this.#success;
    }

    get size(){
        return this.#size;
    }

    set size(v){
        this.#size = v;
        v = v / 2;
        this.#halfX = v * this.#lenX;
        this.#halfY = v * this.#lenY;
    }

    get lenX(){
        return this.#lenX;
    }

    set lenX(v){
        this.#lenX = v;
        v = this.#size / 2;
        this.#halfX = v * this.#lenX;
        this.#halfY = v * this.#lenY;
        
    }

    get lenY(){
        return this.#lenY;
    }

    set lenY(v){
        this.#lenY = v;
        v = this.#size / 2;
        this.#halfX = v * this.#lenX;
        this.#halfY = v * this.#lenY;
        
    }

    toScene(n, v){ //n = "x|y"
        //n = n === "y" ? "lenY" : "lenX";
        if(n === "y" || n === "z") return v * this.#size - this.#halfY;
        return v * this.#size - this.#halfX;
    }
    
    toIndex(n, v){
        //n = n === "y" ? "lenY" : "lenX";
        if(n === "y" || n === "z") return Math.round((this.#halfY + v) / this.#size);
        return Math.round((this.#halfX + v) / this.#size);
    }

    initMap(disable, height){
        
        disable = Array.isArray(disable) === true ? disable : null;
        height = Array.isArray(height) === true ? height : null;
        
        const lenX = this.lenX, lenY = this.lenY;
        var getHeight = (ix, iy) => {
            if(height === null) return 0;
            ix = height[ix * lenY + iy];
            if(ix === undefined) return 0;
            return ix;
        },
        getDisable = (ix, iy) => {
            if(disable === null) return 1;
            ix = disable[ix * lenY + iy];
            if(ix === undefined) return 0;
            return ix;
        },

        map = []//new Map();

        for(let x = 0, y, m; x < lenX; x++){
            m = []//new Map();
            for(y = 0; y < lenY; y++) m[y] = {x:x, y:y, height:getHeight(x, y), is:getDisable(x, y),  g:0, h:0, f:0, p:null, id:""}//m.set(y, {x:x, y:y, height:getHeight(x, y),   g:0, h:0, f:0, p:null, id:""});
            map[x] = m;//map.set(x, m);
        }
        
        this.#map = map;
        this._id = -1;
        this._updateID();
        this.mapRange.set(0, 0, this.#lenX-1, this.#lenY-1);

        map = disable = height = getHeight = undefined;

    }

    getLegalPoints(ix, iy, count, result = []){  //不包括 ix, iy
        const _dots = SeekPath._dots;
        result.length = 0;
        result[0] = this.#map[ix][iy];
        count += 1;
        
        while(result.length < count){
            for(let k = 0, i, n, d, len = result.length; k < len; k++){
                n = result[k];
                this.getDots(n.x, n.y, this.angle, _dots);
                for(i = 0; i < this.angle; i += 2){
                    d = this.#map[_dots[i]][_dots[i+1]];
                    if(d.is === 1 && this.mapRange.containsPoint(d.x, d.y) && !result.includes(d)){
                        if(Math.abs(n.x - d.x) + Math.abs(n.y - d.y) === 2 && this._check(n, d)){
                            result.push(d);
                        }
                    }
                }
            }
        }
    
        result.splice(0, 1);
        return result;
    }

    getLinePoints(now, next, count, result = []){ //不包括 now 
        if(count % 2 !== 0) count += 1;

        const len = count / 2, angle90 = 90/180*Math.PI;

        var i, ix, iy, n, nn = next, is = false;

        UTILS.emptyPoint.set(now.x, now.y).rotate(next, angle90);
        var disX = UTILS.emptyPoint.x - next.x, 
        disY = UTILS.emptyPoint.y - next.y;
        
        for(i = 0; i < len; i++){
            if(is){
                result[len-1-i] = nn;
                continue;
            }
            ix = disX + disX * i + next.x;
            iy = disY + disY * i + next.y;

            n = this.#map[ix][iy];
            if(n.is === 1) nn = n;
            else is = true;
            result[len-1-i] = nn;
        }

        //result[len] = next;
        is = false;
        nn = next;

        UTILS.emptyPoint.set(now.x, now.y).rotate(next, -angle90);
        disX = UTILS.emptyPoint.x - next.x, 
        disY = UTILS.emptyPoint.y - next.y;

        for(i = 0; i < len; i++){
            if(is){
                result[len+i] = nn;
                continue;
            }
            ix = disX + disX * i + next.x;
            iy = disY + disY * i + next.y;

            n = this.#map[ix][iy];
            if(n.is === 1) nn = n;
            else is = true;
            result[len+i] = nn;
        }

        return result;
    }

    getDots(x, y, a, r = []){ //获取周围的点 x,y, a:8|16, r:存放结果数组
        r.length = 0;
        const x_1 = x-1, x1 = x+1, y_1 = y-1, y1 = y+1;
        if(a === 16) r.push(x_1, y_1, x, y_1, x1, y_1, x_1, y, x1, y, x_1, y1, x, y1, x1, y1);
        else r.push(x, y_1, x, y1, x_1, y, x1, y);
    }

    getDisMHD(nodeA, nodeB){
        return Math.abs(nodeA.x - nodeB.x) + Math.abs(nodeA.y - nodeB.y);
    }

    _updateID(){ //更新标记
        this._id++;
        this._openID = "o_"+this._id;
        this._closeID = "c_"+this._id;
    }

    _check(dotA, dotB){ //检测 a 是否能到 b
        //获取 dotB 周围的4个点 并 遍历这4个点
        this.getDots(dotB.x, dotB.y, 8, SeekPath.dots4);
        for(let k = 0, x, y; k < 8; k += 2){
            x = SeekPath.dots4[k]; 
            y = SeekPath.dots4[k+1];
            if(this.mapRange.containsPoint(x, y) === false) continue;

            //找出 dotA 与 dotB 相交的两个点:
            if(Math.abs(dotA.x - x) + Math.abs(dotA.y - y) === 1){
                //如果其中一个交点是不可走的则 dotA 到 dotB 不可走, 既返回 false
                if(this.#map[x][y].is === 0) return false;
            }

        }

        return true;
    }

    run(x, y, x1, y1, path = this.#path){
        path.length = 0;
        if(this.#map === null || this.mapRange.containsPoint(x, y) === false) return path;
        
        var _n = this.#map[x][y];
        if(_n.is === 0) return path;

        const _sort = SeekPath._sort,
        _open = SeekPath._open,
        _dots = SeekPath._dots, 
        time = Date.now();

        //var isDot = true, 
        var suc = _n, k, mhd, g, h, f, _d;

        _n.g = 0;
        _n.h = _n.h = Math.abs(x1 - x) * 10 + Math.abs(y1 - y) * 10; 
        _n.f = _n.h;
        _n.p = null;
        this._updateID();
        _n.id = this._openID;
        _open.push(_n);
        
        while(_open.length !== 0){
            if(Date.now() - time > this.timeout) break;

            _open.sort(_sort);
            _n = _open.shift();
            if(_n.x === x1 && _n.y === y1){
                suc = _n;
                break;
            }
            
            if(suc.h > _n.h) suc = _n;
            _n.id = this._closeID;
            this.getDots(_n.x, _n.y, this.angle, _dots);
            
            for(k = 0; k < this.angle; k += 2){
                
                _d = this.#map[_dots[k]][_dots[k+1]];
                if(_d.id === this._closeID || _d.is === 0 || this.mapRange.containsPoint(_d.x, _d.y) === false) continue;

                mhd = Math["abs"](_n["x"] - _d.x) + Math["abs"](_n["y"] - _d.y);
                g = _n["g"] + (mhd === 1 ? 10 : 14);
                h = Math["abs"](x1 - _d.x) * 10 + Math["abs"](y1 - _d.y) * 10;
                f = g + h;
            
                if(_d.id !== this._openID){
                    //如果是斜角和8方向:
                    if(mhd !== 1 && this.angle === 16){
                        if(this._check(_n, _d)){
                            _d.g = g;
                            _d.h = h;
                            _d.f = f;
                            _d.p = _n;
                            _d.id = this._openID;
                            _open.push(_d);
                        }
                    }else{
                        _d.g = g;
                        _d.h = h;
                        _d.f = f;
                        _d.p = _n;
                        _d.id = this._openID;
                        _open.push(_d);
                    }
                }

                else if(g < _d.g){
                    _d.g = g;
                    _d.f = g + _d.h;
                    _d.p = _n;
                }
    
            }
        }

        this.#success = suc === _n;

        while(suc !== null){
            path.unshift(suc);
            //path.unshift(this.toScene("x", suc["x"]), suc["height"], this.toScene("y", suc["y"]));
            suc = suc["p"];
        }

        _open.length = _dots.length = 0;
        
        return path;
    }

}




/* TweenValue (从 原点 以规定的时间到达  终点)

parameter: origin, end, time, onUpdate, onEnd;

attribute:
    origin: Object; //原点(起点)
    end: Object; //终点
    time: Number; //origin 到 end 花费的时间
    onUpdate: Function; //更新回调; 一个回调参数 origin; 默认null;
    onEnd: Function; //结束回调; 没有回调参数; 默认null; (如果返回的是"restart"将不从队列删除, 你可以在onEnd中更新.end不间断的继续补间)

method:
    reset(origin, end: Object): undefined; //更换 .origin, .end; 它会清除其它对象的缓存属性
    reverse(): undefined; //this.end 复制 this.origin 的原始值
    update(): undefined; //Tween 通过此方法统一更新 TweenValue

demo: 
    //init Tween:
    const tween = new Tween(),
    animate = function (){
        requestAnimationFrame(animate);
        tween.update();
    }

    //init TweenValue:
    const v1 = new Tween.Value({x:0, y:0}, {x:5, y:10}, 1000, v => console.log(v));
    
    animate();
    tween.start(v1);

*/
class TweenValue{

    constructor(origin = {}, end = {}, time = 500, onEnd = null, onUpdate = null, onStart = null){
        this.origin = origin;
        this.end = end;
        this.time = time;

        this.onUpdate = onUpdate;
        this.onEnd = onEnd;
        this.onStart = onStart;
        
        //以下属性不能直接设置
        this._r = null;
        this._t = 0;
        this._v = Object.create(null);
    }

    _start(){
        var v = "";
        for(v in this.origin) this._v[v] = this.origin[v];
        if(this.onStart !== null) this.onStart(this);
        this._t = Date.now();
        //this.update();
    }

    reset(origin, end){
        this.origin = origin;
        this.end = end;
        this._v = Object.create(null);
    }

    reverse(){
        var n = "";
        for(n in this.origin) this.end[n] = this._v[n];
    }

    update(){

        if(this["_r"] !== null){

            var ted = Date["now"]() - this["_t"];

            if(ted >= this["time"]){

                for(ted in this["origin"]) this["origin"][ted] = this["end"][ted];

                if(this["onEnd"] !== null){

                    if(this["onEnd"](this) === "restart"){
                        if(this["onUpdate"] !== null) this["onUpdate"](this["origin"]);
                        this["_start"]();
                    }

                    else this["_r"]["stop"](this);
                    
                }

                else this["_r"]["stop"](this);

            }

            else{
                ted = ted / this["time"];
                let n = "";
                for(n in this["origin"]) this["origin"][n] = ted * (this["end"][n] - this["_v"][n]) + this["_v"][n];
                if(this["onUpdate"] !== null) this["onUpdate"](this["origin"]);
            }

        }

    }

}




/* Tween 动画补间 (TweenValue 的root, 可以管理多个TweenValue)

parameter:
attribute:
method:
    start(value: TweenValue): undefined;
    stop(value: TweenValue): undefined;

static:
    Value: TweenValue;

demo:
    //init Tween:
    const tween = new Tween(),
    animate = function (){
        requestAnimationFrame(animate);
        tween.update();
    }

    //init TweenValue:
    const v2 = new Tween.Value({x:0, y:0}, {x:5, y:10}, 1000, v => console.log(v), v => {
        v2.reverse(); //v2.end 复制起始值
        return "restart"; //返回"restart"表示不删除队列, 需要继续补间
    });
    
    animate();
    tween.start(v2);

*/
class Tween extends RunningList{

    static Value = TweenValue;

    constructor(){
        super();
    }

    start(value){
        this.add(value);
        value._r = this;
        value._start();
    }

    stop(value){
        this.remove(value);
        value._r = null;
    }

}




/* TweenTarget 朝着轴插值(有效的跟踪动态目标, 注意此类需要配合 RunningList 类使用, 因为此类在任何情况下都没有阻止你调用.update()方法)
parameter:    
    v1 = {x: 0}, 
    v2 = {x: 100}, 
    distance = 1,        //每次移动的距离
    onUpdate = null,    //
    onEnd = null

attribute:
    v1: Object;             //起点
    v2: Object;             //终点
    onUpdate: Function;        //
    onEnd: Function;         //

method:
    update(): undefined;                        //一般在动画循环里执行此方法
    updateAxis(): undefined;                     //更新v1至v2的方向轴 (初始化时构造器自动调用一次)
    setDistance(distance: Number): undefined;     //设置每次移动的距离 (初始化时构造器自动调用一次)

demo:
    const ttc = new TweenTarget({x:0, y:0}, {x:100, y:100}, 10),

    //计时器模拟动画循环函数, 每秒执行一次.update()
    timer = new Timer(() => {
        ttc.update();
        console.log('update: ', ttc.v1);

    }, 1000, Infinity);

    ttc.onEnd = v => {
        timer.stop();
        console.log('end: ', v);
    }

    timer.start();
    console.log(ttc);

*/
class TweenTarget{

    #distance = 1;
    #distancePow2 = 1;
    #axis = {};
    get distance(){return this.#distance;}

    constructor(v1 = {x: 0}, v2 = {x: 100}, distance, onUpdate = null, onEnd = null){
        this.v1 = v1;
        this.v2 = v2;
        this.onUpdate = onUpdate;
        this.onEnd = onEnd;
    
        this.setDistance(distance);
        this.updateAxis();
    }

    setDistance(v = 1){
        this.#distance = v;
        this.#distancePow2 = Math.pow(v, 2);
    }

    updateAxis(){
        var n, v, len = 0;

        for(n in this.v1){
            v = this.v2[n] - this.v1[n];
            len += v * v;
            this.#axis[n] = v;

        }

        len = Math.sqrt(len);

        if(len !== 0){
            
            for(n in this.v1) this.#axis[n] *= 1 / len;

        }
    }

    update(){
        var n, len = 0;

        for(n in this.v1) len += Math.pow(this.v1[n] - this.v2[n], 2);

        if(len > this.#distancePow2){

            for(n in this.v1) this.v1[n] += this.#axis[n] * this.#distance;
            if(this.onUpdate !== null) this.onUpdate(this.v1);

        }

        else{

            for(n in this.v1) this.v1[n] = this.v2[n];
            if(this.onEnd !== null) this.onEnd(this.v1);
            
        }
    }

}




/* EventDispatcher 自定义事件管理器
parameter: 
attribute: 

method:
    clearEvents(eventName): undefined;             //清除eventName列表, 如果 eventName 未定义清除所有事件
    customEvents(eventName, eventParam): this;    //创建自定义事件 eventParam 可选 默认{}
    getParam(eventName): eventParam;
    trigger(eventName, callback): undefined;    //触发 (callback: 可选)
    register(eventName, callback): undefined;    //
    deleteEvent(eventName, callback): undefined; //

demo:
    const eventDispatcher = new EventDispatcher();
    eventDispatcher.customEvents("test", {name: "test"});

    eventDispatcher.register("test", eventParam => {
        console.log(eventParam) //Object{name: "test"}
    });

    eventDispatcher.trigger("test");

*/
class EventDispatcher{
    
    constructor(){
        this._eventsList = {};
        this.__eventsList = [];
        this.__trigger = "";
    }

    clearEvents(eventName){ 

        //if(this.__trigger === eventName) return console.warn("EventDispatcher: 清除事件失败");
        if(this._eventsList[eventName] !== undefined) this._eventsList[eventName].func = []

        else this._eventsList = {}

    }
    
    customEvents(eventName, eventParam = {}){ 
        //if(typeof eventName !== "string") return console.warn("EventDispatcher: 注册自定义事件失败");
        if(this._eventsList[eventName] !== undefined) return console.warn("EventDispatcher: "+eventName+" 已存在");
        //eventParam = eventParam || {}
        //if(eventParam.type === undefined) eventParam.type = eventName;
        this._eventsList[eventName] = {func: [], param: eventParam}
        return this;
    }

    getParam(eventName){
        return this._eventsList[eventName]["param"];
    }
    
    trigger(eventName, callback){
        //if(this._eventsList[eventName] === undefined) return;
        
        const obj = this._eventsList[eventName];
        var k, len = obj.func.length;

        if(len !== 0){
            if(typeof callback === "function") callback(obj["param"]); //更新参数(eventParam)

            //触发过程(如果触发过程中删除事件, 不仅 len 没有变, 而且还会漏掉一个key, 所以在触发过程中删除的事件要特殊处理)
            this.__trigger = eventName;
            for(k = 0; k < len; k++) obj["func"][k](obj["param"]);
            this.__trigger = "";
            //触发过程结束
            
            //删除在触发过程中要删除的事件
            len = this.__eventsList.length;
            for(k = 0; k < len; k++) this.deleteEvent(eventName, this.__eventsList[k]);
            this.__eventsList.length = 0;
    
        }

    }
    
    register(eventName, callback){
        if(this._eventsList[eventName] === undefined) return console.warn("EventDispatcher: "+eventName+" 不存在");
        const obj = this._eventsList[eventName];
        //if(obj.func.includes(callback) === false) obj.func.push(callback);
        //else console.warn("EventDispatcher: 回调函数重复");
        obj.func.push(callback);
    }
    
    deleteEvent(eventName, callback){
        if(this._eventsList[eventName] === undefined) return console.warn("EventDispatcher: "+eventName+" 不存在");
        
        if(this.__trigger === eventName) this.__eventsList.push(callback);
        else{
            const obj = this._eventsList[eventName], i = obj.func.indexOf(callback);
            if(i !== -1) obj.func.splice(i, 1);
        }
        
    }

}




export {
    UTILS, 
    ColorRefTable, 
    AnimateLoop,
    Ajax, 
    IndexedDB, 
    TreeStruct, 
    Point, 
    Line, 
    Box, 
    Circle, 
    Polygon, 
    RGBColor, 
    Timer, 
    SeekPath, 
    RunningList, 
    TweenValue, 
    Tween, 
    TweenTarget, 
    EventDispatcher, 
    Rotate,
    ShapeRect,
    SecurityDoor,
}

 

"use strict";

import {
    UTILS, 
    Box, 
    Rotate,
    EventDispatcher,
    Point,
    AnimateLoop,
    TreeStruct,
    Line,
    RGBColor,
} from './Utils.js';




/* CanvasImageRender (渲染 CanvasImage)

关于canvas的优化:
    离屏渲染(预处理图像的 缩放, 旋转, 剪裁, 等)
    避免浮点坐标(用Math.floor()函数对所有的坐标点取整, 浏览器为了达到抗锯齿的效果会做额外的运算)
    如果可能请关闭透明度 (CanvasImageRender.paramCon.alpha = false)

关于渲染 CanvasImage
    尽量让box.w和box.h与image的宽高保持一致, 否则在渲染时会缩放image
    如果你不在使用这些属性请将它们设为默认值: .opacity 默认1, .rotate 默认null
    如果多个 CanvasImage 的image是一样的应该: a.loadImage(src); b.setImage(a); c.setImage(a);

ImageData:
    length: w * h * 4
    r: 0 - 255
    g: 0 - 255
    b: 0 - 255
    a: 0 - 255 Math.round(255 * a)

    遍历:
    const data = context.getImageData(0, 0, canvas.width, canvas.height).data;
    for(let k = 0, x, y, r, g, b, a, i; k < len; k++){
        x = k % width;
        y = Math.floor(k / width);

        i = k*4;
        r = data[i]
        g = data[i+1]
        b = data[i+2]
        a = data[i+3]

        console.log(x, y, r, g, b, a, i);
    }

parameter: 
    option = {
        canvas             //默认 新的canvas
        width, height     //默认 1
        className, id    //默认 ""
    }

attribute:
    domElement: HTMLCanvasElement;
    context: CanvasRenderingContext2D;
    list: Array[CanvasImage]
    
method:
    size(w, h: Number): this;                //设置box和canvas的宽高
    render(parentElem: HTMLElement): this;    //canvas添加至dom树
    initList(i): this;                        //初始化列表
    add(ci: CanvasImage): ci;                //添加至列表并初始化ci
    remove(ci: CanvasImage): ci;            //从列表中删除ci
    redraw(): undefined;                     //重绘在 this.box 内或相交的 CanvasImage

    redrawTarget(ca: CanvasImage|Box): undefined;
    //工作原理: 收集与ca重叠的ca; 重绘这些重叠的ca, 前提是ca的box没发生改变; (缩放或旋转ca的box都会发生改变)
    例子:
        ca.opacity = 0.6;
        cir.redrawTarget(ca);

        ca.visible = false;
        cir.redrawTarget(ca);

        cir.remove(ca);
        cir.redrawTarget(ca);

        cir.add(ca);
        cir.redrawTarget(ca);

        ca.setImage(newImage) //假设newImage与ca的box一样大
        cir.redrawTarget(ca);

    initEventDispatcher(): this; //初始化自定义事件 (如果你不需要这些事件可以不初始化)
    支持的事件名:
        beforeDraw
        afterDraw
        beforeDrawTarget
        afterDrawTarget
        boxX
        boxY
        initList
        size
        add
        remove

demo:
    const cir = new CanvasImageRender({width: WORLD.width, height: WORLD.height})

    .initEventDispatcher(), //初始化 CanvasImageRender 内部的自定义事件

    cie = new CanvasImageEvent(cir), //启用dom事件

    cis = new CanvasImageScroll(cir, cie, {scrollEventType: "touch"}), //启用滚动条
    
    ci = new CanvasImage().loadImage("view/examples/img/test.png", cir); //图片加载完后更新一次画布

    for(let k = 0, pi2 = Math.PI*2, ca; k < 1000000; k++){
        ca = cir.list[k] = new CanvasImage(ci);                     //添加至渲染列表
        ca.pos(UTILS.random(0, 1000000), UTILS.random(0, 1000000));    //随机位置
        //ca.rotate = new Rotate(0, 0, UTILS.random(0, pi2));         //随机旋转
    }
    
    //为什么要用 initList() ? 因为for循环中是直接把ca加入到了列表, 没对ca做任何初始化操作;
    //如果全用.add() 就不需要在调用 initList(); 但 .add() 方法不适合一次性添加多个 CanvasImage;
    cir.initList(); 

*/
class CanvasImageRender{

    static emptyBox = new Box();
    static emptyArrA = []
    static emptyArrB = []
    static paramCon = {alpha: true}

    static defaultStyles = {
        filter: "none",
        globalAlpha: 1,
        globalCompositeOperation: "source-over",
        imageSmoothingEnabled: false, //是否启用平滑处理图像
        miterLimit: 10,
        font: "12px SimSun, Songti SC",
        textAlign: "left",
        textBaseline: "top",
        lineCap: "butt",
        lineJoin: "miter",
        lineDashOffset: 0,
        lineWidth: 1,
        shadowColor: "rgba(0, 0, 0, 0)",
        shadowBlur: 0,
        shadowOffsetX: 0,
        shadowOffsetY: 0,
        fillStyle: "rgba(255,255,255,0.4)",
        strokeStyle: "rgba(210,210,210,0.6)",
    }

    static setDefaultStyles(context){
        let k = "", styles = CanvasImageRender.defaultStyles;
        for(k in styles){
            if(context[k] !== styles[k]) context[k] = styles[k];
        }
    }

    static getContext(canvas, className, id){
        if(CanvasImageRender.isCanvas(canvas) === false) canvas = document.createElement("canvas");
        const context = canvas.getContext("2d", CanvasImageRender.paramCon);

        if(typeof className === "string") canvas.className = className;
        if(typeof id === "string") canvas.setAttribute('id', id);
        
        return context;
    }

    static downloadImage(func){
        const input = document.createElement("input");
        input.type = "file";
        input.multiple = "multiple";
        input.accept = ".png, .jpg, .jpeg, .bmp, .gif";
    
        input.onchange = e => {
            if(e.target.files.length === 0) return;
            const fr = new FileReader();
            fr.onloadend = e1 => {
                const img = new Image();
                img.onload = () => func(img);
                img.src = e1.target.result;
            }

            fr.readAsDataURL(e.target.files[0]);
        }
        
        input.click();
    }

    static isCanvasImage(img){ //OffscreenCanvas: ImageBitmap;

        return ImageBitmap["prototype"]["isPrototypeOf"](img) || 
        HTMLImageElement["prototype"]["isPrototypeOf"](img) || 
        HTMLCanvasElement["prototype"]["isPrototypeOf"](img) || 
        CanvasRenderingContext2D["prototype"]["isPrototypeOf"](img) || 
        HTMLVideoElement["prototype"]["isPrototypeOf"](img);
        
    }

    static isCanvas(canvas){
        return HTMLCanvasElement["prototype"]["isPrototypeOf"](canvas);
    }
    
    #box = new Box();
    get box(){return this.#box;}

    #eventDispatcher = null;
    get eventDispatcher(){return this.#eventDispatcher;}

    constructor(option = {}){
        this.list = [];
        this.context = CanvasImageRender.getContext(option.canvas, option.className, option.id);
        this.domElement = this.context.canvas;
        
        this.size(option.width, option.height);
    }

    initEventDispatcher(){
        this.#eventDispatcher = new EventDispatcher();
        const eventParam = {target: this}, 
        eventParam1 = {target: this, value: null};
        this.#eventDispatcher.
        customEvents("beforeDraw", eventParam)
        .customEvents("afterDraw", eventParam)
        .customEvents("beforeDrawTarget", eventParam)
        .customEvents("afterDrawTarget", eventParam)
        .customEvents("boxX", eventParam)
        .customEvents("boxY", eventParam)
        .customEvents("initList", {target: this, index: 0})
        .customEvents("size", eventParam)
        .customEvents("add", eventParam1)
        .customEvents("remove", eventParam1);

        let _x = this.#box.x, _y = this.#box.y;
        Object.defineProperties(this.#box, {

            x: {
                get: () => {return _x;},
                set: v => {
                    _x = v;
                    this.#eventDispatcher.trigger("boxX");
                }
            },

            y: {
                get: () => {return _y;},
                set: v => {
                    _y = v;
                    this.#eventDispatcher.trigger("boxY");
                }
            },

        });

        return this;
    }

    strokeBox(box){
        this.context.strokeRect(box.x-this.#box.x, box.y-this.#box.y, box.w, box.h);
    }

    fillBox(box){
        this.context.fillRect(box.x-this.#box.x, box.y-this.#box.y, box.w, box.h);
    }

    clearBox(box){
        this['context']['clearRect'](box.x-this.#box.x, box.y-this.#box.y, box.w, box.h);
    }

    isDraw(ca){
        return ca["visible"] === true && ca["image"] !== null && this["box"]["intersectsBox"](ca["box"]);
    }

    size(w = 1, h = 1){
        this.domElement.width = w;
        this.domElement.height = h;
        CanvasImageRender.setDefaultStyles(this.context);
        this.box.size(w, h);
        if(this.#eventDispatcher !== null) this.#eventDispatcher.trigger("size");
        return this;
    }

    append(ca){
        this.add(ca);
        return this;
    }

    add(ca){
        if(CanvasImage.prototype.isPrototypeOf(ca) && !this.list.includes(ca)){
            const len = this.list.length;
            
            if(this.list[ca.index] === undefined){
                ca.index = len;
                this.list.push(ca);
            }

            else{
                const arr = this.list.splice(ca.index);
                this.list.push(ca);
                for(let k = 0, c = arr.length; k < c; k++){
                    this.list.push(arr[k]);
                    arr[k].index++;
                }
            }

            if(this.#eventDispatcher !== null) this.#eventDispatcher.trigger("add", param => param.value = ca);
        }
        
        return ca;
    }

    remove(ca){
        var i = ca.index;

        if(this.list[i] !== ca) i = this.list.indexOf(ca);

        if(i !== -1){
            this.list.splice(i, 1);
            for(let k = i, len = this.list.length; k < len; k++) this.list[k].index -= 1;
            if(this.#eventDispatcher !== null) this.#eventDispatcher.trigger("remove", param => param.value = ca);
        }

        return ca;
    }

    render(parentElem = document.body){
        this.redraw();
        if(this.domElement.parentElement === null) parentElem.appendChild(this.domElement);
        return this;
    }

    initList(i){
        if(i === undefined || i < 0) i = 0;
        const len = this.list.length;
        for(let k = i; k < len; k++) this.list[k].index = k;
        if(this.#eventDispatcher !== null) this.#eventDispatcher.trigger("initList", param => param.index = i);
        return this;
    }

    clear(){
        this['context']['clearRect'](0, 0, this['box']['w'], this['box']['h']);
    }

    draw(){
        if(this.#eventDispatcher !== null) this.#eventDispatcher.trigger("beforeDraw");
        const len = this["list"]["length"];
        for(let k = 0, i = 0, ca; k < len; k++){
            ca = this["list"][k];
            if(this["isDraw"](ca) === true){
                this["_draw"](ca);
            }
        }

        if(this.#eventDispatcher !== null) this.#eventDispatcher.trigger("afterDraw");
    }

    redrawTarget(box){
        box = CanvasImageRender.emptyBox.copy(CanvasImage.prototype.isPrototypeOf(box) ? box.box : box);
        if(this.#eventDispatcher !== null) this.#eventDispatcher.trigger("beforeDrawTarget");
        this._computeOverlap(box);
        this["context"]["clearRect"](box["x"] - this.#box.x, box["y"] - this.#box.y, box["w"], box["h"]);
        this["_drawTarget"]();
        if(this.#eventDispatcher !== null) this.#eventDispatcher.trigger("afterDrawTarget");
    }

    redraw(){
        this.clear();
        this.draw();
    }

    //限内部使用
    _computeOverlap(tar){ //暂不支持带有旋转的 CanvasImage (如遇到将忽略)
        //1 如果检索到与box相交的ca时, 合并其box执行以下步骤: 
        //2 检索 已检索过的 并且 没有相交的ca
        //3 如果存在相交的ca就合并box并继续第 2 步; 如果不存在继续第 1 步
        const _list = CanvasImageRender.emptyArrA, list = CanvasImageRender.emptyArrB, len = this.list.length, box = tar;

        for(let k = 0, i = 0, c = 0, _c = 0, a = _list, b = list, loop = false; k < len; k++){
            tar = this["list"][k];
            
            if(this.isDraw(tar) === false){
                if(tar["overlap"] !== false) tar["overlap"] = false;
                continue;
            }

            if(box["intersectsBox"](tar["box"]) === true){
                if(tar["overlap"] !== true) tar["overlap"] = true;
                box["expand"](tar["box"]);
                loop = true;

                while(loop === true){
                    b["length"] = 0;
                    loop = false;
                    c = _c;

                    for(i = 0; i < c; i++){
                        tar = a[i];

                        if(box["intersectsBox"](tar["box"]) === true){
                            if(tar["overlap"] !== true) tar["overlap"] = true;
                            box["expand"](tar["box"]);
                            loop = true; _c--;
                        }

                        else b.push(tar);
                        
                    }

                    a = a === _list ? list : _list;
                    b = b === _list ? list : _list;

                }
                
            }

            else{
                _c++;
                a["push"](tar);
                if(tar["overlap"] !== false) tar["overlap"] = false;
            }

        }
        
        _list.length = list.length = 0;
    }

    _drawImage(ca, ox = 0, oy = 0){
        if(ca.path2D !== null && ca.path2D.drawBefore === true){
            this._drawPath2D(ca, ox, oy);
        }
        
        if(ca["opacity"] === 1){
            if(ca.scaleEnable === true && ca.width === ca.box.w && ca.height === ca.box.h) this["context"]["drawImage"](ca["image"], ca["box"]["x"]-this.#box.x+ox, ca["box"]["y"]-this.#box.y+oy);
            else this["context"]["drawImage"](ca["image"], ca["box"]["x"]-this.#box.x+ox, ca["box"]["y"]-this.#box.y+oy, ca.box.w, ca.box.h);
        }

        else{
            this["context"]["globalAlpha"] = ca["opacity"];
            if(ca.scaleEnable === true && ca.width === ca.box.w && ca.height === ca.box.h) this["context"]["drawImage"](ca["image"], ca["box"]["x"]-this.#box.x+ox, ca["box"]["y"]-this.#box.y+oy);
            else this["context"]["drawImage"](ca["image"], ca["box"]["x"]-this.#box.x+ox, ca["box"]["y"]-this.#box.y+oy, ca.box.w, ca.box.h);
            this["context"]["globalAlpha"] = 1;
        }
        
        if(ca.path2D !== null && ca.path2D.drawBefore !== true){
            this._drawPath2D(ca, ox, oy);
        }
    }

    _drawPath2D(ca, ox = 0, oy = 0){
        const con = this.context, 
        x = ca["box"]["x"]-this.#box.x+ox, 
        y = ca["box"]["y"]-this.#box.y+oy,
        value = ca.path2D.value;

        switch(ca.path2D.pathType){
            case "line": 
            con.beginPath();

            var vx = value.x < 0 ? 0 : value.x > ca.box.w ? ca.box.w : value.x, 
            vy = value.y < 0 ? 0 : value.y > ca.box.h ? ca.box.h : value.y;
            con.moveTo(vx+x, vy+y);
            
            vx = value.x1 < 0 ? 0 : value.x1 > ca.box.w ? ca.box.w : value.x1;
            vy = value.y1 < 0 ? 0 : value.y1 > ca.box.h ? ca.box.h : value.y1;
            con.lineTo(vx+x, vy+y);

            if(ca.path2D.drawStyle === null) con.stroke();
            else{
                con.save();
                let n = "";
                for(n in ca.path2D.drawStyle){
                    if(ca.path2D.drawStyle[n] !== con[n]) con[n] = ca.path2D.drawStyle[n];
                }
                con.stroke();
                con.restore();
            }
            break;

            case "path2D": 
            con.save();
            con.beginPath();
            con.rect(x, y, ca.box.w, ca.box.h);
            con.clip();
            this.context.translate(x, y);
            if(ca.path2D.drawStyle === null) con[ca.path2D.drawType](value);
            else{
                let n = "";
                for(n in ca.path2D.drawStyle){
                    if(ca.path2D.drawStyle[n] !== con[n]) con[n] = ca.path2D.drawStyle[n];
                }
                con[ca.path2D.drawType](value);
            }
            con.restore();
            break;
        }
    }

    _draw(ca){
        if(ca.rotate === null) this._drawImage(ca);
        else{
            const cx = ca.rotate.origin.x + ca.box.x - this.#box.x, 
            cy = ca.rotate.origin.y + ca.box.y - this.#box.y;
            this.context.translate(cx, cy);
            this.context.rotate(ca.rotate.angle);
            this._drawImage(ca, -cx, -cy);
            this.context.rotate(-ca.rotate.angle);
            this.context.translate(-cx, -cy);
        }
    }
    
    _drawTarget(){
        const len = this["list"]["length"];
        for(let k = 0, ci; k < len; k++){
            ci = this["list"][k];
            if(ci["overlap"] === true) this._draw(ci);
        }
    }

}




/* CanvasImageEvent (CanvasImageRender 的dom事件)
ca 必须的属性: visible, box, rotate, index
ca 必须的方法: 没有;

parameter:
    domElement: CanvasImageRender.domElement; //必须
    box: CanvasImageRender.box; //必须
    ||或者第一个参数为 CanvasImageRender

    与.initEvent(domElement, box)参数一样

attribute:
    domElement
    box: Box;

method:
    add(ca: CanvasImage, eventName: String, callback: Function): ca; //ca添加事件
    remove(ca: CanvasImage, eventName: String, callback: Function): ca; //ca删除事件
        eventName: 可能的值为 CanvasImageEvent.canvasEventsList 的属性名
        callback: 参数 event, ca
    
    clear(ca: CanvasImage, eventName: String): ca; //ca 必须; eventName 可选, 如果未定义则清空ca的所有事件;
    disposeEvent(eventName): this; //.initEvent(domElement, box)调用一次此方法
    initEvent(domElement, box): this; //每次更换 domElement, box 后应调用此方法; (CanvasAnimateEvent初始化时自动调用一次)
    setScale(x, y: Number): undefiend; //
    bindEventClick(ci, callback, clickDelay = 300): Func; //同时兼容pc和mobile端的click事件

eventName:
    (如果注册了 "out"|"over" 事件, 在弃用时(CanvasImageRender 不在使用): 
    必需要调用.disposeEvent(eventName)方法清理注册的dom事件, 
    因为这两个事件用的是 pointermove 而不是 onpointermove);

    down    //鼠标左右键按下
    move    //鼠标左右键移动
    up        //鼠标左右键抬起

    click    //鼠标左键
    wheel    //鼠标滚动轮
    out        //移出
    over    //移入

demo:
    const car = new CanvasImageRender({width: 100, height: 100}),
    cae = new CanvasImageEvent(car),
    ca = car.add(new CanvasImage(image));

    //ca添加点击事件
    cae.add(ca, 'click', (event, target) => console.log(event, target));

    car.render();

*/
class CanvasImageEvent{

    static bind(obj, is){
        /* const _eventList = {}
        Object.defineProperty(obj, "_eventList", {
            get(){return _eventList;}
        }); */
        obj._eventList = {};
        if(is === true){
            let k, evns = CanvasImageEvent.canvasEventsList;
            for(k in evns) obj._eventList[k] = [];
        }
            
    }

    static canvasEventsList = {
        down: "onpointerdown",
        move: "onpointermove",
        up: "onpointerup",
        click: "onclick",
        wheel: "onmousewheel",
        out: "pointermove", //移出 
        over: "pointermove", //移入
    }

    static isEventName(eventName){

        return CanvasImageEvent.canvasEventsList[eventName] !== undefined;

    }
    
    static emptyBox = new Box();
    static emptyRotate = new Rotate();

    constructor(domElement, box){
        this._running = "";
        this._delList = [];
        CanvasImageEvent.bind(this);
        this.initEvent(domElement, box);
    }

    initEvent(domElement, box){
        this.disposeEvent();

        if(CanvasImageRender.prototype.isPrototypeOf(domElement)){
            this.domElement = domElement.domElement;
            this.box = domElement.box;
        }

        else{
            this.domElement = domElement;
            this.box = box;
        }

        if(this._eventList !== undefined){
            for(let evn in this._eventList){
                if(this._eventList[evn] !== undefined) this._createEvent(evn);
            }

        }
        
        return this;
    }

    add(ca, eventName, callback){
        if(CanvasImageEvent.canvasEventsList[eventName] === undefined) return console.warn("CanvasImageEvent: 参数错误 "+ eventName);
        if(typeof callback !== "function") return console.warn("CanvasImageEvent: 事件添加失败,参数错误");
        
        this._add(ca, eventName);
        this._addCA(ca, eventName, callback);
        
        return ca;
    }
    
    remove(ca, eventName, callback){
        if(CanvasImageEvent.canvasEventsList[eventName] === undefined) return console.warn("CanvasImageEvent: 参数错误 "+ eventName);
        if(typeof callback !== "function") return console.warn("CanvasImageEvent: 事件添加失败,参数错误");
        if(this._running !== eventName){
            this._remove(ca, eventName);
            this._removeCA(ca, eventName, callback);
        }

        else this._delList.push(ca, eventName, callback);

        return ca;
    }

    disposeEvent(eventName){
        if(eventName === "over" || eventName === "out"){

            if(typeof this["_"+eventName] === "function"){
                this.domElement.removeEventListener(CanvasImageEvent.canvasEventsList[eventName], this["_"+eventName]);
                delete this["_"+eventName];
            }

        }

        else{

            if(typeof this["_over"] === "function"){
                this.domElement.removeEventListener(CanvasImageEvent.canvasEventsList["over"], this["_over"]);
                delete this["_over"];
            }

            if(typeof this["_out"] === "function"){
                this.domElement.removeEventListener(CanvasImageEvent.canvasEventsList["out"], this["_out"]);
                delete this["_out"];
            }

        }

        return this;
    }
    
    clear(ca, eventName){
        if(eventName === undefined){
            var k; for(k in this._eventList){
                this._remove(ca, k);
            }
            
            if(ca._eventList !== undefined) delete ca._eventList; //CanvasImageEvent.bind(ca, true);
            
        }

        else if(CanvasImageEvent.canvasEventsList[eventName] !== undefined){
            this._remove(ca, eventName);

            if(ca._eventList !== undefined) ca._eventList[eventName].length = 0;
            
        }

        return ca;
    }

    bindEventClick(ci, callback, callbackDown = null, clickDelay = 300){
        if(typeof callback !== "function") return console.warn("[CanvasImageEvent] bindEventClick: 参数错误");
        var pointerId = -1, isDown = false, sTime = 0;

        const _onup = () => {
            this.remove(ci, "up", onup);
            isDown = false;
        },

        onup = (event, target) => {
            if(isDown){
                _onup();
                if(event.pointerId === pointerId && Date.now() - sTime < clickDelay) callback(event, target);
            }
        },

        ondown = (event, target) => {
            if(isDown) _onup();
            if(event.button !== 0) return;

            sTime = Date.now();
            pointerId = event.pointerId;
            isDown = true;
            
            if(callbackDown !== null) callbackDown(event, target);
            this.add(ci, "up", onup);
        }

        this.add(ci, "down", ondown);

        return () => {
            _onup();
            this.remove(ci, "down", ondown);
        }
    }

    _addCA(ca, eventName, callback){
        if(ca._eventList === undefined) CanvasImageEvent.bind(ca);
        if(ca._eventList[eventName] === undefined) ca._eventList[eventName] = [];
        ca._eventList[eventName].push(callback);

    }

    _removeCA(ca, eventName, callback){
        if(ca._eventList !== undefined && ca._eventList[eventName] !== undefined){
            for(let k = 0, len = ca._eventList[eventName].length; k < len; k++){
                if(ca._eventList[eventName][k] === callback){
                    ca._eventList[eventName].splice(k, 1);
                    break;
                }
            }
        }

    }

    _add(ca, eventName){
        if(this._eventList[eventName] === undefined){
            this._eventList[eventName] = [];
            this._createEvent(eventName);
        }

        //if(this._eventList[eventName].includes(ca) === false) this._eventList[eventName].push(ca);
        this._eventList[eventName].push(ca);
    }

    _remove(ca, eventName){
        if(this._eventList[eventName] !== undefined){
            let key = this._eventList[eventName].indexOf(ca);
            if(key !== -1) this._eventList[eventName].splice(key, 1);
            if(key === 0){
                if(eventName == "over" || eventName === "out") this.disposeEvent(eventName);
                else this.domElement[CanvasImageEvent.canvasEventsList[eventName]] = null;
                delete this._eventList[eventName];
            }

        }

    }

    _createEvent(evn){
        var k, len, ca, arr, tar = null, oldTar = null, _run = null, offsetX, offsetY;

        const _box = CanvasImageEvent.emptyBox, _rotate = CanvasImageEvent.emptyRotate,

        run = event => {
            len = this["_eventList"][evn].length;
            if(len === 0) return;

            offsetX = event.offsetX + this.box.x;
            offsetY = event.offsetY + this.box.y;

            tar = null;
            for(k = 0; k < len; k++){
                ca = this["_eventList"][evn][k];
                _box.copy(ca.box);

                //计算旋转后的box
                if(ca.rotate !== null) _box.setFromRotate(_rotate.set(_box.x+ca.rotate.origin.x, _box.y+ca.rotate.origin.y, ca.rotate.angle));
                
                if(ca["visible"] === true && _box.containsPoint(offsetX, offsetY)){
                    
                    if(tar === null || tar["index"] < ca["index"]) tar = ca;
                    
                }

            }
            
            if(_run !== null) _run();
            if(tar !== null){
                this._running = evn;
                arr = tar["_eventList"][evn]; 
                len = arr.length;
                for(k = 0; k < len; k++) arr[k](event, tar);
                
                tar = null;

                len = this._delList.length;
                for(k = 0; k < len; k += 3){
                    this._remove(this._delList[k], this._delList[k+1]);
                    this._removeCA(this._delList[k], this._delList[k+1], this._delList[k+2]);
                }
                this._running = "";
                this._delList.length = 0;
            }
            
        }
        
        if(evn === "over" || evn === "out"){
            this.domElement.addEventListener(CanvasImageEvent.canvasEventsList[evn], run);
            this["_"+evn] = run;
            if(evn === "over"){
                _run = ()=>{
                    if(tar !== null){
                        if(oldTar !== null){
                            if(oldTar !== tar) oldTar = tar;
                            else tar = null;
                        }
                        else oldTar = tar;
                    }
                    else if(oldTar !== null) oldTar = null;
    
                }

            }

            else{
                let _tar = null;
                _run = ()=>{
                    if(tar !== null){
                        if(oldTar !== null){
                            if(oldTar !== tar){
                                _tar = tar;
                                tar = oldTar;
                                oldTar = _tar;
                            }
                            else tar = null;
                        }
                        else{
                            oldTar = tar;
                            tar = null;
                        }
                    }
                    else if(oldTar !== null){
                        tar = oldTar;
                        oldTar = null;
                    }
    
                }

            }

            /* _run = ()=>{
                if(tar !== null){
                    if(oldTar !== null){

                        if(oldTar !== tar){
                            if(evn === "over") oldTar = tar;
                            else{
                                let _tar = tar;
                                tar = oldTar;
                                oldTar = _tar;
                            }
                        }

                        else tar = null;

                    }

                    else{
                        oldTar = tar;
                        if(evn === "out") tar = null;
                        
                    }
                    
                }

                else{
                    if(oldTar !== null){
                        if(evn === "out") tar = oldTar;
                        oldTar = null;
                    }
                    
                }

            } */
            
        }

        else this.domElement[CanvasImageEvent.canvasEventsList[evn]] = run;

    }

}




/* CanvasImageScroll (CanvasImageRender 的滚动条)

待解决的问题:
    1 当某个ci与scroll重叠时, cir.redrawTarget(ci)方法无法检测到scroll(不能重绘滚动条); 把scroll视图挂载到ci可以解决此问题(用ci的path2D动态更新)

parameter:
    cir: CanvasImageRender, 
    cie: CanvasImageEvent, 
    option: Object{
        domEventTarget: //dom事件的绑定目标html元素; 默认 cir.domElement
        scrollSize        //滚动轴的宽或高; 默认 10; (如果想隐藏滚动条最好用 scrollVisible, 而不是把此属性设为0)
        scrollVisible    //滚动轴的显示类型; 可能值: 默认"auto" || "visible" || "";
        scrollEventType    //可能的值: 默认"default", "touch" || "";
        inertia            //是否启用移动端滚动轴的惯性; 默认 true;
        inertiaLife        //移动端滚动轴惯性生命(阻力强度); 0 - 1; 默认 0.04;
    }

*/
class CanvasImageScroll{

    static unbindScroll(box){
        var _x = box.x, _y = box.y, _w = box.w, _h = box.h;
        Object.defineProperties(box, {

            x: {
                get(){return _x;},
                set(v){_x = v;}
            },

            y: {
                get(){return _y;},
                set(v){_y = v;}
            },

            w: {
                get(){return _w;},
                set(v){_w = v;}
            },

            h: {
                get(){return _h;},
                set(v){_h = v;}
            },

        });
    }

    #cir = null;
    #scrollViewBoxX = new Box();
    #scrollViewBoxY = new Box();
    #maxSize = new Point();
    get maxSize(){return this.#maxSize;}
    
    constructor(cir, cie, option = {}){
        this.#cir = cir;
        this.scrollSize = UTILS.isNumber(option.scrollSize) ? option.scrollSize : 10;
        
        const oninitList = event => {
            const len = cir.list.length;
            for(let k = event ? event.index : 0; k < len; k++) this.bindScroll(cir.list[k]);
            this.resetMaxSizeX();
            this.resetMaxSizeY();
        }

        switch(option.scrollVisible){
            case "visible": 
            this.scrollVisible = option.scrollVisible;
            break;

            case "": 
            this.scrollVisible = "";
            break;

            case "auto": 
            default: 
            this.scrollVisible = "auto";
            break;
        }

        switch(option.scrollEventType){
            case "touch": 
            this.createScrollEventMobile(cie, option.domEventTarget || cir.domElement, option.inertia, option.inertiaLife);
            break;

            case "": 
            break;

            case "default": 
            default: 
            this.createScrollEventPC(cie);
            break;
        }
        
        if(EventDispatcher.prototype.isPrototypeOf(cir.eventDispatcher)){
            const box = this.#cir.box;

            cir.eventDispatcher.register("boxX", ()=>{
                if(box.x < 0) box.x = 0;
                else if(box.mx > this.#maxSize.x) box.x = this.#maxSize.x - box.w;
            });
            cir.eventDispatcher.register("boxY", ()=>{
                if(box.y < 0) box.y = 0;
                else if(box.my > this.#maxSize.y) box.y = this.#maxSize.y - box.h;
            });

            cir.eventDispatcher.register("add", event => {
                const ciBox = event.value.box;
                this.bindScroll(event.value);
                ciBox.w = ciBox.w;
                ciBox.h = ciBox.h;
            });
            cir.eventDispatcher.register("remove", event => {
                const ciBox = event.value.box;
                if(ciBox.mx >= this.#maxSize.x) this.resetMaxSizeX();
                if(ciBox.my >= this.#maxSize.y) this.resetMaxSizeY();
                CanvasImageScroll.unbindScroll(ciBox);
            });
            
            cir.eventDispatcher.register("initList", oninitList);

            cir.eventDispatcher.register("afterDraw", () => {
                if(this.scrollVisible !== ""){
                    this.updateScrollViewBox();
                    this.drawScroll();
                }
            });

        }

        else console.warn("CanvasImageScroll: 请定义 eventDispatcher");
        
        if(cir.list.length !== 0) oninitList();
    }

    updateScrollViewBox(){
        this.#scrollViewBoxX.x = this.cursorX();
        this.#scrollViewBoxX.y = this.#cir.box.h - this.scrollSize;
        this.#scrollViewBoxX.w = this.#maxSize.x <= this.#cir.box.w ? this.#cir.box.w : this.#cir.box.w / this.#maxSize.x * this.#cir.box.w;
        this.#scrollViewBoxX.h = this.scrollSize;

        this.#scrollViewBoxY.x = this.#cir.box.w - this.scrollSize;
        this.#scrollViewBoxY.y = this.cursorY();
        this.#scrollViewBoxY.w = this.scrollSize;
        this.#scrollViewBoxY.h = this.#maxSize.y <= this.#cir.box.h ? this.#cir.box.h : this.#cir.box.h / this.#maxSize.y * this.#cir.box.h;
    }

    drawScroll(){
        if(this.scrollVisible === "visible" || (this.scrollVisible === "auto" && this.#maxSize.x > this.#cir.box.w)){
            this.#cir.context.fillRect(this.#scrollViewBoxX.x, this.#scrollViewBoxX.y, this.#scrollViewBoxX.w, this.#scrollViewBoxX.h);
            this.#cir.context.strokeRect(this.#scrollViewBoxX.x, this.#scrollViewBoxX.y, this.#scrollViewBoxX.w, this.#scrollViewBoxX.h);
        }

        if(this.scrollVisible === "visible" || (this.scrollVisible === "auto" && this.#maxSize.y > this.#cir.box.h)){
            this.#cir.context.fillRect(this.#scrollViewBoxY.x, this.#scrollViewBoxY.y, this.#scrollViewBoxY.w, this.#scrollViewBoxY.h);
            this.#cir.context.strokeRect(this.#scrollViewBoxY.x, this.#scrollViewBoxY.y, this.#scrollViewBoxY.w, this.#scrollViewBoxY.h);
        }
    }

    createScrollEventPC(cie){
        var dPos = -1;

        const _box = this.#cir.box, scope = this,
        
        setTop = (event, top) => {
            _box.y = top / _box.h * this.#maxSize.y;
            this.#cir.redraw();
        },

        setLeft = (event, left) => {
            _box.x = left / _box.w * this.#maxSize.x;
            this.#cir.redraw();
        },
        
        onMoveTop = event => {
            setTop(event, event.offsetY - dPos);
        },

        onMoveLeft = event => {
            setLeft(event, event.offsetX - dPos);
        },

        onUpTop = event => {
            document.body.removeEventListener('pointermove', onMoveTop);
            document.body.removeEventListener('pointerup', onUpTop);
            if(event !== null) onMoveTop(event);
        },

        onUpLeft = event => {
            document.body.removeEventListener('pointermove', onMoveLeft);
            document.body.removeEventListener('pointerup', onUpLeft);
            if(event !== null) onMoveLeft(event);
        },

        //伪 CanvasImage, 是 CanvasImageEvent 使用的必须属性
        boxX = new Box(),
        eventTargetX = {
            get index(){return Infinity;},
            get visible(){return true;},
            get box(){return boxX},
            get rotate(){return null},
        },
        
        boxY = new Box(),
        eventTargetY = {
            get index(){return Infinity;},
            get visible(){return true;},
            get box(){return boxY},
            get rotate(){return null},
        },

        eventTargetWheel = {
            get index(){return -1;},
            get visible(){return true;},
            get box(){return _box},
            get rotate(){return null},
        }

        Object.defineProperties(boxX, {
            x: {get: () => {return _box.x;}},
            y: {get: () => {return _box.h - scope.scrollSize + _box.y;}},
            w: {get: () => {return _box.w;}},
            h: {get: () => {return scope.scrollSize;}},
        });

        Object.defineProperties(boxY, {
            x: {get: () => {return _box.w - scope.scrollSize + _box.x;}},
            y: {get: () => {return _box.y;}},
            w: {get: () => {return scope.scrollSize;}},
            h: {get: () => {return _box.h;}},
        });

        //pc event
        cie.add(eventTargetX, "down", event => {
            dPos = event.offsetX - this.cursorX();
            onUpLeft(null);
            document.body.addEventListener("pointermove", onMoveLeft);
            document.body.addEventListener("pointerup", onUpLeft);
        });

        cie.add(eventTargetY, "down", event => {
            dPos = event.offsetY - this.cursorY();
            onUpTop(null);
            document.body.addEventListener("pointermove", onMoveTop);
            document.body.addEventListener("pointerup", onUpTop);
        });

        cie.add(eventTargetWheel, "wheel", event => {
            if(this.#maxSize.y > _box.h){
                dPos = 50 / this.#maxSize.y * _box.h;
                setTop(event, this.cursorY() + (event.wheelDelta === 120 ? -dPos : dPos));
            }
            else if(this.#maxSize.x > _box.w){
                dPos = 50 / this.#maxSize.x * _box.w;
                setLeft(event, this.cursorX() + (event.wheelDelta === 120 ? -dPos : dPos));
            }
        });

    }

    createScrollEventMobile(cie, domElement, inertia = true, inertiaLife){
        var px, py, dPos = 0, sPos = new Point(), step = 1, aniamteRun = false, stepA = "", stepB = "", sTime = 0;

        const _box = this.#cir.box;

        if(inertia === true){
            inertiaLife = 1 - ((UTILS.isNumber(inertiaLife) && inertiaLife >= 0 && inertiaLife <= 1) ? inertiaLife : 0.04);
            var inertiaAnimate = new AnimateLoop(null),
        
            inertiaTop = (event, speed) => {
                if(Math.abs(speed) < 1) return;
                
                stepA = speed < 0 ? "-top" : "top";
                if(aniamteRun && stepA === stepB) step += 0.3;
                else{
                    step = 1;
                    stepB = stepA;
                }
                
                inertiaAnimate.play(() => {
                    speed *= inertiaLife;
                    setTop(event, _box.y + step * 20 * speed);
                    if(Math.abs(speed) < 0.001 || _box.y <= 0 || _box.my >= this.#maxSize.y) inertiaAnimate.stop();
                });
            },

            inertiaLeft = (event, speed) => {
                if(Math.abs(speed) < 1) return;
                stepA = speed < 0 ? "-left" : "left";
                if(aniamteRun && stepA === stepB) step += 0.3;
                else{
                    step = 1;
                    stepB = stepA;
                }
                inertiaAnimate.play(() => {
                    speed *= inertiaLife;
                    setLeft(event, _box.x + step * 20 * speed);
                    if(Math.abs(speed) < 0.001 || _box.x <= 0 || _box.mx >= this.#maxSize.x) inertiaAnimate.stop();
                });
            }
        }

        const setTop = (event, top) => {
            _box.y = top;
            this.#cir.redraw();
        },

        setLeft = (event, left) => {
            _box.x = left;
            this.#cir.redraw();
        },
        
        onMoveTop = event => {
            setTop(event, dPos - event.offsetY);
        },

        onMoveLeft = event => {
            setLeft(event, dPos - event.offsetX);
        },

        onUpTop = event => {
            document.body.removeEventListener('pointermove', onMoveTop);
            document.body.removeEventListener('pointerup', onUpTop);
            if(event !== null){
                onMoveTop(event);
                if(inertia === true) inertiaTop(event, (_box.y - sPos.y) / (Date.now() - sTime));
            }
        },

        onUpLeft = event => {
            document.body.removeEventListener('pointermove', onMoveLeft);
            document.body.removeEventListener('pointerup', onUpLeft);
            if(event !== null){
                onMoveLeft(event);
                if(inertia === true) inertiaLeft(event, (_box.x - sPos.x) / (Date.now() - sTime));
            }
        },

        eventTarget = {
            get index(){return -1;}, //最低优先
            get visible(){return true;},
            get box(){return _box;},
            get rotate(){return null},
        },

        a1 = Math.PI / 4, a2 = Math.PI / 2 + a1,

        onUp = event => {
            domElement.removeEventListener("pointerup", onUp);
            domElement.removeEventListener('pointermove', onMove);
        },

        onMove = event => {
            dPos++; if(dPos < 4) return;
            onUp(event);
            const a = Math.atan2(event.pageY - py, event.pageX - px);
            if((a < a2 && a >= a1) || (a < -a1 && a >= -a2)){ //y轴
                if(this.#maxSize.y > _box.h){
                    dPos = py + sPos.y;
                    document.body.addEventListener("pointermove", onMoveTop);
                    document.body.addEventListener("pointerup", onUpTop);
                }
            }
            else{ //x轴
                if(this.#maxSize.x > _box.w){
                    dPos = px + sPos.x;
                    document.body.addEventListener("pointermove", onMoveLeft);
                    document.body.addEventListener("pointerup", onUpLeft);
                }
            }
        }
    
        cie.add(eventTarget, "down", event => {
            px = event.offsetX;
            py = event.offsetY;
            dPos = 0;
            sPos.set(_box.x, _box.y);
            sTime = Date.now();

            if(inertia === true){
                aniamteRun = inertiaAnimate.running;
                inertiaAnimate.stop();
            }

            //防止没触发 move 或 up 事件;
            onUpLeft(null);
            onUpTop(null);
            onUp();
            
            domElement.addEventListener("pointermove", onMove);
            domElement.addEventListener("pointerup", onUp);
        });
    }

    bindScroll(ci){
        const box = ci.box;
        var _visible = typeof ci.visible === "boolean" ? ci.visible : true, 
        _x = box.x, _y = box.y, _w = box.w, _h = box.h, nm, om;

        const writeBoxX = () => {
            if(nm > this.#maxSize.x) this.#maxSize.x = nm;
            else if(nm < this.#maxSize.x){
                if(om >= this.#maxSize.x) this.resetMaxSizeX();
            }
        },

        writeBoxY = () => {
            if(nm > this.#maxSize.y) this.#maxSize.y = nm;
            else if(nm < this.#maxSize.y){
                if(om >= this.#maxSize.y) this.resetMaxSizeY();
            }
        };

        Object.defineProperties(box, {

            x: {
                get: () => {return _x;},
                set: v => {
                    if(_visible){
                        om = _x+_w;
                        _x = v;
                        nm = v+_w;
                        writeBoxX();
                    }else{
                        _x = v;
                    }
                }
            },

            y: {
                get: () => {return _y;},
                set: v => {
                    if(_visible){
                        om = _y+_h;
                        _y = v;
                        nm = v+_h;
                        writeBoxY();
                    }else{
                        _y = v;
                    }
                }
            },

            w: {
                get: () => {return _w;},
                set: v => {
                    if(_visible){
                        om = _w+_x;
                        _w = v;
                        nm = v+_x;
                        writeBoxX();
                    }else{
                        _w = v;
                    }
                }
            },

            h: {
                get: () => {return _h;},
                set: v => {
                    if(_visible){
                        om = _h+_y;
                        _h = v;
                        nm = v+_y;
                        writeBoxY();
                    }else{
                        _h = v;
                    }
                }
            },

        });

        Object.defineProperties(ci, {

            visible: {
                get: () => {return _visible;},
                set: v => {
                    if(v === true){
                        _visible = true;
                        box.w = _w;
                        box.h = _h;
                    }
                    else if(v === false){
                        _visible = false;
                        if(_x + _w >= this.#maxSize.x) this.resetMaxSizeX();
                        if(_y + _h >= this.#maxSize.y) this.resetMaxSizeY();
                    }
                }
            },

        });
    }

    resetMaxSizeX(){
        this.#maxSize.x = 0;
        for(let k = 0, len = this.#cir.list.length, m; k < len; k++){
            if(this.#cir.list[k].visible === false) continue;
            m = this.#cir.list[k].box.mx;
            if(m > this.#maxSize.x) this.#maxSize.x = m;
        }
    }

    resetMaxSizeY(){
        this.#maxSize.y = 0;
        for(let k = 0, len = this.#cir.list.length, m; k < len; k++){
            if(this.#cir.list[k].visible === false) continue;
            m = this.#cir.list[k].box.my;
            if(m > this.#maxSize.y) this.#maxSize.y = m;
        }
    }

    cursorX(v = this.#cir.box.x){
        return v/this.#maxSize.x*this.#cir.box.w;
    }

    cursorY(v = this.#cir.box.y){
        return v/this.#maxSize.y*this.#cir.box.h;
    }

}




/* CanvasPath2D (CanvasImage.path2D)
parameter: drawBefore = true, drawType = "stroke", drawStyle = null

attributes:
    drawBefore: Bool;     //是否在 CanvasImage 之前绘制
    drawType: String;    //填充路径或描绘路径 可能值: 默认 stroke | fill
    drawStyle: Object;    //canvas.context的属性

method:
    line(line: Line): undefined;         //注意: 参数属性值都是相对于CanvasImage的位置, 参数为引用, 既当参数的属性发生改变时下一次绘制也会生效
    path(path2D: Path2D): undefined;    //

demo:
    const test = new CanvasImageCustom().size(100, 100).pos(100, 100).rect().fill("#664466");
    test.path2D = new CanvasPath2D(false, "stroke", {strokeStyle: "blue", lineWidth: 4});

    const path2D = new Path2D();
    path2D.roundRect(12, 12, 40, 40, 10); //圆角矩形
    test.path2D.path(path2D);

    //test.path2D.line(new Line(4, 4, 4, 150000));

*/
class CanvasPath2D{

    static emptySVGMatrix = document.createElementNS("http://www.w3.org/2000/svg", "svg").createSVGMatrix();
    static resetSVGMatrix(svgMatrix = CanvasPath2D.emptySVGMatrix){
        svgMatrix.a = svgMatrix.d = 1;
        svgMatrix.b = svgMatrix.c = 
        svgMatrix.e = svgMatrix.f = 0;
    }

    #pathType = "";
    get pathType(){
        return this.#pathType;
    }

    #value = null;
    get value(){
        return this.#value;
    }

    constructor(drawBefore = true, drawType = "stroke", drawStyle = null){
        this.drawBefore = drawBefore;
        this.drawStyle = drawStyle;
        this.drawType = drawType;
    }

    line(line){
        this.#pathType = "line";
        this.#value = line;
    }

    path(path2D){
        this.#pathType = "path2D";
        this.#value = path2D;
    }

}




/* CanvasImage (CanvasImageRender 的渲染目标)
parameter: 
    image (构造器会调用一次 .setImage(image) 来处理 image 参数)

attribute:
    opacity: Float;     //透明度; 值0至1之间; 默认1;
    visible: Boolean;    //默认true; 完全隐藏(既不绘制视图, 也不触发绑定的事件, scroll也忽略此ci)
    box: Box;             //.x.y 图像的位置, .w.h 图像的宽高;
    rotate: Roate;        //旋转; 默认 null (注意: 旋转的原点是相对于 box.x.y 的)
    暂未实现, 先用box.w.h代替缩放//scale: Box;            //缩放; .x.y中心点, .w.h缩放; 默认 null; (注意: 缩放的原点是相对于 box.x.y 的)
    path2D: CanvasPath2D;//此属性一般用于动态绘制某个形状
    scaleEnable: Bool;    //是否启用(允许)缩放; 默认true
    
    //以下属性不建议直接修改
    overlap: Object; //CanvasImageRender.computeOverlaps(ca) 方法更新
    index: Integer; //CanvasImageRender.index(ca) 修改

    //只读属性: box, image, x, y, width, height, scaleX, scaleY, loadingImage, className

method:
    loadImage(src, onload): this;    //加载并设置图像 (onload 如果是 CanvasImageRender 则加载完后自动调用一次 redraw 或 render 方法);
    loadVideo(src, onload, type = "mp4")
    
    pos(x, y): this;             //设置位置; x 可以是: Number, Object{x,y}
    setImage(image): this;         //设置图像 (image 如果是 CanvasImage 并它正在加载图像时, 则会在它加载完成时自动设置 image);
    setScaleX(s, x): undefined;    //缩放x
    setScaleY(s, y): undefined;    //缩放y
        s为必须, s小于1为缩小, 大于1放大;
        x默认为0, x是box的局部位置, 如果是居中缩放x应为: box.w/2

demo:
    //CanvasImageRender
    const cir = new CanvasImageRender({width: WORLD.width, height: WORLD.height});
    cir.domElement.style = `
        position: absolute;
        z-index: 9999;
        background: rgb(127,127,127);
    `;

    //values
    const ciA = cir.add(new CanvasImage()).pos(59, 59).load("view/examples/img/test.png", cir);
    ciA.opacity = 0.2; //设置透明度

    const ciB = cir.add(new CanvasImage(ciA)).pos(59, 120);
    ciB.rotate = new Rotate().toAngle(45); //旋转45度

    //event
    const cie = new CanvasImageEvent(cir); //注意: CanvasImage 的缩放和旋转都会影响到 CanvasImageEvent
    cie.add(ciB, "click", event => { //ciB 添加 点击事件
        console.log("click ciB: ", event);
    });


    //这个用于搭载H5视频 video
    cir.add(new CanvasImage())

    .loadVideo("view/examples/video/test.mp4", ci => {
        
        //同比例缩放视频
        const newSize = UTILS.setSizeToSameScale(ci.image, {width: 100, height: 100});
        ci.box.size(newSize.width, newSize.height).center(cir.box);

        //播放按钮
        const cic = cir.add(new CanvasImageCustom())
        .size(50, 30).text("PLAY", "#fff")
        .rect(4).stroke("blue");
        cic.box.center(cir.box);

        //动画循环
        const animateLoop = new AnimateLoop(() => cir.redraw());

        //谷歌浏览器必须要用户与文档交互一次才能播放视频 (点击后播放动画)
        cir.addEvent(cic, "up", () => {
            cic.visible = false;
            ci.image.play(); // ci.image 其实是一个 video 元素
            animateLoop.play(); //播放动画
        });
        
        //把 canvas 添加至 dom 树
        cir.render();

    });

*/
class CanvasImage{

    #box = new Box();
    #image = null;
    #loadingImage = false;
    get box(){return this.#box;}
    get image(){return this.#image;}
    get loadingImage(){return this.#loadingImage;}

    get className(){return this.constructor.name;}
    get x(){return this.box.x;}
    get y(){return this.box.y;}
    get width(){return this.#image !== null ? this.#image.width : 0;}
    get height(){return this.#image !== null ? this.#image.height : 0;}
    get scaleX(){return this.#box.w / this.#image.width;}
    get scaleY(){return this.#box.h / this.#image.height;}
    
    constructor(image){
        this.opacity = 1;
        this.visible = true;
        this.rotate = null;
        this.scaleEnable = true;
        this.path2D = null;

        //以下属性不建议直接修改
        this.overlap = false;
        this.index = -1;

        this.setImage(image);
    }

    pos(x, y){
        if(UTILS.isNumber(x)){
            this.box.x = x;
            this.box.y = y;
        }
        else if(UTILS.isObject(x)){
            this.box.x = x.x;
            this.box.y = x.y;
        }
        return this;
    }

    setImage(image){
        if(CanvasImageRender.isCanvasImage(image)){
            this.box.size(image.width, image.height);
            this.#image = image;
        }
        else if(CanvasImage.prototype.isPrototypeOf(image)){
            if(image.loadingImage){
                if(Array.isArray(image.__setImageList)) image.__setImageList.push(this);
                else image.__setImageList = [this];
            }
            else this.setImage(image.image);
        }
        else{
            this.box.size(0, 0);
            this.#image = null;
        }
        return this;
    }

    setScaleX(s, x = 0){
        const oldVal = this.#box.w;
        this.#box.w = this.width * s;
        this.#box.x += x - this.#box.w / oldVal * x;
    }

    setScaleY(s, y = 0){
        const oldVal = this.#box.h;
        this.#box.h = this.height * s;
        this.#box.y += y - this.#box.h / oldVal * y;
    }

    loadImage(src, onload){
        this.#loadingImage = true;
        const image = new Image();
        image.onload = () => this._loadSuccess(image, onload);
        image.src = src;
        return this;
    }

    loadVideo(src, onload, type = "mp4"){
        /*    video 加载事件 的顺序
            onloadstart
            ondurationchange
            onloadedmetadata //元数据加载完成包含: 时长，尺寸大小（视频），文本轨道。
            onloadeddata
            onprogress
            oncanplay
            oncanplaythrough

            //控制事件:
            onended //播放结束
            onpause //暂停播放
            onplay //开始播放
        */
        this.#loadingImage = true;
        const video = document.createElement("video"),
        source = document.createElement("source");
        video.appendChild(source);
        source.type = `video/${type}`;

        video.oncanplay = () => {
            //video 的 width, height 属性如果不设的话永远都是0
            video.width = video.videoWidth;
            video.height = video.videoHeight;
            this._loadSuccess(video, onload);
        };

        source.src = src;
        return this;
    }

    _loadSuccess(image, onload){
        this.setImage(image);
        
        this.#loadingImage = false;
        if(Array.isArray(this.__setImageList)){
            this.__setImageList.forEach(ci => ci.setImage(image));
            delete this.__setImageList;
        }

        if(typeof onload === "function") onload(this);
        else if(CanvasImageRender.prototype.isPrototypeOf(onload)){
            if(onload.domElement.parentElement !== null) onload.redraw();
            else onload.render();
        }
    }

}




/* CanvasImages

*/
class CanvasImages extends CanvasImage{

    #i = -1;
    get cursor(){return this.#i;}
    set cursor(i){
        super.setImage(this.images[i]);
        this.#i = this.image !== null ? i : -1;
    }

    constructor(images = []){
        super(images[0]);
        this.images = images;
        if(this.image !== null) this.#i = 0;
    }

    setImage(image){
        super.setImage(image);
    
        if(this.image !== null && Array.isArray(this.images)){
            const i = this.images.indexOf(this.image);
            if(i === -1){
                this.#i = this.images.length;
                this.images.push(this.image);
            }
            else this.#i = i;
        }

        return this;
    }

    next(){
        const len = this.images.length - 1;
        if(len !== -1){
            if(this.#i < len) this.#i++;
            else this.#i = 0;
            super.setImage(this.images[this.#i]);
        }
    }

    loadImages(srcs, onDone, onUpdate){
        onUpdate = typeof onUpdate === "function" ? onUpdate : null;
        var i = 0, c = srcs.length, img = null, _i = this.images.length;

        const len = srcs.length, 
        func = ()=>{
            i++; if(onUpdate !== null) onUpdate(this.images, _i);
            if(i === c && typeof onDone === "function"){
                this.cursor = 0;
                onDone(this.images, _i, srcs);
            }
            else _i++;
        }

        for(let k = 0, ty = ""; k < len; k++){
            ty = typeof srcs[k];
            if(ty === "string" || ty === "object"){
                ty = ty === "string" ? srcs[k] : srcs[k].src;
                if(ty !== "" && typeof ty === "string"){
                    img = new Image();
                    img.onload = func;
                    this.images.push(img);
                    img.src = ty;
                }
                else c--;
            }
        }

        return this;
    }

}




/* CanvasImageCustom

demo:
    //CanvasImageRender
    const cir = new CanvasImageRender({width: WORLD.width, height: WORLD.height});
    cir.domElement.style = `
        position: absolute;
        z-index: 9999;
        background: rgb(127,127,127);
    `;

    //values
    cir.add(new CanvasImageCustom())
    .pos(59, 180)
    .load("view/examples/img/test.png", cir);

    cir.add(new CanvasImageCustom())
    .pos(59, 180)
    .text("value", "red")
    .rect().stroke()

*/
class CanvasImageCustom extends CanvasImage{

    //#path2D = new Path2D();

    constructor(canvas, autoSize = true){
        super(canvas);
        this.autoSize = autoSize;
        this.fontSize = parseFloat(CanvasImageRender.defaultStyles.font);
        this.fillStyle = CanvasImageRender.defaultStyles.fillStyle;
        this.strokeStyle = CanvasImageRender.defaultStyles.strokeStyle;
        this.shadowColor = CanvasImageRender.defaultStyles.shadowColor;
    }

    setFontSize(fontSize = this.fontSize){
        if(UTILS.isNumber(fontSize) && fontSize > 1 && this.fontSize !== fontSize){
            this.fontSize = fontSize;
            this.context.font = fontSize+"px SimSun, Songti SC";
        }
        return this.fontSize;
    }

    toImage(callback){
        var image = new Image();
        image.src = this.image.toDataURL("image/png");
        image.onload = callback;
    }

    shear(canvas, dx = 0, dy = 0){
        if(CanvasImageRender.isCanvas(canvas) === false){
            canvas = document.createElement("canvas");
            canvas.width = this.width;
            canvas.height = this.height;
        }

        canvas.getContext("2d").drawImage(this.image, dx, dy); 

        return canvas;
    }

    setImage(image){
        if(CanvasImageRender.isCanvas(image)){ //image 如果是画布
            super.setImage(image);
            this.context = CanvasImageRender.getContext(image);
            this.size(image.width, image.height);
        }
        else{
            if(CanvasImageRender.isCanvasImage(image)){ //image 如果是图像
                this.context = CanvasImageRender.getContext();
                super.setImage(this.context.canvas);
                this.size(image.width, image.height);
                this.context.drawImage(image, 0, 0);
            }else{ //image 如果是其它对象
                if(image) super.setImage(image);
                else{
                    this.context = CanvasImageRender.getContext();
                    super.setImage(this.context.canvas);
                    this.size(this.width, this.height);
                }
            }
        }
        
        return this;
    }

    clear(){
        this.context.clearRect(0, 0, this.box.w, this.box.h);
        return this;
    }

    size(w, h){
        this.box.size(w, h);
        this.image.width = w;
        this.image.height = h;
        CanvasImageRender.setDefaultStyles(this.context);
        
        if(this.context.font !== parseFloat(this.fontSize)) this.context.font = this.fontSize+"px SimSun, Songti SC";//
        if(this.context.fillStyle !== this.fillStyle) this.context.fillStyle = this.fillStyle; //
        if(this.context.strokeStyle !== this.strokeStyle) this.context.strokeStyle = this.strokeStyle; //
        if(this.context.shadowColor !== this.shadowColor) this.context.shadowColor = this.shadowColor; //

        return this;
    }

    shadow(shadowColor = "rgba(0,0,0,0)", shadowBlur, shadowOffsetX, shadowOffsetY){
        const con = this.context;
        if(typeof shadowColor === "string" && this.shadowColor !== shadowColor) this.shadowColor = con.shadowColor = shadowColor;
        if(con.shadowBlur !== shadowBlur && typeof shadowBlur === "number") con.shadowBlur = shadowBlur;
        if(con.shadowOffsetX !== shadowOffsetX && typeof shadowOffsetX === "number") con.shadowOffsetX = shadowOffsetX;
        if(con.shadowOffsetY !== shadowOffsetY && typeof shadowOffsetY === "number") con.shadowOffsetY = shadowOffsetY;
        return this;
    }

    line(x, y, x1, y1){
        this.context.beginPath();
        this.context.moveTo(x, y);
        this.context.lineTo(x1, y1);
        return this;
    }

    path(arr, close = false){
        const con = this.context;
        con.beginPath();
        con.moveTo(arr[0], arr[1]);
        for(let k = 2, len = arr.length; k < len; k+=2) con.lineTo(arr[k], arr[k+1]);
        if(close === true) con.closePath();
        return this;
    }

    rect(r, box, lineWidth){
        if(UTILS.isNumber(lineWidth) && this.context.lineWidth !== lineWidth) this.context.lineWidth = lineWidth;

        const con = this.context, s = con.lineWidth;

        if(Box.prototype.isPrototypeOf(box)){
            var x = box.x,
            y = box.y,
            w = box.w,
            h = box.h;
            
        }else{
            var x = s/2,
            y = s/2,
            w = this.box.w - s,
            h = this.box.h - s;
        }

        if(UTILS.isNumber(r) === false || r <= 0){
            con.rect(x, y, w, h);
            return this;
        }

        const _x = x + r, 
        _y = y + r, 
        mx = x + w, 
        my = y + h, 
        _mx = mx - r, 
        _my = my - r;
        
        con.beginPath();

        //上
        con.moveTo(_x, y);
        con.lineTo(_mx, y);
        con.arcTo(mx, y, mx, _y, r);

        //右
        con.lineTo(mx, _y);
        con.lineTo(mx, _my);
        con.arcTo(mx, my, _x, my, r);

        //下
        con.lineTo(_x, my);
        con.lineTo(_mx, my);
        con.arcTo(x, my, x, _my, r);

        //左
        con.lineTo(x, _y);
        con.lineTo(x, _my);
        con.arcTo(x, y, _x, y, r);

        return this;
    }

    stroke(color = this.fillStyle){
        if(color !== "" && this.strokeStyle !== color) this.strokeStyle = this.context.strokeStyle = color;
        this.context.stroke();
        return this;
    }

    fill(color = this.fillStyle){
        if(color !== "" && this.fillStyle !== color) this.fillStyle = this.context.fillStyle = color;
        this.context.fill();
        return this;
    }

    text(value, color = this.fillStyle, fontSize, x = -1, y = -1){
        fontSize = this.setFontSize(fontSize);
        const textWidth = this.context.measureText(value).width;
        if(this.autoSize === true && textWidth > this.box.w || this.fontSize > this.box.h){
            this.size(textWidth+4, this.fontSize+4);
            this.setFontSize(fontSize);
        }

        if(x === -1) x = (this.box.w - textWidth) / 2;
        if(y === -1) y = (this.box.h - this.fontSize) / 2;

        if(color !== "" && this.fillStyle !== color) this.fillStyle = this.context.fillStyle = color;
        this.context.fillText(value, x, y);

        return this;
    }

    linearGradient(sx, sy, dx, dy){
        return this.context.createLinearGradient(sx || 0, sy || 0, dx || this.box.w, dy || 0);
    }

    gradientColors(gradient, colors, close = false){
        if(UTILS.emptyArray(colors)) return gradient;
        const len = colors.length;
        if(close === false){
            for(let k = 0, _len = len - 1; k < len; k++) gradient.addColorStop(k / _len, colors[k]);
        }else{
            for(let k = 0; k < len; k++) gradient.addColorStop(k / len, colors[k]);
            gradient.addColorStop(1, colors[0]);
        }
        return gradient;
    }

    drawTransparentBG(r, box, size = 5){
        if(Box.prototype.isPrototypeOf(box)){
            var x = box.x,
            y = box.y,
            w = box.w,
            h = box.h;
        }else{
            var x = 0,
            y = 0,
            w = this.box.w,
            h = this.box.h;
        }

        const con = this.context, 
        c1 = "rgb(255,255,255)", c2 = "rgb(127,127,127)", 
        lenX = Math.ceil(w/size), lenY = Math.ceil(h/size);
        
        con.save();
        this.rect(r, box);
        con.clip();

        for(let ix = 0, iy = 0; ix < lenX; ix++){

            for(iy = 0; iy < lenY; iy++){

                con.fillStyle = (ix + iy) % 2 === 0 ? c1 : c2;
                con.fillRect(ix * size + x, iy * size + y, size, size);
                
            }

        }

        con.restore();
        return this;
    }

}





/* CanvasIconMenu 图标菜单

备注: 
    每个 CanvasIconMenu 会创建3个CanvasImage对象, 
    
parameter:
    icon: Image, 
    text,
    option: Object{
        padding //border 以内的间隔
        margin //border 以外的间隔
        iconSize
        backgroundColor //border 以内的背景颜色(最底层的)
        
        //text
        textSize
        textColor

        //边框
        borderSize
        borderColor
        borderRadius
    }

attributes:
    background: CanvasImage;    //它同时容纳了 backgroundColor, icon, text

    //下面这两个需要你自己创建或更新, 它们的位置.pos()方法会自动更新, 其宽高也以定义(图片的宽高)
    icons: CanvasImages;    //右边可更换的图标 宽高为 option.iconSize, option.iconSize
        
    masks: CanvasImages;     //遮罩层(最顶层) 宽高为 this.contentWidth, this.contentHeight;

method:
    pos(x, y)
    addToList(arr)
    removeToList(arr)
*/
class CanvasIconMenu{

    static padding = 2;
    static margin = 2;
    static iconSize = 20;

    static backgroundColor = "#ffffff";
    static textSize = 12;
    static textColor = "#002e23";
    
    static borderSize = 0;
    static borderColor = "rgb(0,173,230)";
    static borderRadius = 4;

    static emptyCIC = new CanvasImageCustom(null, false);

    #iconsOffsetX = 0;
    #iconsOffsetY = 0;

    #icons = null;
    #masks = null;
    #background = null;
    #masksOffset = 0;
    #contentWidth = 0;
    #contentHeight = 0;
    #contentOffset = 0;
    get icons(){return this.#icons;}
    get masks(){return this.#masks;}
    get background(){return this.#background;}
    get masksOffset(){return this.#masksOffset;}
    get contentWidth(){return this.#contentWidth;}
    get contentHeight(){return this.#contentHeight;}
    get contentOffset(){return this.#contentOffset;}

    constructor(icon, text, option = {}){
        if(typeof text !== "string" || text === "") text = "empty";

        const emptyCIC = CanvasIconMenu.emptyCIC,
        
        padding = option.padding || CanvasIconMenu.padding,
        margin = option.margin || CanvasIconMenu.margin,
        iconSize = option.iconSize || CanvasIconMenu.iconSize,
        backgroundColor = option.backgroundColor || CanvasIconMenu.backgroundColor,
        
        textSize = option.textSize || CanvasIconMenu.textSize,
        textColor = option.textColor || CanvasIconMenu.textColor,

        borderSize = option.borderSize || CanvasIconMenu.borderSize,
        borderColor = option.borderColor || CanvasIconMenu.borderColor,
        borderRadius = option.borderRadius || CanvasIconMenu.borderRadius;
        
        emptyCIC.setFontSize(textSize);
        const textWidth = emptyCIC.context.measureText(text).width, 
        contentWidth = padding * 4 + borderSize * 2 + iconSize * 2 + textWidth, 
        contentHeight = padding * 2 + borderSize * 2 + iconSize,
        contentOffset = borderSize + padding;

        //background
        emptyCIC.size(contentWidth, contentHeight).rect(borderRadius, null, borderSize).fill(backgroundColor);
        if(CanvasImageRender.isCanvasImage(icon)){
            const size = UTILS.setSizeToSameScale(icon, {width: iconSize, height: iconSize});
            emptyCIC.context.drawImage(icon, contentOffset, contentOffset, size.width, size.height);
        }
        emptyCIC.text(text, textColor, textSize);
        if(borderSize > 0) emptyCIC.stroke(borderColor);
        const backgroundImage = emptyCIC.shear();
        
        //icons
        this.#icons = new CanvasImages();
        this.#icons.box.size(iconSize, iconSize);

        //masks
        this.#masks = new CanvasImages();
        this.#masks.box.size(contentWidth, contentHeight);
        
        //margin
        if(UTILS.isNumber(margin) && margin > 0 && margin !== Infinity){
            const margin2 = margin * 2;
            emptyCIC.size(contentWidth + margin2, contentHeight + margin2);
            emptyCIC.context.drawImage(backgroundImage, margin, margin);
            this.#background = new CanvasImage(emptyCIC.shear());
            this.#masksOffset = margin;
        }else{
            this.#background = new CanvasImage(backgroundImage);
            this.#masksOffset = 0;
        }

        this.#iconsOffsetX = emptyCIC.box.w - this.#masksOffset - contentOffset - iconSize;
        this.#iconsOffsetY = this.#masksOffset + contentOffset;
        this.#contentWidth = contentWidth;
        this.#contentHeight = contentHeight;
        this.#contentOffset = contentOffset;
    }

    pos(x, y){
        this.#background.pos(x, y);
        this.#icons.pos(x + this.#iconsOffsetX, y + this.#iconsOffsetY);
        this.#masks.pos(x + this.#masksOffset, y + this.#masksOffset);
    }

    addToList(arr){
        arr.push(this.#background, this.#icons, this.#masks);
        return this;
    }

    removeToList(arr){
        const i = arr.indexOf(this.#background);
        if(i !== -1) arr.splice(i, 3);
    }

}




/* CanvasTreeList extends TreeStruct
parameter:
    object: Object,
    info: Object{
        name_attributesName: String, //object[name_attributesName] 
        iamges_attributesName: String,
        iamges: Object{
            object[iamges_attributesName]: Image
        },
    },
    option: Object, //参见 CanvasIconMenu 的 option

attribute:
    objectView: CanvasIconMenu;        //object 展示视图(文字)
    childIcon: CanvasImages;        //子视图隐藏开关(三角形图标)
    childView: CanvasImageCustom;    //子视图 (线)

    //此属性内部自动更新, 表示自己子视图的高 
    //为什么不直接用 childView.box.h 代替? 
    //因为如果cir存在scroll则box的属性将会变成一个"状态机", 
    //所以就是为了不让它高频率的更新box的属性
    childViewHeight: Number;
    
    //只读: 
    object: Object;            //
    visible: Bool;            //自己是否已经显示
    root: CanvasTreeList;    //向上遍历查找自己的root
    rect: Box;                //new一个新的box并根据自己和所有子更新此box的值

method:
    bindEvent(cir: CanvasImageRender, cie: CanvasImageEvent, onclick: Func): this; //给 .childIcon 创建默认点击事件, onclick 是 .objectView 的点击回调
    unbindEvent(): undefined;                 //

    addToList(arr: Array);                    //添加到数组, arr一般是 CanvasImageRender.list 渲染队列
    removeToList(arr: Array);                //
    
    visibleChild(root): undefined;             //显示 (如果自己为隐藏状态则会想查找已显示的ctl,并从ctl展开至自己为止)
    hiddenChild(root): undefined;            //隐藏 (此方法忽略root,既root永远都是展开状态)

    getByObject(object): CanvasTreeList;    //查找 如果不存在返回 undefined;
    setName(name: String, arr: Array);        //更改 .objectView 的文字
    pos(x, y: Number): this;                //此方法是专门为 root 设的; 如果你让不是root的root调用root的方法的话 也行

demo:
    const info = {
        name_attributesName: "CTL_name",
        iamges_attributesName: "className",
        images: {
            CanvasImage: CanvasIconMenu.emptyCIC.size(20, 20).rect().fill("blue").shear(),
            CanvasImages: CanvasIconMenu.emptyCIC.size(20, 20).rect().stroke("blue").shear(),
        },
    }

    const cir = new CanvasImageRender({width: innerWidth, height: innerHeight});
    const cie = new CanvasImageEvent(cir);

    const onclick = function (event) {
        ctl_root.traverse(ctl => console.log(ctl.visible, ctl.childViewHeight))
    }

    const ctl_root = new CanvasTreeList(new CanvasImage(), info)
    .addToList(cir.list)
    .bindEvent(cir, cie, onclick);

    ctl_root.appendChild(new CanvasTreeList(new CanvasImages(), info))
    .addToList(cir.list)
    .bindEvent(cir, cie, onclick);

    ctl_root.pos(10, 10).visibleChild();
    cir.render();
*/
class CanvasTreeList extends TreeStruct {

    static info = null;
    
    static option = {
        padding: 2,
        margin: 2, 
        iconSize: 20,
        backgroundColor: "#ffffff",
        textSize: 12,
        textColor: "#002e23",
        borderSize: 0,
        borderColor: "#ffffff",
        borderRadius: 4,
    }

    static childLineStyle = {
        strokeStyle: "#cccccc",
        lineWidth: 2,
    }

    #info = null;
    #option = null;
    #object = null;
    get object(){
        return this.#object;
    }

    #visible = false;
    get visible(){
        return this.#visible;
    }

    get root(){
        var par = this;
        while(true){
            if(par.parent === null) break;
            par = par.parent;
        }
        return par;
    }

    get rect(){
        var maxX = this.objectView.background.box.mx, _x;
        this.traverse(ctl => {
            if(ctl.visible === true){
                _x = ctl.objectView.background.box.mx;
                maxX = Math.max(_x, maxX);
            }
        });
        
        const masksOffset = this.objectView.masksOffset, x = this.childIcon.box.x - masksOffset;

        return new Box(x, this.childIcon.box.y - masksOffset, maxX - x, this.childViewHeight + this.objectView.background.box.h);
    }

    constructor(object, info = CanvasTreeList.info, option = CanvasTreeList.option){
        if(UTILS.isObject(object) === false) return console.warn("[CanvasTreeList] 参数错误: ", object);
        if(UTILS.isObject(info) === false) info = CanvasTreeList.info;
        if(UTILS.isObject(option) === false) option = CanvasTreeList.option;
        super();
        this.#object = object;
        this.#info = info;
        this.#option = option;
    
        //this.objectView
        this.setName();

        //this.childIcon
        const size = this.objectView.contentHeight,
        emptyCIC = CanvasIconMenu.emptyCIC.size(size, size), 
        x = (size - option.textSize) / 2, s = x + option.textSize;
        this.childIcon = new CanvasImages([
            emptyCIC.rect(option.borderRadius, null, info.borderSize).fill(option.backgroundColor)
            .path([x, x, x, s, s, size/2], true).fill(option.textColor).shear(),
            emptyCIC.clear().rect(option.borderRadius).fill(option.backgroundColor)
            .path([x, x, s, x, size/2, s], true).fill(option.textColor).shear(),
        ]);
        
        //this.childView
        this.childView = new CanvasImageCustom();
        this.childView.scaleEnable = false; //禁用缩放
        this.childView.box.size(CanvasTreeList.childLineStyle.lineWidth || 1, 0);
        this.childView.path2D = new CanvasPath2D(true, "stroke", CanvasTreeList.childLineStyle);
        this.childView.path2D.line(new Line());
        this.childViewHeight = 0;
        
        //visible
        this.childIcon.cursor = 0;
        this.childIcon.visible = 
        this.objectView.background.visible = 
        this.objectView.icons.visible = 
        this.objectView.masks.visible = 
        this.childView.visible = false;
    }

    bindEvent(cir, cie, onclick, root){
        this.removeEventClick_childIcon = cie.bindEventClick(this.childIcon, () => {
            if(this.childIcon.cursor === 0) this.visibleChild(root); 
            else if(this.childIcon.cursor === 1) this.hiddenChild(root);
            cir.redraw();
        });
        
        if(typeof onclick === "function") this.removeEventClick_objectView = cie.bindEventClick(this.objectView.background, onclick);

        return this;
    }

    unbindEvent(){
        this.removeEventClick_childIcon();
        this.removeEventClick_objectView();
    }

    addToList(arr){
        arr.push(this.childIcon, this.objectView.background, this.objectView.icons, this.objectView.masks, this.childView);
        return this;
    }

    removeToList(arr){
        const i = arr.indexOf(this.childIcon);
        if(i !== -1) arr.splice(i, 5);
    }
    
    visibleChild(root = this.root){
        this.childIcon.cursor = 1;
        
        if(this.#visible){
            this._visibleChild();
            root.childViewHeight = 0;
            root._updateSizeChild();
            root._updatePositionChild();
            root.childView.box.h = root.childView.path2D.value.y1 = root.childViewHeight;
        }else{
            if(root === this) return console.warn("[CanvasTreeList] visibleChild: 展开失败, 请使用 root.pos() 方法初始化root");
            let _ctl = root;
            this.traverseUp(ctl => {
                if(ctl.visible){
                    _ctl = ctl;
                    return "break";
                }
                if(ctl.childIcon.cursor !== 1) ctl.childIcon.cursor = 1;
            });
            _ctl.visibleChild(root);
        }
    }

    hiddenChild(root = this.root){
        if(this.#visible){
            this.childIcon.cursor = 0;
            this._hiddenChild();
            root.childViewHeight = 0;
            root._updateSizeChild();
            root._updatePositionChild();
            root.childView.box.h = root.childView.path2D.value.y1 = root.childViewHeight;
        }
    }

    getByObject(object){
        var result;
        this.traverse(ctl => {
            if(result !== undefined) return "continue";
            if(ctl.object === object){
                result = ctl;
                return "continue";
            }
        });
        return result;
    }

    setName(name, arr){
        var objectView;

        if(UTILS.isObject(this.#info)){
            const objectType = this.#object[this.#info.iamges_attributesName];

            if(typeof name === "string" && name !== ""){
                this.#object[this.#info.name_attributesName] = name;
            }else if(typeof this.#object[this.#info.name_attributesName] === "string" && this.#object[this.#info.name_attributesName] !== ""){
                name = this.#object[this.#info.name_attributesName];
            }else{
                name = objectType;
            }

            objectView = new CanvasIconMenu(this.#info.images[objectType], name, this.#option);
        }

        else objectView = new CanvasIconMenu(null, "", this.#option);

        //补遮罩层样式
        const emptyCIC = CanvasIconMenu.emptyCIC
        .size(objectView.contentWidth, objectView.contentHeight)
        .rect(this.#option.borderRadius);
        objectView.masks.images.push(
            emptyCIC.fill("rgba(0,0,0,0.75)").shear(),
            emptyCIC.clear().fill("rgba(0,173,230,0.2)").shear()
        );
        objectView.masks.cursor = 1;

        //更改渲染队列
        if(CanvasIconMenu.prototype.isPrototypeOf(this.objectView)){
            if(Array.isArray(arr)){
                const i = arr.indexOf(this.objectView.background);
                if(i !== -1){
                    arr[i] = objectView.background;
                    arr[i+1] = objectView.icons;
                    arr[i+2] = objectView.masks;
                    objectView.background.index = i;
                    objectView.icons.index = i+1;
                    objectView.masks.index = i+2;
                    objectView.background.visible = this.objectView.background.visible;
                    objectView.icons.visible = this.objectView.icons.visible;
                    objectView.masks.visible = this.objectView.masks.visible;

                    this.objectView = objectView;
                }else console.warn("[CanvasTreeList] setName: 修改失败, 无法找到目标");
            }else console.warn("[CanvasTreeList] setName: 第二个参数为Array");
        }

        else this.objectView = objectView;
    }

    pos(x, y){
        if(this.#visible === false){
            this.childIcon.cursor = 1;
            this.childIcon.visible = 
            this.childView.visible = true;

            this.#visible = 
            this.objectView.background.visible = 
            this.objectView.icons.visible = true;
        }
    
        const masksOffset = this.objectView.masksOffset;
        this.childIcon.pos(masksOffset+x, masksOffset+y); 
        this.objectView.pos(this.childIcon.box.mx, this.childIcon.box.y - masksOffset);
        this.childView.box.pos(this.childIcon.box.x + this.childIcon.box.w / 2, this.objectView.background.box.my);
        return this;
    }


    //以下属性限内部使用
    _visible(){
        if(this.#visible === false){
            this.childIcon.visible = 
            this.childView.visible = this.children.length === 0 ? false : true;

            this.#visible = 
            this.objectView.background.visible = 
            this.objectView.icons.visible = true;
        }
    }

    _visibleChild(){
        for(let k = 0, len = this.children.length, child; k < len; k++){
            child = this.children[k];
            child._visible();
            if(child.childIcon.cursor === 1) child._visibleChild();
        }
    }

    _hidden(){
        if(this.#visible === true){
            this.#visible = 
            this.childIcon.visible = 
            this.objectView.background.visible = 
            this.objectView.icons.visible = 
            this.childView.visible = false;
        }
    }

    _hiddenChild(){
        for(let k = 0, len = this.children.length, child; k < len; k++){
            child = this.children[k];
            child._hidden();
            child._hiddenChild();
        }
    }

    _updateSize(){
        const itemHeight = this.objectView.background.box.h;
        var par = this.parent;
        while(par !== null){
            par.childViewHeight += itemHeight;
            par.childView.path2D.value.y1 = par.childViewHeight;
            par = par.parent;
        }
    }

    _updateSizeChild(){
        for(let k = 0, len = this.children.length, child; k < len; k++){
            child = this.children[k];
            child.childView.path2D.value.y1 = child.childViewHeight = 0;
            if(child.visible){
                child._updateSize();
                child._updateSizeChild();
            }
        }
    }

    _updatePosition(outCTL){
        const masksOffset = this.parent.objectView.masksOffset,  
        mx_parent = this.parent.childIcon.box.mx,
        my_outCTL = outCTL !== undefined ? outCTL.childView.box.y+outCTL.childViewHeight : this.parent.objectView.background.box.my;
        
        //childIcon
        this.childIcon.pos(
            mx_parent + masksOffset, 
            my_outCTL + masksOffset
        );
        
        //objectView
        this.objectView.pos(
            this.childIcon.visible === true ? this.childIcon.box.mx : mx_parent, 
            my_outCTL
        );
        
        //childView
        this.childView.box.pos(mx_parent + this.childIcon.box.w / 2, this.objectView.background.box.my);
        this.childView.box.h = this.childViewHeight;
    }

    _updatePositionChild(){
        for(let k = 0, len = this.children.length, outChild, child; k < len; k++){
            child = this.children[k];
            if(child.visible){
                child._updatePosition(outChild);
                child._updatePositionChild();
                outChild = child;
            }
        }
    }

}




/* CanvasColorTestViewer 颜色调试器
parameter:
    w, 默认 250 
    h, 默认 w*0.618 
    r, 默认 0

attribute:
    hsv: Object{h,s,v};
    alpha: Number;
    只读: value: RGBColor, width, height, x, y: Number;

method:
    visible(v: Bool): undefined;//显示或隐藏所以的ci
    pos(x, y): undefined;         //如果你不希望排版错乱的话用此方法设置它们的位置位置
    update(): undefined;         //当颜色发送改变时更新: ctv.set("red").update()
    set(r, g, b, a): this;         //第一个参数r可以时字符串样式的颜色(rgb|rgba|十进制|英文)

    addToList(arr): undefined;     //把创建的 CanvasImage push到arr数组 (arr数组一般为某个 CanvasImageRender.list)
    removeToList(arr): undefined;

    bindEvent(cir: CanvasImageRender, cie: CanvasImageEvent, onchange: Func): this;    //
    unbindEvent();

demo:
    const ctv = new CanvasColorTestViewer(),
    cir = new CanvasImageRender({width: ctv.box.w - 5, height: ctv.box.h - 5}),
    cie = new CanvasImageEvent(cir); //启用dom事件
    
    ctv.set("blue").update();
    ctv.addToList(cir.list);
    ctv.bindEvent(cir, cie);
    cir.render();
*/
class CanvasColorTestViewer{

    static emptyColor = new RGBColor();
    static bgColor = "rgb(127,127,127)";
    static textColor = "#fff";
    static padding = 4;

    #value = new RGBColor();
    get value(){
        return this.#value;
    }

    #box = null;
    get box(){
        return this.#box;
    }

    #alpha = 1;
    get alpha(){
        return this.#alpha;
    }

    set alpha(v){
        this.#alpha = UTILS.floatKeep(v);
    }

    constructor(w, h, r = 4){
        const emptyCIC = CanvasIconMenu.emptyCIC;

        if(UTILS.isNumber(w) === false || w < 1 || w === Infinity) w = 250;
        if(UTILS.isNumber(h) === false || h < 1 || h === Infinity) h = Math.max(emptyCIC.fontSize+this.constructor.padding*2, Math.round(0.618*w));

        this.hsv = {h:0, s:100, v:100};

        const colors = [], lw = w * 0.3, rw = w - lw, sh = 10,
        cursorImage = emptyCIC.size(10, 10).rect(5).fill("#fff").shear();


        //h
        this.ciH = new CanvasImageCustom().size(w, h).rect(r);

        colors.length = 0;
        for(let h = 0, c = this.constructor.emptyColor; h < 6; h++){
            c.setFormHSV(h/6*360, 100, 100);
            colors[h] = `rgb(${c.r},${c.g},${c.b})`;
        }
        emptyCIC.size(rw-10, sh).rect(2).fill(emptyCIC.gradientColors(emptyCIC.linearGradient(0, sh, rw-10, sh), colors, true));
        this.ciH_scroll = new CanvasImage(emptyCIC.shear());

        this.cursorH = new CanvasImage(cursorImage);


        //sv 饱和度&明度
        emptyCIC.size(w, h).rect(r);
        colors.length = 0;
        for(let s = 0; s < 100; s++) colors[s] = `rgba(255,255,255,${1 - s / 99})`;
        emptyCIC.fill(emptyCIC.gradientColors(emptyCIC.linearGradient(0, h, w, h), colors));
        
        colors.length = 0;
        for(let v = 0; v < 100; v++) colors[v] = `rgba(0,0,0,${1 - v / 99})`;
        emptyCIC.fill(emptyCIC.gradientColors(emptyCIC.linearGradient(w, h, w, 0), colors));

        this.ciSV = new CanvasImage(emptyCIC.shear());

        this.cursorSV = new CanvasImage(emptyCIC.size(10, 10).rect(5).fill("rgba(255,255,255,0.4)").stroke("rgba(0,0,0,0.6)").shear());


        //a
        this.ciA = new CanvasImage(emptyCIC.size(rw-10, sh).drawTransparentBG(2, null, sh/2).shear());

        colors.length = 0;
        for(let a = 0; a < 10; a++) colors[a] = `rgba(0,0,0,${a / 9})`;
        emptyCIC.size(this.ciA.box.w, sh).rect(2).fill(emptyCIC.gradientColors(emptyCIC.linearGradient(0, sh, this.ciA.box.w, sh), colors));
        this.ciA_scroll = new CanvasImage(emptyCIC.shear());

        this.cursorA = new CanvasImage(cursorImage);

        //bottom bg
        this.bottomBG = new CanvasImage(emptyCIC.size(w, lw).rect(r).fill(this.constructor.bgColor).shear());

        //result
        this.resultBG = new CanvasImage(emptyCIC.size(lw-10, lw-10).drawTransparentBG(2, null, 5).shear());
        this.resultColor = new CanvasImageCustom().size(this.resultBG.box.w, this.resultBG.box.h).rect(2);
        this.resultText = new CanvasImageCustom().size(this.ciA.box.w, this.resultColor.box.h - this.ciH_scroll.box.h - this.ciA_scroll.box.h - 15);
        
        const _box = new Box(), scope = this, _s = this.cursorSV.box.w / 2;
        this.#box = _box;
        Object.defineProperties(_box, {
            x: {get: () => {return scope.ciH.box.x - _s;}},
            y: {get: () => {return scope.ciH.box.y - _s;}},
            w: {get: () => {return scope.ciH.box.w + _s;}},
            h: {get: () => {return scope.ciH.box.h + scope.bottomBG.box.h + _s;}},
        });

        this.updateCIH();
        this.updateResult();
        this.pos(0, 0);
    }

    bindEvent(cir, cie, onchange = null){
        var sx = 0, sy = 0, v;
        const cursorSV_half = this.cursorSV.box.w / 2,


        //SV
        setSV = (x, y) => {
            if(x < this.#box.x) x = this.#box.x;
            else{
                v = this.ciSV.box.mx - cursorSV_half;
                if(x > v) x = v;
            }

            if(y < this.#box.y) y = this.#box.y;
            else{
                v = this.ciSV.box.my - cursorSV_half;
                if(y > v) y = v;
            }

            this.cursorSV.box.pos(x, y);
            
            x += cursorSV_half;
            y += cursorSV_half;
            this.hsv.s = (x - this.ciSV.box.x) / this.ciSV.box.w * 100;
            this.hsv.v = (1 - (y - this.ciSV.box.y) / this.ciSV.box.h) * 100;
            this.updateResult();

            if(onchange !== null) onchange(this);
            cir.redrawTarget(this.#box);
        },

        onmoveSV = event => {
            setSV(event.offsetX - sx, event.offsetY - sy);
        },

        onupSV = event => {
            document.body.removeEventListener('pointermove', onmoveSV);
            document.body.removeEventListener('pointerup', onupSV);
            setSV(event.offsetX - sx, event.offsetY - sy);
        },

        ondownSV = event => {
            sx = event.offsetX - this.cursorSV.box.x;
            sy = event.offsetY - this.cursorSV.box.y;
            onupSV(event);
            document.body.addEventListener("pointermove", onmoveSV);
            document.body.addEventListener("pointerup", onupSV);
        },


        //H
        setH = x => {
            v = this.ciH_scroll.box.x - cursorSV_half;
            if(x < v) x = v;
            else{
                v = this.ciH_scroll.box.mx - cursorSV_half;
                if(x > v) x = v;
            }

            this.cursorH.box.x = x;
            
            x += cursorSV_half;
            this.hsv.h = (x - this.ciH_scroll.box.x) / this.ciH_scroll.box.w * 360;
            this.updateCIH();
            this.updateResult();

            if(onchange !== null) onchange(this);
            cir.redrawTarget(this.#box);
        },

        onmoveH = event => {
            setH(event.offsetX - sx);
        },

        onupH = event => {
            document.body.removeEventListener('pointermove', onmoveH);
            document.body.removeEventListener('pointerup', onupH);
            setH(event.offsetX - sx);
        },

        ondownH = event => {
            sx = event.offsetX - this.cursorH.box.x;
            sy = event.offsetY - this.cursorH.box.y;
            onupH(event);
            document.body.addEventListener("pointermove", onmoveH);
            document.body.addEventListener("pointerup", onupH);
        },


        //A
        setA = x => {
            v = this.ciA_scroll.box.x - cursorSV_half;
            if(x < v) x = v;
            else{
                v = this.ciA_scroll.box.mx - cursorSV_half;
                if(x > v) x = v;
            }

            this.cursorA.box.x = x;
            
            x += cursorSV_half;
            this.alpha = (x - this.ciA_scroll.box.x) / this.ciA_scroll.box.w * 1;
            this.updateResult();

            if(onchange !== null) onchange(this);
            cir.redrawTarget(this.#box);
        },

        onmoveA = event => {
            setA(event.offsetX - sx);
        },

        onupA = event => {
            document.body.removeEventListener('pointermove', onmoveA);
            document.body.removeEventListener('pointerup', onupA);
            setA(event.offsetX - sx);
        },

        ondownA = event => {
            sx = event.offsetX - this.cursorA.box.x;
            sy = event.offsetY - this.cursorA.box.y;
            onupA(event);
            document.body.addEventListener("pointermove", onmoveA);
            document.body.addEventListener("pointerup", onupA);
        }


        cie.add(this.cursorSV, "down", ondownSV);
        cie.add(this.ciSV, "down", ondownSV);

        cie.add(this.cursorH, "down", ondownH);
        cie.add(this.ciH_scroll, "down", ondownH);

        cie.add(this.cursorA, "down", ondownA);
        cie.add(this.ciA_scroll, "down", ondownA);

        return this;
    }

    unbindEvent(){

    }

    addToList(arr){
        arr.push(this.ciH, this.ciSV, this.cursorSV, this.bottomBG, this.resultBG, this.resultColor, this.resultText, this.ciH_scroll, this.cursorH, this.ciA, this.ciA_scroll, this.cursorA);
    }

    removeToList(arr){
        const i = arr.indexOf(this.ciH);
        if(i !== -1) arr.splice(i, 12);
    }

    pos(x, y){
        this.ciH.box.pos(x, y);
        this.ciSV.box.pos(x, y);
        this.updateCursorSV();

        this.bottomBG.pos(this.ciH.x, this.ciH.box.my);
        this.resultBG.pos(this.bottomBG.x+5, this.bottomBG.y+5);
        this.resultColor.pos(this.resultBG.x, this.resultBG.y);

        this.ciH_scroll.pos(this.resultBG.box.mx + 5, this.resultBG.y + 5);
        this.updateCursorH();

        this.ciA.pos(this.ciH_scroll.x, this.ciH_scroll.box.my + 5);
        this.ciA_scroll.pos(this.ciA.x, this.ciA.y);
        this.updateCursorA();

        this.resultText.pos(this.ciA_scroll.x, this.ciA_scroll.box.my + 5);
    }

    visible(v){
        this.ciH.visible = this.ciSV.visible = this.cursorSV.visible = 
        this.bottomBG.visible = this.resultBG.visible = this.resultColor.visible = 
        this.resultText.visible = this.ciH_scroll.visible = this.cursorH.visible = 
        this.ciA.visible = this.ciA_scroll.visible = this.cursorA.visible = v;
    }

    set(r, g, b, a){
        if(typeof r !== "string"){
            this.constructor.emptyColor.set(r, g, b).getHSV(this.hsv);
            this.alpha = a || 1;
        }
        else{
            this.alpha = this.constructor.emptyColor.setFormString(r);
            this.constructor.emptyColor.getHSV(this.hsv);
        }
        return this;
    }

    update(){
        this.updateCIH();
        this.updateResult();

        this.updateCursorSV();
        this.updateCursorH();
        this.updateCursorA();
    }

    updateCursorSV(){
        this.cursorSV.box.x = this.hsv.s / 100 * this.ciSV.box.w + this.ciSV.box.x - this.cursorSV.box.w / 2;
        this.cursorSV.box.y = (1 - this.hsv.v / 100) * this.ciSV.box.h + this.ciSV.box.y - this.cursorSV.box.h / 2;
    }

    updateCursorH(){
        this.cursorH.box.x = this.hsv.h / 360 * this.ciH_scroll.box.w + this.ciH_scroll.box.x - this.cursorH.box.w / 2;
        this.cursorH.box.y = this.ciH_scroll.box.y;
    }

    updateCursorA(){
        this.cursorA.box.x = this.alpha * this.ciA_scroll.box.w + this.ciA_scroll.box.x - this.cursorA.box.w / 2;
        this.cursorA.box.y = this.ciA_scroll.box.y;
    }

    updateCIH(){
        const c = this.constructor.emptyColor.setFormHSV(this.hsv.h, 100, 100);
        this.ciH.fill(`rgb(${c.r},${c.g},${c.b})`);
    }

    updateResult(){
        this.#value.setFormHSV(this.hsv.h, this.hsv.s, this.hsv.v);
        this.resultColor.clear().fill(this.#value.getRGBA(this.alpha));
        this.resultText.clear().text(this.resultColor.fillStyle, this.constructor.textColor);
    }

}




class CanvasTreeOptionMenu{

}




class CanvasUIList{

}




export {
    CanvasImageEvent,
    CanvasImageScroll,
    CanvasImageRender,
    CanvasImage, 
    CanvasImages,
    CanvasImageCustom,
    CanvasIconMenu,
    CanvasTreeList,
    CanvasPath2D,
    CanvasColorTestViewer
}

 

main.js:

import { 
    CanvasImageEvent, 
    CanvasImageRender, 
    CanvasImage 
} from './lib/CanvasImageRender.js';

const cir = new CanvasImageRender({width: innerWidth, height: innerHeight}),
cie = new CanvasImageEvent(cir),

target = cir.add(new CanvasImage()).loadImage("./examples/img/test.jpg", cir);

cie.add(target, "wheel", event => {

    const scale = target.scaleX + event.wheelDelta * 0.001,

    //offsetX,offsetY 是鼠标到 element 的距离, 现在把它们转为 target 的距离
    localPositionX = event.offsetX - target.x,
    localPositionY = event.offsetY - target.y;

    //xy以相等的比例缩放
    target.setScaleX(scale, localPositionX);
    target.setScaleY(scale, localPositionY);

    cir.redraw();

});

console.log(cir, cie, target);

 

图: