/**
 *   海洋环境可视化工具类代码
 *
 *          金磊
 */
importScripts("pako_inflate.min.js");

function request(options) {
    var oReq = new XMLHttpRequest();
    oReq.open("GET", options.url, true);
    oReq.responseType = options.type;
    oReq.onload = function (result) {
        if (result) {
            var _data = null;
            if (oReq.responseType == "text" || oReq.responseType == "") {
                _data = result.target.responseText;
            } else {
                _data = result.target.response;
            }
            if (result.target.status == 200) {
                if (typeof options.success == "function")
                    options.success(_data);
            } else {
                if (typeof options.error == "function") options.error(_data);
            }
        }
    };
    oReq.send(null);
    oReq.onloadend = function () {
        oReq = null;
    };
}
function getCacheInfo(options, callback) {
    var id = options.id;
    var fullUrl = "";
    fullUrl =
        serviceUrl +
        "?ncpath=" +
        options.ncpath +
        "&type=" +
        options.variable +
        "&depth=" +
        options.depth;
    request({
        url: fullUrl,
        type: "text",
        success: function (data) {
            var json = JSON.parse(data);
            if (json.path) {
                var cachePath = cacheUrl + json.path;
                getData(
                    {
                        id: id,
                        url: cachePath,
                    },
                    callback
                );
            }
        },
        error: function () {},
    });
}
function getData(options, callback) {
    var id = options.id;
    request({
        url: options.url,
        type: "arraybuffer",
        success: function (arrayBuffer) {
            if (typeof callback == "function") {
                var binData = new Uint8Array(arrayBuffer);
                var data = pako.inflate(binData);
                var byteArray = new Float32Array(data.buffer);
                callback(id, byteArray);
            }
        },
        error: function () {},
    });
}
function colorInterpolator(start, end) {
    var r = start[0],
        g = start[1],
        b = start[2];
    var Δr = end[0] - r,
        Δg = end[1] - g,
        Δb = end[2] - b;
    return function (i, a) {
        return [
            Math.floor(r + i * Δr),
            Math.floor(g + i * Δg),
            Math.floor(b + i * Δb),
            a,
        ];
    };
}

/**
 * Creates a color scale composed of the specified segments. Segments is an array of two-element arrays of the
 * form [value, color], where value is the point along the scale and color is the [r, g, b] color at that point.
 * For example, the following creates a scale that smoothly transitions from red to green to blue along the
 * points 0.5, 1.0, and 3.5:
 *
 *     [ [ 0.5, [255, 0, 0] ],
 *       [ 1.0, [0, 255, 0] ],
 *       [ 3.5, [0, 0, 255] ] ]
 *
 * @param segments array of color segments
 * @returns {Function} a function(point, alpha) that returns the color [r, g, b, alpha] for the given point.
 */
function segmentedColorScale(segments) {
    var points = [],
        interpolators = [],
        ranges = [];
    for (var i = 0; i < segments.length - 1; i++) {
        points.push(segments[i + 1][0]);
        interpolators.push(
            colorInterpolator(segments[i][1], segments[i + 1][1])
        );
        ranges.push([segments[i][0], segments[i + 1][0]]);
    }

    return function (point, alpha) {
        var i;
        for (i = 0; i < points.length - 1; i++) {
            if (point <= points[i]) {
                break;
            }
        }
        var range = ranges[i];
        return interpolators[i](proportion(point, range[0], range[1]), alpha);
    };
}

/**
 * @returns {Number} the value x clamped to the range [low, high].
 */
function clamp(x, low, high) {
    return Math.max(low, Math.min(x, high));
}

/**
 * @returns {number} the fraction of the bounds [low, high] covered by the value x, after clamping x to the
 *          bounds. For example, given bounds=[10, 20], this method returns 1 for x>=20, 0.5 for x=15 and 0
 *          for x<=10.
 */
function proportion(x, low, high) {
    return (clamp(x, low, high) - low) / (high - low);
}
/**
 *
 *  双线性插值算法
 *
 */
function bilinearInterpolate(x, y, g00, g10, g01, g11) {
    var rx = 1 - x;
    var ry = 1 - y;
    var a = rx * ry,
        b = x * ry,
        c = rx * y,
        d = x * y;
    var u = g00 * a + g10 * b + g01 * c + g11 * d;
    return u;
}
function bilinearInterpolateVector(x, y, g00, g10, g01, g11) {
    var rx = 1 - x;
    var ry = 1 - y;
    var a = rx * ry,
        b = x * ry,
        c = rx * y,
        d = x * y;
    var u = g00[0] * a + g10[0] * b + g01[0] * c + g11[0] * d;
    var v = g00[1] * a + g10[1] * b + g01[1] * c + g11[1] * d;
    return [u, v, Math.sqrt(u * u + v * v)];
}