vitessce 3.6.0 → 3.6.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/{deflate-BQIf2hY7.js → deflate-JIgkfrJp.js} +1 -1
- package/dist/{higlass-Bat4GE21.js → higlass-DtQYm-cf.js} +1 -1
- package/dist/{index-n--TL9vD.js → index-CGb9JHk9.js} +1 -1
- package/dist/{index-DKsNZq_H.js → index-NeyzZ285.js} +68159 -68025
- package/dist/{index-CcMPJ7FR.js → index-axVzbAYY.js} +2753 -2695
- package/dist/index.min.js +4 -4
- package/dist/{jpeg-GIpYHoeg.js → jpeg-CpdHV9ON.js} +32 -32
- package/dist/lerc-CEsOhIb6.js +1032 -0
- package/dist/{lzw-BudhLb7h.js → lzw-CTsRA3aT.js} +1 -1
- package/dist/{packbits-CzOC0r_e.js → packbits-BvYiWUAv.js} +1 -1
- package/dist/{raw-xPYeRIN6.js → raw-dTBk71WO.js} +1 -1
- package/dist/{troika-three-text.esm-BOqKyvZt.js → troika-three-text.esm-C0dD1f80.js} +1 -1
- package/dist/{webimage-CGcky9Qo.js → webimage-Djrqr9Ff.js} +1 -1
- package/package.json +6 -6
- package/dist/lerc-DQBaC8Uo.js +0 -1004
package/dist/lerc-DQBaC8Uo.js
DELETED
|
@@ -1,1004 +0,0 @@
|
|
|
1
|
-
import { i as se } from "./pako.esm-D68R8YXe.js";
|
|
2
|
-
import { g as le, aQ as oe, aR as ue, aS as ie } from "./index-DKsNZq_H.js";
|
|
3
|
-
var K = { exports: {} }, ne;
|
|
4
|
-
function ve() {
|
|
5
|
-
return ne || (ne = 1, function($) {
|
|
6
|
-
/* Copyright 2015-2021 Esri. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 @preserve */
|
|
7
|
-
(function() {
|
|
8
|
-
var Y = function() {
|
|
9
|
-
var F = {};
|
|
10
|
-
F.defaultNoDataValue = -34027999387901484e22, F.decode = function(r, o) {
|
|
11
|
-
o = o || {};
|
|
12
|
-
var a = o.encodedMaskData || o.encodedMaskData === null, i = t(r, o.inputOffset || 0, a), m = o.noDataValue !== null ? o.noDataValue : F.defaultNoDataValue, n = A(
|
|
13
|
-
i,
|
|
14
|
-
o.pixelType || Float32Array,
|
|
15
|
-
o.encodedMaskData,
|
|
16
|
-
m,
|
|
17
|
-
o.returnMask
|
|
18
|
-
), f = {
|
|
19
|
-
width: i.width,
|
|
20
|
-
height: i.height,
|
|
21
|
-
pixelData: n.resultPixels,
|
|
22
|
-
minValue: n.minValue,
|
|
23
|
-
maxValue: i.pixels.maxValue,
|
|
24
|
-
noDataValue: m
|
|
25
|
-
};
|
|
26
|
-
return n.resultMask && (f.maskData = n.resultMask), o.returnEncodedMask && i.mask && (f.encodedMaskData = i.mask.bitset ? i.mask.bitset : null), o.returnFileInfo && (f.fileInfo = X(i), o.computeUsedBitDepths && (f.fileInfo.bitDepths = H(i))), f;
|
|
27
|
-
};
|
|
28
|
-
var A = function(r, o, a, i, m) {
|
|
29
|
-
var n = 0, f = r.pixels.numBlocksX, v = r.pixels.numBlocksY, u = Math.floor(r.width / f), h = Math.floor(r.height / v), g = 2 * r.maxZError, l = Number.MAX_VALUE, s;
|
|
30
|
-
a = a || (r.mask ? r.mask.bitset : null);
|
|
31
|
-
var w, k;
|
|
32
|
-
w = new o(r.width * r.height), m && a && (k = new Uint8Array(r.width * r.height));
|
|
33
|
-
for (var D = new Float32Array(u * h), p, y, x = 0; x <= v; x++) {
|
|
34
|
-
var L = x !== v ? h : r.height % v;
|
|
35
|
-
if (L !== 0)
|
|
36
|
-
for (var d = 0; d <= f; d++) {
|
|
37
|
-
var c = d !== f ? u : r.width % f;
|
|
38
|
-
if (c !== 0) {
|
|
39
|
-
var U = x * r.width * h + d * u, I = r.width - c, M = r.pixels.blocks[n], T, V, S;
|
|
40
|
-
M.encoding < 2 ? (M.encoding === 0 ? T = M.rawData : (e(M.stuffedData, M.bitsPerPixel, M.numValidPixels, M.offset, g, D, r.pixels.maxValue), T = D), V = 0) : M.encoding === 2 ? S = 0 : S = M.offset;
|
|
41
|
-
var B;
|
|
42
|
-
if (a)
|
|
43
|
-
for (y = 0; y < L; y++) {
|
|
44
|
-
for (U & 7 && (B = a[U >> 3], B <<= U & 7), p = 0; p < c; p++)
|
|
45
|
-
U & 7 || (B = a[U >> 3]), B & 128 ? (k && (k[U] = 1), s = M.encoding < 2 ? T[V++] : S, l = l > s ? s : l, w[U++] = s) : (k && (k[U] = 0), w[U++] = i), B <<= 1;
|
|
46
|
-
U += I;
|
|
47
|
-
}
|
|
48
|
-
else if (M.encoding < 2)
|
|
49
|
-
for (y = 0; y < L; y++) {
|
|
50
|
-
for (p = 0; p < c; p++)
|
|
51
|
-
s = T[V++], l = l > s ? s : l, w[U++] = s;
|
|
52
|
-
U += I;
|
|
53
|
-
}
|
|
54
|
-
else
|
|
55
|
-
for (l = l > S ? S : l, y = 0; y < L; y++) {
|
|
56
|
-
for (p = 0; p < c; p++)
|
|
57
|
-
w[U++] = S;
|
|
58
|
-
U += I;
|
|
59
|
-
}
|
|
60
|
-
if (M.encoding === 1 && V !== M.numValidPixels)
|
|
61
|
-
throw "Block and Mask do not match";
|
|
62
|
-
n++;
|
|
63
|
-
}
|
|
64
|
-
}
|
|
65
|
-
}
|
|
66
|
-
return {
|
|
67
|
-
resultPixels: w,
|
|
68
|
-
resultMask: k,
|
|
69
|
-
minValue: l
|
|
70
|
-
};
|
|
71
|
-
}, X = function(r) {
|
|
72
|
-
return {
|
|
73
|
-
fileIdentifierString: r.fileIdentifierString,
|
|
74
|
-
fileVersion: r.fileVersion,
|
|
75
|
-
imageType: r.imageType,
|
|
76
|
-
height: r.height,
|
|
77
|
-
width: r.width,
|
|
78
|
-
maxZError: r.maxZError,
|
|
79
|
-
eofOffset: r.eofOffset,
|
|
80
|
-
mask: r.mask ? {
|
|
81
|
-
numBlocksX: r.mask.numBlocksX,
|
|
82
|
-
numBlocksY: r.mask.numBlocksY,
|
|
83
|
-
numBytes: r.mask.numBytes,
|
|
84
|
-
maxValue: r.mask.maxValue
|
|
85
|
-
} : null,
|
|
86
|
-
pixels: {
|
|
87
|
-
numBlocksX: r.pixels.numBlocksX,
|
|
88
|
-
numBlocksY: r.pixels.numBlocksY,
|
|
89
|
-
numBytes: r.pixels.numBytes,
|
|
90
|
-
maxValue: r.pixels.maxValue,
|
|
91
|
-
noDataValue: r.noDataValue
|
|
92
|
-
}
|
|
93
|
-
};
|
|
94
|
-
}, H = function(r) {
|
|
95
|
-
for (var o = r.pixels.numBlocksX * r.pixels.numBlocksY, a = {}, i = 0; i < o; i++) {
|
|
96
|
-
var m = r.pixels.blocks[i];
|
|
97
|
-
m.encoding === 0 ? a.float32 = !0 : m.encoding === 1 ? a[m.bitsPerPixel] = !0 : a[0] = !0;
|
|
98
|
-
}
|
|
99
|
-
return Object.keys(a);
|
|
100
|
-
}, t = function(r, o, a) {
|
|
101
|
-
var i = {}, m = new Uint8Array(r, o, 10);
|
|
102
|
-
if (i.fileIdentifierString = String.fromCharCode.apply(null, m), i.fileIdentifierString.trim() !== "CntZImage")
|
|
103
|
-
throw "Unexpected file identifier string: " + i.fileIdentifierString;
|
|
104
|
-
o += 10;
|
|
105
|
-
var n = new DataView(r, o, 24);
|
|
106
|
-
if (i.fileVersion = n.getInt32(0, !0), i.imageType = n.getInt32(4, !0), i.height = n.getUint32(8, !0), i.width = n.getUint32(12, !0), i.maxZError = n.getFloat64(16, !0), o += 24, !a)
|
|
107
|
-
if (n = new DataView(r, o, 16), i.mask = {}, i.mask.numBlocksY = n.getUint32(0, !0), i.mask.numBlocksX = n.getUint32(4, !0), i.mask.numBytes = n.getUint32(8, !0), i.mask.maxValue = n.getFloat32(12, !0), o += 16, i.mask.numBytes > 0) {
|
|
108
|
-
var f = new Uint8Array(Math.ceil(i.width * i.height / 8));
|
|
109
|
-
n = new DataView(r, o, i.mask.numBytes);
|
|
110
|
-
var v = n.getInt16(0, !0), u = 2, h = 0;
|
|
111
|
-
do {
|
|
112
|
-
if (v > 0)
|
|
113
|
-
for (; v--; )
|
|
114
|
-
f[h++] = n.getUint8(u++);
|
|
115
|
-
else {
|
|
116
|
-
var g = n.getUint8(u++);
|
|
117
|
-
for (v = -v; v--; )
|
|
118
|
-
f[h++] = g;
|
|
119
|
-
}
|
|
120
|
-
v = n.getInt16(u, !0), u += 2;
|
|
121
|
-
} while (u < i.mask.numBytes);
|
|
122
|
-
if (v !== -32768 || h < f.length)
|
|
123
|
-
throw "Unexpected end of mask RLE encoding";
|
|
124
|
-
i.mask.bitset = f, o += i.mask.numBytes;
|
|
125
|
-
} else (i.mask.numBytes | i.mask.numBlocksY | i.mask.maxValue) === 0 && (i.mask.bitset = new Uint8Array(Math.ceil(i.width * i.height / 8)));
|
|
126
|
-
n = new DataView(r, o, 16), i.pixels = {}, i.pixels.numBlocksY = n.getUint32(0, !0), i.pixels.numBlocksX = n.getUint32(4, !0), i.pixels.numBytes = n.getUint32(8, !0), i.pixels.maxValue = n.getFloat32(12, !0), o += 16;
|
|
127
|
-
var l = i.pixels.numBlocksX, s = i.pixels.numBlocksY, w = l + (i.width % l > 0 ? 1 : 0), k = s + (i.height % s > 0 ? 1 : 0);
|
|
128
|
-
i.pixels.blocks = new Array(w * k);
|
|
129
|
-
for (var D = 0, p = 0; p < k; p++)
|
|
130
|
-
for (var y = 0; y < w; y++) {
|
|
131
|
-
var x = 0, L = r.byteLength - o;
|
|
132
|
-
n = new DataView(r, o, Math.min(10, L));
|
|
133
|
-
var d = {};
|
|
134
|
-
i.pixels.blocks[D++] = d;
|
|
135
|
-
var c = n.getUint8(0);
|
|
136
|
-
if (x++, d.encoding = c & 63, d.encoding > 3)
|
|
137
|
-
throw "Invalid block encoding (" + d.encoding + ")";
|
|
138
|
-
if (d.encoding === 2) {
|
|
139
|
-
o++;
|
|
140
|
-
continue;
|
|
141
|
-
}
|
|
142
|
-
if (c !== 0 && c !== 2) {
|
|
143
|
-
if (c >>= 6, d.offsetType = c, c === 2)
|
|
144
|
-
d.offset = n.getInt8(1), x++;
|
|
145
|
-
else if (c === 1)
|
|
146
|
-
d.offset = n.getInt16(1, !0), x += 2;
|
|
147
|
-
else if (c === 0)
|
|
148
|
-
d.offset = n.getFloat32(1, !0), x += 4;
|
|
149
|
-
else
|
|
150
|
-
throw "Invalid block offset type";
|
|
151
|
-
if (d.encoding === 1)
|
|
152
|
-
if (c = n.getUint8(x), x++, d.bitsPerPixel = c & 63, c >>= 6, d.numValidPixelsType = c, c === 2)
|
|
153
|
-
d.numValidPixels = n.getUint8(x), x++;
|
|
154
|
-
else if (c === 1)
|
|
155
|
-
d.numValidPixels = n.getUint16(x, !0), x += 2;
|
|
156
|
-
else if (c === 0)
|
|
157
|
-
d.numValidPixels = n.getUint32(x, !0), x += 4;
|
|
158
|
-
else
|
|
159
|
-
throw "Invalid valid pixel count type";
|
|
160
|
-
}
|
|
161
|
-
if (o += x, d.encoding !== 3) {
|
|
162
|
-
var U, I;
|
|
163
|
-
if (d.encoding === 0) {
|
|
164
|
-
var M = (i.pixels.numBytes - 1) / 4;
|
|
165
|
-
if (M !== Math.floor(M))
|
|
166
|
-
throw "uncompressed block has invalid length";
|
|
167
|
-
U = new ArrayBuffer(M * 4), I = new Uint8Array(U), I.set(new Uint8Array(r, o, M * 4));
|
|
168
|
-
var T = new Float32Array(U);
|
|
169
|
-
d.rawData = T, o += M * 4;
|
|
170
|
-
} else if (d.encoding === 1) {
|
|
171
|
-
var V = Math.ceil(d.numValidPixels * d.bitsPerPixel / 8), S = Math.ceil(V / 4);
|
|
172
|
-
U = new ArrayBuffer(S * 4), I = new Uint8Array(U), I.set(new Uint8Array(r, o, V)), d.stuffedData = new Uint32Array(U), o += V;
|
|
173
|
-
}
|
|
174
|
-
}
|
|
175
|
-
}
|
|
176
|
-
return i.eofOffset = o, i;
|
|
177
|
-
}, e = function(r, o, a, i, m, n, f) {
|
|
178
|
-
var v = (1 << o) - 1, u = 0, h, g = 0, l, s, w = Math.ceil((f - i) / m), k = r.length * 4 - Math.ceil(o * a / 8);
|
|
179
|
-
for (r[r.length - 1] <<= 8 * k, h = 0; h < a; h++) {
|
|
180
|
-
if (g === 0 && (s = r[u++], g = 32), g >= o)
|
|
181
|
-
l = s >>> g - o & v, g -= o;
|
|
182
|
-
else {
|
|
183
|
-
var D = o - g;
|
|
184
|
-
l = (s & v) << D & v, s = r[u++], g = 32 - D, l += s >>> g;
|
|
185
|
-
}
|
|
186
|
-
n[h] = l < w ? i + l * m : f;
|
|
187
|
-
}
|
|
188
|
-
return n;
|
|
189
|
-
};
|
|
190
|
-
return F;
|
|
191
|
-
}(), W = /* @__PURE__ */ function() {
|
|
192
|
-
var F = {
|
|
193
|
-
//methods ending with 2 are for the new byte order used by Lerc2.3 and above.
|
|
194
|
-
//originalUnstuff is used to unpack Huffman code table. code is duplicated to unstuffx for performance reasons.
|
|
195
|
-
unstuff: function(t, e, r, o, a, i, m, n) {
|
|
196
|
-
var f = (1 << r) - 1, v = 0, u, h = 0, g, l, s, w, k = t.length * 4 - Math.ceil(r * o / 8);
|
|
197
|
-
if (t[t.length - 1] <<= 8 * k, a)
|
|
198
|
-
for (u = 0; u < o; u++)
|
|
199
|
-
h === 0 && (l = t[v++], h = 32), h >= r ? (g = l >>> h - r & f, h -= r) : (s = r - h, g = (l & f) << s & f, l = t[v++], h = 32 - s, g += l >>> h), e[u] = a[g];
|
|
200
|
-
else
|
|
201
|
-
for (w = Math.ceil((n - i) / m), u = 0; u < o; u++)
|
|
202
|
-
h === 0 && (l = t[v++], h = 32), h >= r ? (g = l >>> h - r & f, h -= r) : (s = r - h, g = (l & f) << s & f, l = t[v++], h = 32 - s, g += l >>> h), e[u] = g < w ? i + g * m : n;
|
|
203
|
-
},
|
|
204
|
-
unstuffLUT: function(t, e, r, o, a, i) {
|
|
205
|
-
var m = (1 << e) - 1, n = 0, f = 0, v = 0, u = 0, h = 0, g, l = [], s = t.length * 4 - Math.ceil(e * r / 8);
|
|
206
|
-
t[t.length - 1] <<= 8 * s;
|
|
207
|
-
var w = Math.ceil((i - o) / a);
|
|
208
|
-
for (f = 0; f < r; f++)
|
|
209
|
-
u === 0 && (g = t[n++], u = 32), u >= e ? (h = g >>> u - e & m, u -= e) : (v = e - u, h = (g & m) << v & m, g = t[n++], u = 32 - v, h += g >>> u), l[f] = h < w ? o + h * a : i;
|
|
210
|
-
return l.unshift(o), l;
|
|
211
|
-
},
|
|
212
|
-
unstuff2: function(t, e, r, o, a, i, m, n) {
|
|
213
|
-
var f = (1 << r) - 1, v = 0, u, h = 0, g = 0, l, s, w;
|
|
214
|
-
if (a)
|
|
215
|
-
for (u = 0; u < o; u++)
|
|
216
|
-
h === 0 && (s = t[v++], h = 32, g = 0), h >= r ? (l = s >>> g & f, h -= r, g += r) : (w = r - h, l = s >>> g & f, s = t[v++], h = 32 - w, l |= (s & (1 << w) - 1) << r - w, g = w), e[u] = a[l];
|
|
217
|
-
else {
|
|
218
|
-
var k = Math.ceil((n - i) / m);
|
|
219
|
-
for (u = 0; u < o; u++)
|
|
220
|
-
h === 0 && (s = t[v++], h = 32, g = 0), h >= r ? (l = s >>> g & f, h -= r, g += r) : (w = r - h, l = s >>> g & f, s = t[v++], h = 32 - w, l |= (s & (1 << w) - 1) << r - w, g = w), e[u] = l < k ? i + l * m : n;
|
|
221
|
-
}
|
|
222
|
-
return e;
|
|
223
|
-
},
|
|
224
|
-
unstuffLUT2: function(t, e, r, o, a, i) {
|
|
225
|
-
var m = (1 << e) - 1, n = 0, f = 0, v = 0, u = 0, h = 0, g = 0, l, s = [], w = Math.ceil((i - o) / a);
|
|
226
|
-
for (f = 0; f < r; f++)
|
|
227
|
-
u === 0 && (l = t[n++], u = 32, g = 0), u >= e ? (h = l >>> g & m, u -= e, g += e) : (v = e - u, h = l >>> g & m, l = t[n++], u = 32 - v, h |= (l & (1 << v) - 1) << e - v, g = v), s[f] = h < w ? o + h * a : i;
|
|
228
|
-
return s.unshift(o), s;
|
|
229
|
-
},
|
|
230
|
-
originalUnstuff: function(t, e, r, o) {
|
|
231
|
-
var a = (1 << r) - 1, i = 0, m, n = 0, f, v, u, h = t.length * 4 - Math.ceil(r * o / 8);
|
|
232
|
-
for (t[t.length - 1] <<= 8 * h, m = 0; m < o; m++)
|
|
233
|
-
n === 0 && (v = t[i++], n = 32), n >= r ? (f = v >>> n - r & a, n -= r) : (u = r - n, f = (v & a) << u & a, v = t[i++], n = 32 - u, f += v >>> n), e[m] = f;
|
|
234
|
-
return e;
|
|
235
|
-
},
|
|
236
|
-
originalUnstuff2: function(t, e, r, o) {
|
|
237
|
-
var a = (1 << r) - 1, i = 0, m, n = 0, f = 0, v, u, h;
|
|
238
|
-
for (m = 0; m < o; m++)
|
|
239
|
-
n === 0 && (u = t[i++], n = 32, f = 0), n >= r ? (v = u >>> f & a, n -= r, f += r) : (h = r - n, v = u >>> f & a, u = t[i++], n = 32 - h, v |= (u & (1 << h) - 1) << r - h, f = h), e[m] = v;
|
|
240
|
-
return e;
|
|
241
|
-
}
|
|
242
|
-
}, A = {
|
|
243
|
-
HUFFMAN_LUT_BITS_MAX: 12,
|
|
244
|
-
//use 2^12 lut, treat it like constant
|
|
245
|
-
computeChecksumFletcher32: function(t) {
|
|
246
|
-
for (var e = 65535, r = 65535, o = t.length, a = Math.floor(o / 2), i = 0; a; ) {
|
|
247
|
-
var m = a >= 359 ? 359 : a;
|
|
248
|
-
a -= m;
|
|
249
|
-
do
|
|
250
|
-
e += t[i++] << 8, r += e += t[i++];
|
|
251
|
-
while (--m);
|
|
252
|
-
e = (e & 65535) + (e >>> 16), r = (r & 65535) + (r >>> 16);
|
|
253
|
-
}
|
|
254
|
-
return o & 1 && (r += e += t[i] << 8), e = (e & 65535) + (e >>> 16), r = (r & 65535) + (r >>> 16), (r << 16 | e) >>> 0;
|
|
255
|
-
},
|
|
256
|
-
readHeaderInfo: function(t, e) {
|
|
257
|
-
var r = e.ptr, o = new Uint8Array(t, r, 6), a = {};
|
|
258
|
-
if (a.fileIdentifierString = String.fromCharCode.apply(null, o), a.fileIdentifierString.lastIndexOf("Lerc2", 0) !== 0)
|
|
259
|
-
throw "Unexpected file identifier string (expect Lerc2 ): " + a.fileIdentifierString;
|
|
260
|
-
r += 6;
|
|
261
|
-
var i = new DataView(t, r, 8), m = i.getInt32(0, !0);
|
|
262
|
-
a.fileVersion = m, r += 4, m >= 3 && (a.checksum = i.getUint32(4, !0), r += 4), i = new DataView(t, r, 12), a.height = i.getUint32(0, !0), a.width = i.getUint32(4, !0), r += 8, m >= 4 ? (a.numDims = i.getUint32(8, !0), r += 4) : a.numDims = 1, i = new DataView(t, r, 40), a.numValidPixel = i.getUint32(0, !0), a.microBlockSize = i.getInt32(4, !0), a.blobSize = i.getInt32(8, !0), a.imageType = i.getInt32(12, !0), a.maxZError = i.getFloat64(16, !0), a.zMin = i.getFloat64(24, !0), a.zMax = i.getFloat64(32, !0), r += 40, e.headerInfo = a, e.ptr = r;
|
|
263
|
-
var n, f;
|
|
264
|
-
if (m >= 3 && (f = m >= 4 ? 52 : 48, n = this.computeChecksumFletcher32(new Uint8Array(t, r - f, a.blobSize - 14)), n !== a.checksum))
|
|
265
|
-
throw "Checksum failed.";
|
|
266
|
-
return !0;
|
|
267
|
-
},
|
|
268
|
-
checkMinMaxRanges: function(t, e) {
|
|
269
|
-
var r = e.headerInfo, o = this.getDataTypeArray(r.imageType), a = r.numDims * this.getDataTypeSize(r.imageType), i = this.readSubArray(t, e.ptr, o, a), m = this.readSubArray(t, e.ptr + a, o, a);
|
|
270
|
-
e.ptr += 2 * a;
|
|
271
|
-
var n, f = !0;
|
|
272
|
-
for (n = 0; n < r.numDims; n++)
|
|
273
|
-
if (i[n] !== m[n]) {
|
|
274
|
-
f = !1;
|
|
275
|
-
break;
|
|
276
|
-
}
|
|
277
|
-
return r.minValues = i, r.maxValues = m, f;
|
|
278
|
-
},
|
|
279
|
-
readSubArray: function(t, e, r, o) {
|
|
280
|
-
var a;
|
|
281
|
-
if (r === Uint8Array)
|
|
282
|
-
a = new Uint8Array(t, e, o);
|
|
283
|
-
else {
|
|
284
|
-
var i = new ArrayBuffer(o), m = new Uint8Array(i);
|
|
285
|
-
m.set(new Uint8Array(t, e, o)), a = new r(i);
|
|
286
|
-
}
|
|
287
|
-
return a;
|
|
288
|
-
},
|
|
289
|
-
readMask: function(t, e) {
|
|
290
|
-
var r = e.ptr, o = e.headerInfo, a = o.width * o.height, i = o.numValidPixel, m = new DataView(t, r, 4), n = {};
|
|
291
|
-
if (n.numBytes = m.getUint32(0, !0), r += 4, (i === 0 || a === i) && n.numBytes !== 0)
|
|
292
|
-
throw "invalid mask";
|
|
293
|
-
var f, v;
|
|
294
|
-
if (i === 0)
|
|
295
|
-
f = new Uint8Array(Math.ceil(a / 8)), n.bitset = f, v = new Uint8Array(a), e.pixels.resultMask = v, r += n.numBytes;
|
|
296
|
-
else if (n.numBytes > 0) {
|
|
297
|
-
f = new Uint8Array(Math.ceil(a / 8)), m = new DataView(t, r, n.numBytes);
|
|
298
|
-
var u = m.getInt16(0, !0), h = 2, g = 0, l = 0;
|
|
299
|
-
do {
|
|
300
|
-
if (u > 0)
|
|
301
|
-
for (; u--; )
|
|
302
|
-
f[g++] = m.getUint8(h++);
|
|
303
|
-
else
|
|
304
|
-
for (l = m.getUint8(h++), u = -u; u--; )
|
|
305
|
-
f[g++] = l;
|
|
306
|
-
u = m.getInt16(h, !0), h += 2;
|
|
307
|
-
} while (h < n.numBytes);
|
|
308
|
-
if (u !== -32768 || g < f.length)
|
|
309
|
-
throw "Unexpected end of mask RLE encoding";
|
|
310
|
-
v = new Uint8Array(a);
|
|
311
|
-
var s = 0, w = 0;
|
|
312
|
-
for (w = 0; w < a; w++)
|
|
313
|
-
w & 7 ? (s = f[w >> 3], s <<= w & 7) : s = f[w >> 3], s & 128 && (v[w] = 1);
|
|
314
|
-
e.pixels.resultMask = v, n.bitset = f, r += n.numBytes;
|
|
315
|
-
}
|
|
316
|
-
return e.ptr = r, e.mask = n, !0;
|
|
317
|
-
},
|
|
318
|
-
readDataOneSweep: function(t, e, r, o) {
|
|
319
|
-
var a = e.ptr, i = e.headerInfo, m = i.numDims, n = i.width * i.height, f = i.imageType, v = i.numValidPixel * A.getDataTypeSize(f) * m, u, h = e.pixels.resultMask;
|
|
320
|
-
if (r === Uint8Array)
|
|
321
|
-
u = new Uint8Array(t, a, v);
|
|
322
|
-
else {
|
|
323
|
-
var g = new ArrayBuffer(v), l = new Uint8Array(g);
|
|
324
|
-
l.set(new Uint8Array(t, a, v)), u = new r(g);
|
|
325
|
-
}
|
|
326
|
-
if (u.length === n * m)
|
|
327
|
-
o ? e.pixels.resultPixels = A.swapDimensionOrder(u, n, m, r, !0) : e.pixels.resultPixels = u;
|
|
328
|
-
else {
|
|
329
|
-
e.pixels.resultPixels = new r(n * m);
|
|
330
|
-
var s = 0, w = 0, k = 0, D = 0;
|
|
331
|
-
if (m > 1) {
|
|
332
|
-
if (o) {
|
|
333
|
-
for (w = 0; w < n; w++)
|
|
334
|
-
if (h[w])
|
|
335
|
-
for (D = w, k = 0; k < m; k++, D += n)
|
|
336
|
-
e.pixels.resultPixels[D] = u[s++];
|
|
337
|
-
} else
|
|
338
|
-
for (w = 0; w < n; w++)
|
|
339
|
-
if (h[w])
|
|
340
|
-
for (D = w * m, k = 0; k < m; k++)
|
|
341
|
-
e.pixels.resultPixels[D + k] = u[s++];
|
|
342
|
-
} else
|
|
343
|
-
for (w = 0; w < n; w++)
|
|
344
|
-
h[w] && (e.pixels.resultPixels[w] = u[s++]);
|
|
345
|
-
}
|
|
346
|
-
return a += v, e.ptr = a, !0;
|
|
347
|
-
},
|
|
348
|
-
readHuffmanTree: function(t, e) {
|
|
349
|
-
var r = this.HUFFMAN_LUT_BITS_MAX, o = new DataView(t, e.ptr, 16);
|
|
350
|
-
e.ptr += 16;
|
|
351
|
-
var a = o.getInt32(0, !0);
|
|
352
|
-
if (a < 2)
|
|
353
|
-
throw "unsupported Huffman version";
|
|
354
|
-
var i = o.getInt32(4, !0), m = o.getInt32(8, !0), n = o.getInt32(12, !0);
|
|
355
|
-
if (m >= n)
|
|
356
|
-
return !1;
|
|
357
|
-
var f = new Uint32Array(n - m);
|
|
358
|
-
A.decodeBits(t, e, f);
|
|
359
|
-
var v = [], u, h, g, l;
|
|
360
|
-
for (u = m; u < n; u++)
|
|
361
|
-
h = u - (u < i ? 0 : i), v[h] = { first: f[u - m], second: null };
|
|
362
|
-
var s = t.byteLength - e.ptr, w = Math.ceil(s / 4), k = new ArrayBuffer(w * 4), D = new Uint8Array(k);
|
|
363
|
-
D.set(new Uint8Array(t, e.ptr, s));
|
|
364
|
-
var p = new Uint32Array(k), y = 0, x, L = 0;
|
|
365
|
-
for (x = p[0], u = m; u < n; u++)
|
|
366
|
-
h = u - (u < i ? 0 : i), l = v[h].first, l > 0 && (v[h].second = x << y >>> 32 - l, 32 - y >= l ? (y += l, y === 32 && (y = 0, L++, x = p[L])) : (y += l - 32, L++, x = p[L], v[h].second |= x >>> 32 - y));
|
|
367
|
-
var d = 0, c = 0, U = new X();
|
|
368
|
-
for (u = 0; u < v.length; u++)
|
|
369
|
-
v[u] !== void 0 && (d = Math.max(d, v[u].first));
|
|
370
|
-
d >= r ? c = r : c = d;
|
|
371
|
-
var I = [], M, T, V, S, B, C;
|
|
372
|
-
for (u = m; u < n; u++)
|
|
373
|
-
if (h = u - (u < i ? 0 : i), l = v[h].first, l > 0)
|
|
374
|
-
if (M = [l, h], l <= c)
|
|
375
|
-
for (T = v[h].second << c - l, V = 1 << c - l, g = 0; g < V; g++)
|
|
376
|
-
I[T | g] = M;
|
|
377
|
-
else
|
|
378
|
-
for (T = v[h].second, C = U, S = l - 1; S >= 0; S--)
|
|
379
|
-
B = T >>> S & 1, B ? (C.right || (C.right = new X()), C = C.right) : (C.left || (C.left = new X()), C = C.left), S === 0 && !C.val && (C.val = M[1]);
|
|
380
|
-
return {
|
|
381
|
-
decodeLut: I,
|
|
382
|
-
numBitsLUTQick: c,
|
|
383
|
-
numBitsLUT: d,
|
|
384
|
-
tree: U,
|
|
385
|
-
stuffedData: p,
|
|
386
|
-
srcPtr: L,
|
|
387
|
-
bitPos: y
|
|
388
|
-
};
|
|
389
|
-
},
|
|
390
|
-
readHuffman: function(t, e, r, o) {
|
|
391
|
-
var a = e.headerInfo, i = a.numDims, m = e.headerInfo.height, n = e.headerInfo.width, f = n * m, v = this.readHuffmanTree(t, e), u = v.decodeLut, h = v.tree, g = v.stuffedData, l = v.srcPtr, s = v.bitPos, w = v.numBitsLUTQick, k = v.numBitsLUT, D = e.headerInfo.imageType === 0 ? 128 : 0, p, y, x, L = e.pixels.resultMask, d, c, U, I, M, T, V, S = 0;
|
|
392
|
-
s > 0 && (l++, s = 0);
|
|
393
|
-
var B = g[l], C = e.encodeMode === 1, j = new r(f * i), O = j, b;
|
|
394
|
-
if (i < 2 || C) {
|
|
395
|
-
for (b = 0; b < i; b++)
|
|
396
|
-
if (i > 1 && (O = new r(j.buffer, f * b, f), S = 0), e.headerInfo.numValidPixel === n * m)
|
|
397
|
-
for (T = 0, I = 0; I < m; I++)
|
|
398
|
-
for (M = 0; M < n; M++, T++) {
|
|
399
|
-
if (y = 0, d = B << s >>> 32 - w, c = d, 32 - s < w && (d |= g[l + 1] >>> 64 - s - w, c = d), u[c])
|
|
400
|
-
y = u[c][1], s += u[c][0];
|
|
401
|
-
else
|
|
402
|
-
for (d = B << s >>> 32 - k, c = d, 32 - s < k && (d |= g[l + 1] >>> 64 - s - k, c = d), p = h, V = 0; V < k; V++)
|
|
403
|
-
if (U = d >>> k - V - 1 & 1, p = U ? p.right : p.left, !(p.left || p.right)) {
|
|
404
|
-
y = p.val, s = s + V + 1;
|
|
405
|
-
break;
|
|
406
|
-
}
|
|
407
|
-
s >= 32 && (s -= 32, l++, B = g[l]), x = y - D, C ? (M > 0 ? x += S : I > 0 ? x += O[T - n] : x += S, x &= 255, O[T] = x, S = x) : O[T] = x;
|
|
408
|
-
}
|
|
409
|
-
else
|
|
410
|
-
for (T = 0, I = 0; I < m; I++)
|
|
411
|
-
for (M = 0; M < n; M++, T++)
|
|
412
|
-
if (L[T]) {
|
|
413
|
-
if (y = 0, d = B << s >>> 32 - w, c = d, 32 - s < w && (d |= g[l + 1] >>> 64 - s - w, c = d), u[c])
|
|
414
|
-
y = u[c][1], s += u[c][0];
|
|
415
|
-
else
|
|
416
|
-
for (d = B << s >>> 32 - k, c = d, 32 - s < k && (d |= g[l + 1] >>> 64 - s - k, c = d), p = h, V = 0; V < k; V++)
|
|
417
|
-
if (U = d >>> k - V - 1 & 1, p = U ? p.right : p.left, !(p.left || p.right)) {
|
|
418
|
-
y = p.val, s = s + V + 1;
|
|
419
|
-
break;
|
|
420
|
-
}
|
|
421
|
-
s >= 32 && (s -= 32, l++, B = g[l]), x = y - D, C ? (M > 0 && L[T - 1] ? x += S : I > 0 && L[T - n] ? x += O[T - n] : x += S, x &= 255, O[T] = x, S = x) : O[T] = x;
|
|
422
|
-
}
|
|
423
|
-
} else
|
|
424
|
-
for (T = 0, I = 0; I < m; I++)
|
|
425
|
-
for (M = 0; M < n; M++)
|
|
426
|
-
if (T = I * n + M, !L || L[T])
|
|
427
|
-
for (b = 0; b < i; b++, T += f) {
|
|
428
|
-
if (y = 0, d = B << s >>> 32 - w, c = d, 32 - s < w && (d |= g[l + 1] >>> 64 - s - w, c = d), u[c])
|
|
429
|
-
y = u[c][1], s += u[c][0];
|
|
430
|
-
else
|
|
431
|
-
for (d = B << s >>> 32 - k, c = d, 32 - s < k && (d |= g[l + 1] >>> 64 - s - k, c = d), p = h, V = 0; V < k; V++)
|
|
432
|
-
if (U = d >>> k - V - 1 & 1, p = U ? p.right : p.left, !(p.left || p.right)) {
|
|
433
|
-
y = p.val, s = s + V + 1;
|
|
434
|
-
break;
|
|
435
|
-
}
|
|
436
|
-
s >= 32 && (s -= 32, l++, B = g[l]), x = y - D, O[T] = x;
|
|
437
|
-
}
|
|
438
|
-
e.ptr = e.ptr + (l + 1) * 4 + (s > 0 ? 4 : 0), e.pixels.resultPixels = j, i > 1 && !o && (e.pixels.resultPixels = A.swapDimensionOrder(j, f, i, r));
|
|
439
|
-
},
|
|
440
|
-
decodeBits: function(t, e, r, o, a) {
|
|
441
|
-
{
|
|
442
|
-
var i = e.headerInfo, m = i.fileVersion, n = 0, f = t.byteLength - e.ptr >= 5 ? 5 : t.byteLength - e.ptr, v = new DataView(t, e.ptr, f), u = v.getUint8(0);
|
|
443
|
-
n++;
|
|
444
|
-
var h = u >> 6, g = h === 0 ? 4 : 3 - h, l = (u & 32) > 0, s = u & 31, w = 0;
|
|
445
|
-
if (g === 1)
|
|
446
|
-
w = v.getUint8(n), n++;
|
|
447
|
-
else if (g === 2)
|
|
448
|
-
w = v.getUint16(n, !0), n += 2;
|
|
449
|
-
else if (g === 4)
|
|
450
|
-
w = v.getUint32(n, !0), n += 4;
|
|
451
|
-
else
|
|
452
|
-
throw "Invalid valid pixel count type";
|
|
453
|
-
var k = 2 * i.maxZError, D, p, y, x, L, d, c, U, I, M = i.numDims > 1 ? i.maxValues[a] : i.zMax;
|
|
454
|
-
if (l) {
|
|
455
|
-
for (e.counter.lut++, U = v.getUint8(n), n++, x = Math.ceil((U - 1) * s / 8), L = Math.ceil(x / 4), p = new ArrayBuffer(L * 4), y = new Uint8Array(p), e.ptr += n, y.set(new Uint8Array(t, e.ptr, x)), c = new Uint32Array(p), e.ptr += x, I = 0; U - 1 >>> I; )
|
|
456
|
-
I++;
|
|
457
|
-
x = Math.ceil(w * I / 8), L = Math.ceil(x / 4), p = new ArrayBuffer(L * 4), y = new Uint8Array(p), y.set(new Uint8Array(t, e.ptr, x)), D = new Uint32Array(p), e.ptr += x, m >= 3 ? d = F.unstuffLUT2(c, s, U - 1, o, k, M) : d = F.unstuffLUT(c, s, U - 1, o, k, M), m >= 3 ? F.unstuff2(D, r, I, w, d) : F.unstuff(D, r, I, w, d);
|
|
458
|
-
} else
|
|
459
|
-
e.counter.bitstuffer++, I = s, e.ptr += n, I > 0 && (x = Math.ceil(w * I / 8), L = Math.ceil(x / 4), p = new ArrayBuffer(L * 4), y = new Uint8Array(p), y.set(new Uint8Array(t, e.ptr, x)), D = new Uint32Array(p), e.ptr += x, m >= 3 ? o == null ? F.originalUnstuff2(D, r, I, w) : F.unstuff2(D, r, I, w, !1, o, k, M) : o == null ? F.originalUnstuff(D, r, I, w) : F.unstuff(D, r, I, w, !1, o, k, M));
|
|
460
|
-
}
|
|
461
|
-
},
|
|
462
|
-
readTiles: function(t, e, r, o) {
|
|
463
|
-
var a = e.headerInfo, i = a.width, m = a.height, n = i * m, f = a.microBlockSize, v = a.imageType, u = A.getDataTypeSize(v), h = Math.ceil(i / f), g = Math.ceil(m / f);
|
|
464
|
-
e.pixels.numBlocksY = g, e.pixels.numBlocksX = h, e.pixels.ptr = 0;
|
|
465
|
-
var l = 0, s = 0, w = 0, k = 0, D = 0, p = 0, y = 0, x = 0, L = 0, d = 0, c = 0, U = 0, I = 0, M = 0, T = 0, V = 0, S, B, C, j, O, b, Q = new r(f * f), ae = m % f || f, fe = i % f || f, G, _, q = a.numDims, R, E = e.pixels.resultMask, z = e.pixels.resultPixels, te = a.fileVersion, re = te >= 5 ? 14 : 15, Z, J = a.zMax, N;
|
|
466
|
-
for (w = 0; w < g; w++)
|
|
467
|
-
for (D = w !== g - 1 ? f : ae, k = 0; k < h; k++)
|
|
468
|
-
for (p = k !== h - 1 ? f : fe, c = w * i * f + k * f, U = i - p, R = 0; R < q; R++) {
|
|
469
|
-
if (q > 1 ? (N = z, c = w * i * f + k * f, z = new r(e.pixels.resultPixels.buffer, n * R * u, n), J = a.maxValues[R]) : N = null, y = t.byteLength - e.ptr, S = new DataView(t, e.ptr, Math.min(10, y)), B = {}, V = 0, x = S.getUint8(0), V++, Z = a.fileVersion >= 5 ? x & 4 : 0, L = x >> 6 & 255, d = x >> 2 & re, d !== (k * f >> 3 & re) || Z && R === 0)
|
|
470
|
-
throw "integrity issue";
|
|
471
|
-
if (b = x & 3, b > 3)
|
|
472
|
-
throw e.ptr += V, "Invalid block encoding (" + b + ")";
|
|
473
|
-
if (b === 2) {
|
|
474
|
-
if (Z)
|
|
475
|
-
if (E)
|
|
476
|
-
for (l = 0; l < D; l++)
|
|
477
|
-
for (s = 0; s < p; s++)
|
|
478
|
-
E[c] && (z[c] = N[c]), c++;
|
|
479
|
-
else
|
|
480
|
-
for (l = 0; l < D; l++)
|
|
481
|
-
for (s = 0; s < p; s++)
|
|
482
|
-
z[c] = N[c], c++;
|
|
483
|
-
e.counter.constant++, e.ptr += V;
|
|
484
|
-
continue;
|
|
485
|
-
} else if (b === 0) {
|
|
486
|
-
if (Z)
|
|
487
|
-
throw "integrity issue";
|
|
488
|
-
if (e.counter.uncompressed++, e.ptr += V, I = D * p * u, M = t.byteLength - e.ptr, I = I < M ? I : M, C = new ArrayBuffer(I % u === 0 ? I : I + u - I % u), j = new Uint8Array(C), j.set(new Uint8Array(t, e.ptr, I)), O = new r(C), T = 0, E)
|
|
489
|
-
for (l = 0; l < D; l++) {
|
|
490
|
-
for (s = 0; s < p; s++)
|
|
491
|
-
E[c] && (z[c] = O[T++]), c++;
|
|
492
|
-
c += U;
|
|
493
|
-
}
|
|
494
|
-
else
|
|
495
|
-
for (l = 0; l < D; l++) {
|
|
496
|
-
for (s = 0; s < p; s++)
|
|
497
|
-
z[c++] = O[T++];
|
|
498
|
-
c += U;
|
|
499
|
-
}
|
|
500
|
-
e.ptr += T * u;
|
|
501
|
-
} else if (G = A.getDataTypeUsed(Z && v < 6 ? 4 : v, L), _ = A.getOnePixel(B, V, G, S), V += A.getDataTypeSize(G), b === 3)
|
|
502
|
-
if (e.ptr += V, e.counter.constantoffset++, E)
|
|
503
|
-
for (l = 0; l < D; l++) {
|
|
504
|
-
for (s = 0; s < p; s++)
|
|
505
|
-
E[c] && (z[c] = Z ? Math.min(J, N[c] + _) : _), c++;
|
|
506
|
-
c += U;
|
|
507
|
-
}
|
|
508
|
-
else
|
|
509
|
-
for (l = 0; l < D; l++) {
|
|
510
|
-
for (s = 0; s < p; s++)
|
|
511
|
-
z[c] = Z ? Math.min(J, N[c] + _) : _, c++;
|
|
512
|
-
c += U;
|
|
513
|
-
}
|
|
514
|
-
else if (e.ptr += V, A.decodeBits(t, e, Q, _, R), V = 0, Z)
|
|
515
|
-
if (E)
|
|
516
|
-
for (l = 0; l < D; l++) {
|
|
517
|
-
for (s = 0; s < p; s++)
|
|
518
|
-
E[c] && (z[c] = Q[V++] + N[c]), c++;
|
|
519
|
-
c += U;
|
|
520
|
-
}
|
|
521
|
-
else
|
|
522
|
-
for (l = 0; l < D; l++) {
|
|
523
|
-
for (s = 0; s < p; s++)
|
|
524
|
-
z[c] = Q[V++] + N[c], c++;
|
|
525
|
-
c += U;
|
|
526
|
-
}
|
|
527
|
-
else if (E)
|
|
528
|
-
for (l = 0; l < D; l++) {
|
|
529
|
-
for (s = 0; s < p; s++)
|
|
530
|
-
E[c] && (z[c] = Q[V++]), c++;
|
|
531
|
-
c += U;
|
|
532
|
-
}
|
|
533
|
-
else
|
|
534
|
-
for (l = 0; l < D; l++) {
|
|
535
|
-
for (s = 0; s < p; s++)
|
|
536
|
-
z[c++] = Q[V++];
|
|
537
|
-
c += U;
|
|
538
|
-
}
|
|
539
|
-
}
|
|
540
|
-
q > 1 && !o && (e.pixels.resultPixels = A.swapDimensionOrder(e.pixels.resultPixels, n, q, r));
|
|
541
|
-
},
|
|
542
|
-
/*****************
|
|
543
|
-
* private methods (helper methods)
|
|
544
|
-
*****************/
|
|
545
|
-
formatFileInfo: function(t) {
|
|
546
|
-
return {
|
|
547
|
-
fileIdentifierString: t.headerInfo.fileIdentifierString,
|
|
548
|
-
fileVersion: t.headerInfo.fileVersion,
|
|
549
|
-
imageType: t.headerInfo.imageType,
|
|
550
|
-
height: t.headerInfo.height,
|
|
551
|
-
width: t.headerInfo.width,
|
|
552
|
-
numValidPixel: t.headerInfo.numValidPixel,
|
|
553
|
-
microBlockSize: t.headerInfo.microBlockSize,
|
|
554
|
-
blobSize: t.headerInfo.blobSize,
|
|
555
|
-
maxZError: t.headerInfo.maxZError,
|
|
556
|
-
pixelType: A.getPixelType(t.headerInfo.imageType),
|
|
557
|
-
eofOffset: t.eofOffset,
|
|
558
|
-
mask: t.mask ? {
|
|
559
|
-
numBytes: t.mask.numBytes
|
|
560
|
-
} : null,
|
|
561
|
-
pixels: {
|
|
562
|
-
numBlocksX: t.pixels.numBlocksX,
|
|
563
|
-
numBlocksY: t.pixels.numBlocksY,
|
|
564
|
-
//"numBytes": data.pixels.numBytes,
|
|
565
|
-
maxValue: t.headerInfo.zMax,
|
|
566
|
-
minValue: t.headerInfo.zMin,
|
|
567
|
-
noDataValue: t.noDataValue
|
|
568
|
-
}
|
|
569
|
-
};
|
|
570
|
-
},
|
|
571
|
-
constructConstantSurface: function(t, e) {
|
|
572
|
-
var r = t.headerInfo.zMax, o = t.headerInfo.zMin, a = t.headerInfo.maxValues, i = t.headerInfo.numDims, m = t.headerInfo.height * t.headerInfo.width, n = 0, f = 0, v = 0, u = t.pixels.resultMask, h = t.pixels.resultPixels;
|
|
573
|
-
if (u)
|
|
574
|
-
if (i > 1) {
|
|
575
|
-
if (e)
|
|
576
|
-
for (n = 0; n < i; n++)
|
|
577
|
-
for (v = n * m, r = a[n], f = 0; f < m; f++)
|
|
578
|
-
u[f] && (h[v + f] = r);
|
|
579
|
-
else
|
|
580
|
-
for (f = 0; f < m; f++)
|
|
581
|
-
if (u[f])
|
|
582
|
-
for (v = f * i, n = 0; n < i; n++)
|
|
583
|
-
h[v + i] = a[n];
|
|
584
|
-
} else
|
|
585
|
-
for (f = 0; f < m; f++)
|
|
586
|
-
u[f] && (h[f] = r);
|
|
587
|
-
else if (i > 1 && o !== r)
|
|
588
|
-
if (e)
|
|
589
|
-
for (n = 0; n < i; n++)
|
|
590
|
-
for (v = n * m, r = a[n], f = 0; f < m; f++)
|
|
591
|
-
h[v + f] = r;
|
|
592
|
-
else
|
|
593
|
-
for (f = 0; f < m; f++)
|
|
594
|
-
for (v = f * i, n = 0; n < i; n++)
|
|
595
|
-
h[v + n] = a[n];
|
|
596
|
-
else
|
|
597
|
-
for (f = 0; f < m * i; f++)
|
|
598
|
-
h[f] = r;
|
|
599
|
-
},
|
|
600
|
-
getDataTypeArray: function(t) {
|
|
601
|
-
var e;
|
|
602
|
-
switch (t) {
|
|
603
|
-
case 0:
|
|
604
|
-
e = Int8Array;
|
|
605
|
-
break;
|
|
606
|
-
case 1:
|
|
607
|
-
e = Uint8Array;
|
|
608
|
-
break;
|
|
609
|
-
case 2:
|
|
610
|
-
e = Int16Array;
|
|
611
|
-
break;
|
|
612
|
-
case 3:
|
|
613
|
-
e = Uint16Array;
|
|
614
|
-
break;
|
|
615
|
-
case 4:
|
|
616
|
-
e = Int32Array;
|
|
617
|
-
break;
|
|
618
|
-
case 5:
|
|
619
|
-
e = Uint32Array;
|
|
620
|
-
break;
|
|
621
|
-
case 6:
|
|
622
|
-
e = Float32Array;
|
|
623
|
-
break;
|
|
624
|
-
case 7:
|
|
625
|
-
e = Float64Array;
|
|
626
|
-
break;
|
|
627
|
-
default:
|
|
628
|
-
e = Float32Array;
|
|
629
|
-
}
|
|
630
|
-
return e;
|
|
631
|
-
},
|
|
632
|
-
getPixelType: function(t) {
|
|
633
|
-
var e;
|
|
634
|
-
switch (t) {
|
|
635
|
-
case 0:
|
|
636
|
-
e = "S8";
|
|
637
|
-
break;
|
|
638
|
-
case 1:
|
|
639
|
-
e = "U8";
|
|
640
|
-
break;
|
|
641
|
-
case 2:
|
|
642
|
-
e = "S16";
|
|
643
|
-
break;
|
|
644
|
-
case 3:
|
|
645
|
-
e = "U16";
|
|
646
|
-
break;
|
|
647
|
-
case 4:
|
|
648
|
-
e = "S32";
|
|
649
|
-
break;
|
|
650
|
-
case 5:
|
|
651
|
-
e = "U32";
|
|
652
|
-
break;
|
|
653
|
-
case 6:
|
|
654
|
-
e = "F32";
|
|
655
|
-
break;
|
|
656
|
-
case 7:
|
|
657
|
-
e = "F64";
|
|
658
|
-
break;
|
|
659
|
-
default:
|
|
660
|
-
e = "F32";
|
|
661
|
-
}
|
|
662
|
-
return e;
|
|
663
|
-
},
|
|
664
|
-
isValidPixelValue: function(t, e) {
|
|
665
|
-
if (e == null)
|
|
666
|
-
return !1;
|
|
667
|
-
var r;
|
|
668
|
-
switch (t) {
|
|
669
|
-
case 0:
|
|
670
|
-
r = e >= -128 && e <= 127;
|
|
671
|
-
break;
|
|
672
|
-
case 1:
|
|
673
|
-
r = e >= 0 && e <= 255;
|
|
674
|
-
break;
|
|
675
|
-
case 2:
|
|
676
|
-
r = e >= -32768 && e <= 32767;
|
|
677
|
-
break;
|
|
678
|
-
case 3:
|
|
679
|
-
r = e >= 0 && e <= 65536;
|
|
680
|
-
break;
|
|
681
|
-
case 4:
|
|
682
|
-
r = e >= -2147483648 && e <= 2147483647;
|
|
683
|
-
break;
|
|
684
|
-
case 5:
|
|
685
|
-
r = e >= 0 && e <= 4294967296;
|
|
686
|
-
break;
|
|
687
|
-
case 6:
|
|
688
|
-
r = e >= -34027999387901484e22 && e <= 34027999387901484e22;
|
|
689
|
-
break;
|
|
690
|
-
case 7:
|
|
691
|
-
r = e >= -17976931348623157e292 && e <= 17976931348623157e292;
|
|
692
|
-
break;
|
|
693
|
-
default:
|
|
694
|
-
r = !1;
|
|
695
|
-
}
|
|
696
|
-
return r;
|
|
697
|
-
},
|
|
698
|
-
getDataTypeSize: function(t) {
|
|
699
|
-
var e = 0;
|
|
700
|
-
switch (t) {
|
|
701
|
-
case 0:
|
|
702
|
-
//ubyte
|
|
703
|
-
case 1:
|
|
704
|
-
e = 1;
|
|
705
|
-
break;
|
|
706
|
-
case 2:
|
|
707
|
-
//short
|
|
708
|
-
case 3:
|
|
709
|
-
e = 2;
|
|
710
|
-
break;
|
|
711
|
-
case 4:
|
|
712
|
-
case 5:
|
|
713
|
-
case 6:
|
|
714
|
-
e = 4;
|
|
715
|
-
break;
|
|
716
|
-
case 7:
|
|
717
|
-
e = 8;
|
|
718
|
-
break;
|
|
719
|
-
default:
|
|
720
|
-
e = t;
|
|
721
|
-
}
|
|
722
|
-
return e;
|
|
723
|
-
},
|
|
724
|
-
getDataTypeUsed: function(t, e) {
|
|
725
|
-
var r = t;
|
|
726
|
-
switch (t) {
|
|
727
|
-
case 2:
|
|
728
|
-
//short
|
|
729
|
-
case 4:
|
|
730
|
-
r = t - e;
|
|
731
|
-
break;
|
|
732
|
-
case 3:
|
|
733
|
-
//ushort
|
|
734
|
-
case 5:
|
|
735
|
-
r = t - 2 * e;
|
|
736
|
-
break;
|
|
737
|
-
case 6:
|
|
738
|
-
e === 0 ? r = t : e === 1 ? r = 2 : r = 1;
|
|
739
|
-
break;
|
|
740
|
-
case 7:
|
|
741
|
-
e === 0 ? r = t : r = t - 2 * e + 1;
|
|
742
|
-
break;
|
|
743
|
-
default:
|
|
744
|
-
r = t;
|
|
745
|
-
break;
|
|
746
|
-
}
|
|
747
|
-
return r;
|
|
748
|
-
},
|
|
749
|
-
getOnePixel: function(t, e, r, o) {
|
|
750
|
-
var a = 0;
|
|
751
|
-
switch (r) {
|
|
752
|
-
case 0:
|
|
753
|
-
a = o.getInt8(e);
|
|
754
|
-
break;
|
|
755
|
-
case 1:
|
|
756
|
-
a = o.getUint8(e);
|
|
757
|
-
break;
|
|
758
|
-
case 2:
|
|
759
|
-
a = o.getInt16(e, !0);
|
|
760
|
-
break;
|
|
761
|
-
case 3:
|
|
762
|
-
a = o.getUint16(e, !0);
|
|
763
|
-
break;
|
|
764
|
-
case 4:
|
|
765
|
-
a = o.getInt32(e, !0);
|
|
766
|
-
break;
|
|
767
|
-
case 5:
|
|
768
|
-
a = o.getUInt32(e, !0);
|
|
769
|
-
break;
|
|
770
|
-
case 6:
|
|
771
|
-
a = o.getFloat32(e, !0);
|
|
772
|
-
break;
|
|
773
|
-
case 7:
|
|
774
|
-
a = o.getFloat64(e, !0);
|
|
775
|
-
break;
|
|
776
|
-
default:
|
|
777
|
-
throw "the decoder does not understand this pixel type";
|
|
778
|
-
}
|
|
779
|
-
return a;
|
|
780
|
-
},
|
|
781
|
-
swapDimensionOrder: function(t, e, r, o, a) {
|
|
782
|
-
var i = 0, m = 0, n = 0, f = 0, v = t;
|
|
783
|
-
if (r > 1)
|
|
784
|
-
if (v = new o(e * r), a)
|
|
785
|
-
for (i = 0; i < e; i++)
|
|
786
|
-
for (f = i, n = 0; n < r; n++, f += e)
|
|
787
|
-
v[f] = t[m++];
|
|
788
|
-
else
|
|
789
|
-
for (i = 0; i < e; i++)
|
|
790
|
-
for (f = i, n = 0; n < r; n++, f += e)
|
|
791
|
-
v[m++] = t[f];
|
|
792
|
-
return v;
|
|
793
|
-
}
|
|
794
|
-
}, X = function(t, e, r) {
|
|
795
|
-
this.val = t, this.left = e, this.right = r;
|
|
796
|
-
}, H = {
|
|
797
|
-
/*
|
|
798
|
-
* ********removed options compared to LERC1. We can bring some of them back if needed.
|
|
799
|
-
* removed pixel type. LERC2 is typed and doesn't require user to give pixel type
|
|
800
|
-
* changed encodedMaskData to maskData. LERC2 's js version make it faster to use maskData directly.
|
|
801
|
-
* removed returnMask. mask is used by LERC2 internally and is cost free. In case of user input mask, it's returned as well and has neglible cost.
|
|
802
|
-
* removed nodatavalue. Because LERC2 pixels are typed, nodatavalue will sacrify a useful value for many types (8bit, 16bit) etc,
|
|
803
|
-
* user has to be knowledgable enough about raster and their data to avoid usability issues. so nodata value is simply removed now.
|
|
804
|
-
* We can add it back later if their's a clear requirement.
|
|
805
|
-
* removed encodedMask. This option was not implemented in LercDecode. It can be done after decoding (less efficient)
|
|
806
|
-
* removed computeUsedBitDepths.
|
|
807
|
-
*
|
|
808
|
-
*
|
|
809
|
-
* response changes compared to LERC1
|
|
810
|
-
* 1. encodedMaskData is not available
|
|
811
|
-
* 2. noDataValue is optional (returns only if user's noDataValue is with in the valid data type range)
|
|
812
|
-
* 3. maskData is always available
|
|
813
|
-
*/
|
|
814
|
-
/*****************
|
|
815
|
-
* public properties
|
|
816
|
-
******************/
|
|
817
|
-
//HUFFMAN_LUT_BITS_MAX: 12, //use 2^12 lut, not configurable
|
|
818
|
-
/*****************
|
|
819
|
-
* public methods
|
|
820
|
-
*****************/
|
|
821
|
-
/**
|
|
822
|
-
* Decode a LERC2 byte stream and return an object containing the pixel data and optional metadata.
|
|
823
|
-
*
|
|
824
|
-
* @param {ArrayBuffer} input The LERC input byte stream
|
|
825
|
-
* @param {object} [options] options Decoding options
|
|
826
|
-
* @param {number} [options.inputOffset] The number of bytes to skip in the input byte stream. A valid LERC file is expected at that position
|
|
827
|
-
* @param {boolean} [options.returnFileInfo] If true, the return value will have a fileInfo property that contains metadata obtained from the LERC headers and the decoding process
|
|
828
|
-
* @param {boolean} [options.returnPixelInterleavedDims] If true, returned dimensions are pixel-interleaved, a.k.a [p1_dim0, p1_dim1, p1_dimn, p2_dim0...], default is [p1_dim0, p2_dim0, ..., p1_dim1, p2_dim1...]
|
|
829
|
-
*/
|
|
830
|
-
decode: function(t, e) {
|
|
831
|
-
e = e || {};
|
|
832
|
-
var r = e.noDataValue, o = 0, a = {};
|
|
833
|
-
if (a.ptr = e.inputOffset || 0, a.pixels = {}, !!A.readHeaderInfo(t, a)) {
|
|
834
|
-
var i = a.headerInfo, m = i.fileVersion, n = A.getDataTypeArray(i.imageType);
|
|
835
|
-
if (m > 5)
|
|
836
|
-
throw "unsupported lerc version 2." + m;
|
|
837
|
-
A.readMask(t, a), i.numValidPixel !== i.width * i.height && !a.pixels.resultMask && (a.pixels.resultMask = e.maskData);
|
|
838
|
-
var f = i.width * i.height;
|
|
839
|
-
a.pixels.resultPixels = new n(f * i.numDims), a.counter = {
|
|
840
|
-
onesweep: 0,
|
|
841
|
-
uncompressed: 0,
|
|
842
|
-
lut: 0,
|
|
843
|
-
bitstuffer: 0,
|
|
844
|
-
constant: 0,
|
|
845
|
-
constantoffset: 0
|
|
846
|
-
};
|
|
847
|
-
var v = !e.returnPixelInterleavedDims;
|
|
848
|
-
if (i.numValidPixel !== 0)
|
|
849
|
-
if (i.zMax === i.zMin)
|
|
850
|
-
A.constructConstantSurface(a, v);
|
|
851
|
-
else if (m >= 4 && A.checkMinMaxRanges(t, a))
|
|
852
|
-
A.constructConstantSurface(a, v);
|
|
853
|
-
else {
|
|
854
|
-
var u = new DataView(t, a.ptr, 2), h = u.getUint8(0);
|
|
855
|
-
if (a.ptr++, h)
|
|
856
|
-
A.readDataOneSweep(t, a, n, v);
|
|
857
|
-
else if (m > 1 && i.imageType <= 1 && Math.abs(i.maxZError - 0.5) < 1e-5) {
|
|
858
|
-
var g = u.getUint8(1);
|
|
859
|
-
if (a.ptr++, a.encodeMode = g, g > 2 || m < 4 && g > 1)
|
|
860
|
-
throw "Invalid Huffman flag " + g;
|
|
861
|
-
g ? A.readHuffman(t, a, n, v) : A.readTiles(t, a, n, v);
|
|
862
|
-
} else
|
|
863
|
-
A.readTiles(t, a, n, v);
|
|
864
|
-
}
|
|
865
|
-
a.eofOffset = a.ptr;
|
|
866
|
-
var l;
|
|
867
|
-
e.inputOffset ? (l = a.headerInfo.blobSize + e.inputOffset - a.ptr, Math.abs(l) >= 1 && (a.eofOffset = e.inputOffset + a.headerInfo.blobSize)) : (l = a.headerInfo.blobSize - a.ptr, Math.abs(l) >= 1 && (a.eofOffset = a.headerInfo.blobSize));
|
|
868
|
-
var s = {
|
|
869
|
-
width: i.width,
|
|
870
|
-
height: i.height,
|
|
871
|
-
pixelData: a.pixels.resultPixels,
|
|
872
|
-
minValue: i.zMin,
|
|
873
|
-
maxValue: i.zMax,
|
|
874
|
-
validPixelCount: i.numValidPixel,
|
|
875
|
-
dimCount: i.numDims,
|
|
876
|
-
dimStats: {
|
|
877
|
-
minValues: i.minValues,
|
|
878
|
-
maxValues: i.maxValues
|
|
879
|
-
},
|
|
880
|
-
maskData: a.pixels.resultMask
|
|
881
|
-
//noDataValue: noDataValue
|
|
882
|
-
};
|
|
883
|
-
if (a.pixels.resultMask && A.isValidPixelValue(i.imageType, r)) {
|
|
884
|
-
var w = a.pixels.resultMask;
|
|
885
|
-
for (o = 0; o < f; o++)
|
|
886
|
-
w[o] || (s.pixelData[o] = r);
|
|
887
|
-
s.noDataValue = r;
|
|
888
|
-
}
|
|
889
|
-
return a.noDataValue = r, e.returnFileInfo && (s.fileInfo = A.formatFileInfo(a)), s;
|
|
890
|
-
}
|
|
891
|
-
},
|
|
892
|
-
getBandCount: function(t) {
|
|
893
|
-
var e = 0, r = 0, o = {};
|
|
894
|
-
for (o.ptr = 0, o.pixels = {}; r < t.byteLength - 58; )
|
|
895
|
-
A.readHeaderInfo(t, o), r += o.headerInfo.blobSize, e++, o.ptr = r;
|
|
896
|
-
return e;
|
|
897
|
-
}
|
|
898
|
-
};
|
|
899
|
-
return H;
|
|
900
|
-
}(), P = function() {
|
|
901
|
-
var F = new ArrayBuffer(4), A = new Uint8Array(F), X = new Uint32Array(F);
|
|
902
|
-
return X[0] = 1, A[0] === 1;
|
|
903
|
-
}(), ee = {
|
|
904
|
-
/************wrapper**********************************************/
|
|
905
|
-
/**
|
|
906
|
-
* A wrapper for decoding both LERC1 and LERC2 byte streams capable of handling multiband pixel blocks for various pixel types.
|
|
907
|
-
*
|
|
908
|
-
* @alias module:Lerc
|
|
909
|
-
* @param {ArrayBuffer} input The LERC input byte stream
|
|
910
|
-
* @param {object} [options] The decoding options below are optional.
|
|
911
|
-
* @param {number} [options.inputOffset] The number of bytes to skip in the input byte stream. A valid Lerc file is expected at that position.
|
|
912
|
-
* @param {string} [options.pixelType] (LERC1 only) Default value is F32. Valid pixel types for input are U8/S8/S16/U16/S32/U32/F32.
|
|
913
|
-
* @param {number} [options.noDataValue] (LERC1 only). It is recommended to use the returned mask instead of setting this value.
|
|
914
|
-
* @param {boolean} [options.returnPixelInterleavedDims] (nDim LERC2 only) If true, returned dimensions are pixel-interleaved, a.k.a [p1_dim0, p1_dim1, p1_dimn, p2_dim0...], default is [p1_dim0, p2_dim0, ..., p1_dim1, p2_dim1...]
|
|
915
|
-
* @returns {{width, height, pixels, pixelType, mask, statistics}}
|
|
916
|
-
* @property {number} width Width of decoded image.
|
|
917
|
-
* @property {number} height Height of decoded image.
|
|
918
|
-
* @property {array} pixels [band1, band2, …] Each band is a typed array of width*height.
|
|
919
|
-
* @property {string} pixelType The type of pixels represented in the output.
|
|
920
|
-
* @property {mask} mask Typed array with a size of width*height, or null if all pixels are valid.
|
|
921
|
-
* @property {array} statistics [statistics_band1, statistics_band2, …] Each element is a statistics object representing min and max values
|
|
922
|
-
**/
|
|
923
|
-
decode: function(F, A) {
|
|
924
|
-
if (!P)
|
|
925
|
-
throw "Big endian system is not supported.";
|
|
926
|
-
A = A || {};
|
|
927
|
-
var X = A.inputOffset || 0, H = new Uint8Array(F, X, 10), t = String.fromCharCode.apply(null, H), e, r;
|
|
928
|
-
if (t.trim() === "CntZImage")
|
|
929
|
-
e = Y, r = 1;
|
|
930
|
-
else if (t.substring(0, 5) === "Lerc2")
|
|
931
|
-
e = W, r = 2;
|
|
932
|
-
else
|
|
933
|
-
throw "Unexpected file identifier string: " + t;
|
|
934
|
-
for (var o = 0, a = F.byteLength - 10, i, m = [], n, f, v = {
|
|
935
|
-
width: 0,
|
|
936
|
-
height: 0,
|
|
937
|
-
pixels: [],
|
|
938
|
-
pixelType: A.pixelType,
|
|
939
|
-
mask: null,
|
|
940
|
-
statistics: []
|
|
941
|
-
}, u = 0; X < a; ) {
|
|
942
|
-
var h = e.decode(F, {
|
|
943
|
-
inputOffset: X,
|
|
944
|
-
//for both lerc1 and lerc2
|
|
945
|
-
encodedMaskData: i,
|
|
946
|
-
//lerc1 only
|
|
947
|
-
maskData: f,
|
|
948
|
-
//lerc2 only
|
|
949
|
-
returnMask: o === 0,
|
|
950
|
-
//lerc1 only
|
|
951
|
-
returnEncodedMask: o === 0,
|
|
952
|
-
//lerc1 only
|
|
953
|
-
returnFileInfo: !0,
|
|
954
|
-
//for both lerc1 and lerc2
|
|
955
|
-
returnPixelInterleavedDims: A.returnPixelInterleavedDims,
|
|
956
|
-
//for ndim lerc2 only
|
|
957
|
-
pixelType: A.pixelType || null,
|
|
958
|
-
//lerc1 only
|
|
959
|
-
noDataValue: A.noDataValue || null
|
|
960
|
-
//lerc1 only
|
|
961
|
-
});
|
|
962
|
-
X = h.fileInfo.eofOffset, f = h.maskData, o === 0 && (i = h.encodedMaskData, v.width = h.width, v.height = h.height, v.dimCount = h.dimCount || 1, v.pixelType = h.pixelType || h.fileInfo.pixelType, v.mask = f), r > 1 && (f && m.push(f), h.fileInfo.mask && h.fileInfo.mask.numBytes > 0 && u++), o++, v.pixels.push(h.pixelData), v.statistics.push({
|
|
963
|
-
minValue: h.minValue,
|
|
964
|
-
maxValue: h.maxValue,
|
|
965
|
-
noDataValue: h.noDataValue,
|
|
966
|
-
dimStats: h.dimStats
|
|
967
|
-
});
|
|
968
|
-
}
|
|
969
|
-
var g, l, s;
|
|
970
|
-
if (r > 1 && u > 1) {
|
|
971
|
-
for (s = v.width * v.height, v.bandMasks = m, f = new Uint8Array(s), f.set(m[0]), g = 1; g < m.length; g++)
|
|
972
|
-
for (n = m[g], l = 0; l < s; l++)
|
|
973
|
-
f[l] = f[l] & n[l];
|
|
974
|
-
v.maskData = f;
|
|
975
|
-
}
|
|
976
|
-
return v;
|
|
977
|
-
}
|
|
978
|
-
};
|
|
979
|
-
$.exports ? $.exports = ee : this.Lerc = ee;
|
|
980
|
-
})();
|
|
981
|
-
}(K)), K.exports;
|
|
982
|
-
}
|
|
983
|
-
var he = ve();
|
|
984
|
-
const me = /* @__PURE__ */ le(he);
|
|
985
|
-
class we extends oe {
|
|
986
|
-
constructor(Y) {
|
|
987
|
-
super(), this.planarConfiguration = typeof Y.PlanarConfiguration < "u" ? Y.PlanarConfiguration : 1, this.samplesPerPixel = typeof Y.SamplesPerPixel < "u" ? Y.SamplesPerPixel : 1, this.addCompression = Y.LercParameters[ue.AddCompression];
|
|
988
|
-
}
|
|
989
|
-
decodeBlock(Y) {
|
|
990
|
-
switch (this.addCompression) {
|
|
991
|
-
case ie.None:
|
|
992
|
-
break;
|
|
993
|
-
case ie.Deflate:
|
|
994
|
-
Y = se(new Uint8Array(Y)).buffer;
|
|
995
|
-
break;
|
|
996
|
-
default:
|
|
997
|
-
throw new Error(`Unsupported LERC additional compression method identifier: ${this.addCompression}`);
|
|
998
|
-
}
|
|
999
|
-
return me.decode(Y, { returnPixelInterleavedDims: this.planarConfiguration === 1 }).pixels[0].buffer;
|
|
1000
|
-
}
|
|
1001
|
-
}
|
|
1002
|
-
export {
|
|
1003
|
-
we as default
|
|
1004
|
-
};
|