molstar/lib/mol-util/color/scale.js

A comprehensive macromolecular library.

/**
 * Copyright (c) 2018-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
 *
 * @author Alexander Rose <alexander.rose@weirdbyte.de>
 */
import { __assign, __spreadArray } from "tslib";
import { Color } from './color';
import { getColorListFromName } from './lists';
import { defaults } from '../../mol-util';
import { ScaleLegend } from '../legend';
import { SortedArray } from '../../mol-data/int';
import { clamp } from '../../mol-math/interpolate';
export var DefaultColorScaleProps = {
    domain: [0, 1],
    reverse: false,
    listOrName: 'red-yellow-blue',
    minLabel: '',
    maxLabel: '',
};
export var ColorScale;
(function (ColorScale) {
    function create(props) {
        var _a = __assign(__assign({}, DefaultColorScaleProps), props), domain = _a.domain, reverse = _a.reverse, listOrName = _a.listOrName;
        var list = typeof listOrName === 'string' ? getColorListFromName(listOrName).list : listOrName;
        var colors = reverse ? list.slice().reverse() : list;
        var count1 = colors.length - 1;
        var diff = 0, min = 0, max = 0;
        function setDomain(_min, _max) {
            min = _min;
            max = _max;
            diff = (max - min) || 1;
        }
        setDomain(domain[0], domain[1]);
        var minLabel = defaults(props.minLabel, min.toString());
        var maxLabel = defaults(props.maxLabel, max.toString());
        var color;
        var hasOffsets = colors.every(function (c) { return Array.isArray(c); });
        if (hasOffsets) {
            var sorted = __spreadArray([], colors, true);
            sorted.sort(function (a, b) { return a[1] - b[1]; });
            var src_1 = sorted.map(function (c) { return c[0]; });
            var off_1 = SortedArray.ofSortedArray(sorted.map(function (c) { return c[1]; }));
            var max_1 = src_1.length - 1;
            color = function (v) {
                var t = clamp((v - min) / diff, 0, 1);
                var i = SortedArray.findPredecessorIndex(off_1, t);
                if (i === 0) {
                    return src_1[min];
                }
                else if (i > max_1) {
                    return src_1[max_1];
                }
                var o1 = off_1[i - 1], o2 = off_1[i];
                var t1 = clamp((t - o1) / (o2 - o1), 0, 1); // TODO: cache the deltas?
                return Color.interpolate(src_1[i - 1], src_1[i], t1);
            };
        }
        else {
            color = function (value) {
                var t = Math.min(colors.length - 1, Math.max(0, ((value - min) / diff) * count1));
                var tf = Math.floor(t);
                var c1 = colors[tf];
                var c2 = colors[Math.ceil(t)];
                return Color.interpolate(c1, c2, t - tf);
            };
        }
        return {
            color: color,
            colorToArray: function (value, array, offset) {
                Color.toArray(color(value), array, offset);
            },
            normalizedColorToArray: function (value, array, offset) {
                Color.toArrayNormalized(color(value), array, offset);
            },
            setDomain: setDomain,
            get legend() { return ScaleLegend(minLabel, maxLabel, colors); }
        };
    }
    ColorScale.create = create;
})(ColorScale || (ColorScale = {}));