@vitessce/all 2.0.3-beta.0 → 3.0.0

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.
Files changed (45) hide show
  1. package/dist/deflate-f57b3163.js +13 -0
  2. package/dist/hglib-1422f224.js +138925 -0
  3. package/dist/index-3f1c1764.js +258272 -0
  4. package/dist/index.js +12 -2
  5. package/dist/jpeg-e740c9a5.js +840 -0
  6. package/dist/lerc-01e6c4d8.js +2006 -0
  7. package/dist/lzw-865bd058.js +128 -0
  8. package/dist/packbits-d4191efd.js +30 -0
  9. package/dist/pako.esm-68f84e2a.js +4022 -0
  10. package/dist/raw-3c693341.js +12 -0
  11. package/dist/webimage-83da2258.js +32 -0
  12. package/dist-tsc/Vitessce.d.ts +2 -0
  13. package/dist-tsc/Vitessce.d.ts.map +1 -0
  14. package/dist-tsc/Vitessce.js +41 -0
  15. package/dist-tsc/base-plugins.d.ts +854 -0
  16. package/dist-tsc/base-plugins.d.ts.map +1 -0
  17. package/dist-tsc/base-plugins.js +191 -0
  18. package/dist-tsc/index.d.ts +4 -0
  19. package/dist-tsc/index.d.ts.map +1 -0
  20. package/dist-tsc/index.js +3 -0
  21. package/dist-tsc/joint-file-types-legacy.d.ts +226 -0
  22. package/dist-tsc/joint-file-types-legacy.d.ts.map +1 -0
  23. package/dist-tsc/joint-file-types-legacy.js +266 -0
  24. package/dist-tsc/joint-file-types-legacy.test.d.ts +2 -0
  25. package/dist-tsc/joint-file-types-legacy.test.d.ts.map +1 -0
  26. package/dist-tsc/joint-file-types-legacy.test.js +401 -0
  27. package/dist-tsc/joint-file-types.d.ts +4 -0
  28. package/dist-tsc/joint-file-types.d.ts.map +1 -0
  29. package/dist-tsc/joint-file-types.js +127 -0
  30. package/dist-tsc/joint-file-types.test.d.ts +2 -0
  31. package/dist-tsc/joint-file-types.test.d.ts.map +1 -0
  32. package/dist-tsc/joint-file-types.test.js +128 -0
  33. package/dist-tsc/latest-config-schema.test.d.ts +2 -0
  34. package/dist-tsc/latest-config-schema.test.d.ts.map +1 -0
  35. package/dist-tsc/latest-config-schema.test.js +19 -0
  36. package/package.json +39 -21
  37. package/src/Vitessce.tsx +74 -0
  38. package/src/base-plugins.ts +362 -0
  39. package/src/index.ts +8 -0
  40. package/src/joint-file-types-legacy.test.ts +413 -0
  41. package/src/joint-file-types-legacy.ts +284 -0
  42. package/src/joint-file-types.test.ts +132 -0
  43. package/src/joint-file-types.ts +142 -0
  44. package/src/latest-config-schema.test.ts +26 -0
  45. package/dist/setup.js +0 -96
@@ -0,0 +1,2006 @@
1
+ import { i as inflate_1 } from "./pako.esm-68f84e2a.js";
2
+ import { g as getDefaultExportFromCjs, B as BaseDecoder, L as LercParameters, a as LercAddCompression } from "./index-3f1c1764.js";
3
+ import "react";
4
+ import "@vitessce/vit-s";
5
+ import "react-dom";
6
+ var LercDecode = { exports: {} };
7
+ (function(module) {
8
+ /* 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 */
9
+ (function() {
10
+ var LercDecode2 = function() {
11
+ var CntZImage = {};
12
+ CntZImage.defaultNoDataValue = -34027999387901484e22;
13
+ CntZImage.decode = function(input, options) {
14
+ options = options || {};
15
+ var skipMask = options.encodedMaskData || options.encodedMaskData === null;
16
+ var parsedData = parse(input, options.inputOffset || 0, skipMask);
17
+ var noDataValue = options.noDataValue !== null ? options.noDataValue : CntZImage.defaultNoDataValue;
18
+ var uncompressedData = uncompressPixelValues(
19
+ parsedData,
20
+ options.pixelType || Float32Array,
21
+ options.encodedMaskData,
22
+ noDataValue,
23
+ options.returnMask
24
+ );
25
+ var result = {
26
+ width: parsedData.width,
27
+ height: parsedData.height,
28
+ pixelData: uncompressedData.resultPixels,
29
+ minValue: uncompressedData.minValue,
30
+ maxValue: parsedData.pixels.maxValue,
31
+ noDataValue
32
+ };
33
+ if (uncompressedData.resultMask) {
34
+ result.maskData = uncompressedData.resultMask;
35
+ }
36
+ if (options.returnEncodedMask && parsedData.mask) {
37
+ result.encodedMaskData = parsedData.mask.bitset ? parsedData.mask.bitset : null;
38
+ }
39
+ if (options.returnFileInfo) {
40
+ result.fileInfo = formatFileInfo(parsedData);
41
+ if (options.computeUsedBitDepths) {
42
+ result.fileInfo.bitDepths = computeUsedBitDepths(parsedData);
43
+ }
44
+ }
45
+ return result;
46
+ };
47
+ var uncompressPixelValues = function(data, TypedArrayClass, maskBitset, noDataValue, storeDecodedMask) {
48
+ var blockIdx = 0;
49
+ var numX = data.pixels.numBlocksX;
50
+ var numY = data.pixels.numBlocksY;
51
+ var blockWidth = Math.floor(data.width / numX);
52
+ var blockHeight = Math.floor(data.height / numY);
53
+ var scale = 2 * data.maxZError;
54
+ var minValue = Number.MAX_VALUE, currentValue;
55
+ maskBitset = maskBitset || (data.mask ? data.mask.bitset : null);
56
+ var resultPixels, resultMask;
57
+ resultPixels = new TypedArrayClass(data.width * data.height);
58
+ if (storeDecodedMask && maskBitset) {
59
+ resultMask = new Uint8Array(data.width * data.height);
60
+ }
61
+ var blockDataBuffer = new Float32Array(blockWidth * blockHeight);
62
+ var xx, yy;
63
+ for (var y = 0; y <= numY; y++) {
64
+ var thisBlockHeight = y !== numY ? blockHeight : data.height % numY;
65
+ if (thisBlockHeight === 0) {
66
+ continue;
67
+ }
68
+ for (var x = 0; x <= numX; x++) {
69
+ var thisBlockWidth = x !== numX ? blockWidth : data.width % numX;
70
+ if (thisBlockWidth === 0) {
71
+ continue;
72
+ }
73
+ var outPtr = y * data.width * blockHeight + x * blockWidth;
74
+ var outStride = data.width - thisBlockWidth;
75
+ var block = data.pixels.blocks[blockIdx];
76
+ var blockData, blockPtr, constValue;
77
+ if (block.encoding < 2) {
78
+ if (block.encoding === 0) {
79
+ blockData = block.rawData;
80
+ } else {
81
+ unstuff(block.stuffedData, block.bitsPerPixel, block.numValidPixels, block.offset, scale, blockDataBuffer, data.pixels.maxValue);
82
+ blockData = blockDataBuffer;
83
+ }
84
+ blockPtr = 0;
85
+ } else if (block.encoding === 2) {
86
+ constValue = 0;
87
+ } else {
88
+ constValue = block.offset;
89
+ }
90
+ var maskByte;
91
+ if (maskBitset) {
92
+ for (yy = 0; yy < thisBlockHeight; yy++) {
93
+ if (outPtr & 7) {
94
+ maskByte = maskBitset[outPtr >> 3];
95
+ maskByte <<= outPtr & 7;
96
+ }
97
+ for (xx = 0; xx < thisBlockWidth; xx++) {
98
+ if (!(outPtr & 7)) {
99
+ maskByte = maskBitset[outPtr >> 3];
100
+ }
101
+ if (maskByte & 128) {
102
+ if (resultMask) {
103
+ resultMask[outPtr] = 1;
104
+ }
105
+ currentValue = block.encoding < 2 ? blockData[blockPtr++] : constValue;
106
+ minValue = minValue > currentValue ? currentValue : minValue;
107
+ resultPixels[outPtr++] = currentValue;
108
+ } else {
109
+ if (resultMask) {
110
+ resultMask[outPtr] = 0;
111
+ }
112
+ resultPixels[outPtr++] = noDataValue;
113
+ }
114
+ maskByte <<= 1;
115
+ }
116
+ outPtr += outStride;
117
+ }
118
+ } else {
119
+ if (block.encoding < 2) {
120
+ for (yy = 0; yy < thisBlockHeight; yy++) {
121
+ for (xx = 0; xx < thisBlockWidth; xx++) {
122
+ currentValue = blockData[blockPtr++];
123
+ minValue = minValue > currentValue ? currentValue : minValue;
124
+ resultPixels[outPtr++] = currentValue;
125
+ }
126
+ outPtr += outStride;
127
+ }
128
+ } else {
129
+ minValue = minValue > constValue ? constValue : minValue;
130
+ for (yy = 0; yy < thisBlockHeight; yy++) {
131
+ for (xx = 0; xx < thisBlockWidth; xx++) {
132
+ resultPixels[outPtr++] = constValue;
133
+ }
134
+ outPtr += outStride;
135
+ }
136
+ }
137
+ }
138
+ if (block.encoding === 1 && blockPtr !== block.numValidPixels) {
139
+ throw "Block and Mask do not match";
140
+ }
141
+ blockIdx++;
142
+ }
143
+ }
144
+ return {
145
+ resultPixels,
146
+ resultMask,
147
+ minValue
148
+ };
149
+ };
150
+ var formatFileInfo = function(data) {
151
+ return {
152
+ "fileIdentifierString": data.fileIdentifierString,
153
+ "fileVersion": data.fileVersion,
154
+ "imageType": data.imageType,
155
+ "height": data.height,
156
+ "width": data.width,
157
+ "maxZError": data.maxZError,
158
+ "eofOffset": data.eofOffset,
159
+ "mask": data.mask ? {
160
+ "numBlocksX": data.mask.numBlocksX,
161
+ "numBlocksY": data.mask.numBlocksY,
162
+ "numBytes": data.mask.numBytes,
163
+ "maxValue": data.mask.maxValue
164
+ } : null,
165
+ "pixels": {
166
+ "numBlocksX": data.pixels.numBlocksX,
167
+ "numBlocksY": data.pixels.numBlocksY,
168
+ "numBytes": data.pixels.numBytes,
169
+ "maxValue": data.pixels.maxValue,
170
+ "noDataValue": data.noDataValue
171
+ }
172
+ };
173
+ };
174
+ var computeUsedBitDepths = function(data) {
175
+ var numBlocks = data.pixels.numBlocksX * data.pixels.numBlocksY;
176
+ var bitDepths = {};
177
+ for (var i = 0; i < numBlocks; i++) {
178
+ var block = data.pixels.blocks[i];
179
+ if (block.encoding === 0) {
180
+ bitDepths.float32 = true;
181
+ } else if (block.encoding === 1) {
182
+ bitDepths[block.bitsPerPixel] = true;
183
+ } else {
184
+ bitDepths[0] = true;
185
+ }
186
+ }
187
+ return Object.keys(bitDepths);
188
+ };
189
+ var parse = function(input, fp, skipMask) {
190
+ var data = {};
191
+ var fileIdView = new Uint8Array(input, fp, 10);
192
+ data.fileIdentifierString = String.fromCharCode.apply(null, fileIdView);
193
+ if (data.fileIdentifierString.trim() !== "CntZImage") {
194
+ throw "Unexpected file identifier string: " + data.fileIdentifierString;
195
+ }
196
+ fp += 10;
197
+ var view = new DataView(input, fp, 24);
198
+ data.fileVersion = view.getInt32(0, true);
199
+ data.imageType = view.getInt32(4, true);
200
+ data.height = view.getUint32(8, true);
201
+ data.width = view.getUint32(12, true);
202
+ data.maxZError = view.getFloat64(16, true);
203
+ fp += 24;
204
+ if (!skipMask) {
205
+ view = new DataView(input, fp, 16);
206
+ data.mask = {};
207
+ data.mask.numBlocksY = view.getUint32(0, true);
208
+ data.mask.numBlocksX = view.getUint32(4, true);
209
+ data.mask.numBytes = view.getUint32(8, true);
210
+ data.mask.maxValue = view.getFloat32(12, true);
211
+ fp += 16;
212
+ if (data.mask.numBytes > 0) {
213
+ var bitset = new Uint8Array(Math.ceil(data.width * data.height / 8));
214
+ view = new DataView(input, fp, data.mask.numBytes);
215
+ var cnt = view.getInt16(0, true);
216
+ var ip = 2, op = 0;
217
+ do {
218
+ if (cnt > 0) {
219
+ while (cnt--) {
220
+ bitset[op++] = view.getUint8(ip++);
221
+ }
222
+ } else {
223
+ var val = view.getUint8(ip++);
224
+ cnt = -cnt;
225
+ while (cnt--) {
226
+ bitset[op++] = val;
227
+ }
228
+ }
229
+ cnt = view.getInt16(ip, true);
230
+ ip += 2;
231
+ } while (ip < data.mask.numBytes);
232
+ if (cnt !== -32768 || op < bitset.length) {
233
+ throw "Unexpected end of mask RLE encoding";
234
+ }
235
+ data.mask.bitset = bitset;
236
+ fp += data.mask.numBytes;
237
+ } else if ((data.mask.numBytes | data.mask.numBlocksY | data.mask.maxValue) === 0) {
238
+ data.mask.bitset = new Uint8Array(Math.ceil(data.width * data.height / 8));
239
+ }
240
+ }
241
+ view = new DataView(input, fp, 16);
242
+ data.pixels = {};
243
+ data.pixels.numBlocksY = view.getUint32(0, true);
244
+ data.pixels.numBlocksX = view.getUint32(4, true);
245
+ data.pixels.numBytes = view.getUint32(8, true);
246
+ data.pixels.maxValue = view.getFloat32(12, true);
247
+ fp += 16;
248
+ var numBlocksX = data.pixels.numBlocksX;
249
+ var numBlocksY = data.pixels.numBlocksY;
250
+ var actualNumBlocksX = numBlocksX + (data.width % numBlocksX > 0 ? 1 : 0);
251
+ var actualNumBlocksY = numBlocksY + (data.height % numBlocksY > 0 ? 1 : 0);
252
+ data.pixels.blocks = new Array(actualNumBlocksX * actualNumBlocksY);
253
+ var blockI = 0;
254
+ for (var blockY = 0; blockY < actualNumBlocksY; blockY++) {
255
+ for (var blockX = 0; blockX < actualNumBlocksX; blockX++) {
256
+ var size = 0;
257
+ var bytesLeft = input.byteLength - fp;
258
+ view = new DataView(input, fp, Math.min(10, bytesLeft));
259
+ var block = {};
260
+ data.pixels.blocks[blockI++] = block;
261
+ var headerByte = view.getUint8(0);
262
+ size++;
263
+ block.encoding = headerByte & 63;
264
+ if (block.encoding > 3) {
265
+ throw "Invalid block encoding (" + block.encoding + ")";
266
+ }
267
+ if (block.encoding === 2) {
268
+ fp++;
269
+ continue;
270
+ }
271
+ if (headerByte !== 0 && headerByte !== 2) {
272
+ headerByte >>= 6;
273
+ block.offsetType = headerByte;
274
+ if (headerByte === 2) {
275
+ block.offset = view.getInt8(1);
276
+ size++;
277
+ } else if (headerByte === 1) {
278
+ block.offset = view.getInt16(1, true);
279
+ size += 2;
280
+ } else if (headerByte === 0) {
281
+ block.offset = view.getFloat32(1, true);
282
+ size += 4;
283
+ } else {
284
+ throw "Invalid block offset type";
285
+ }
286
+ if (block.encoding === 1) {
287
+ headerByte = view.getUint8(size);
288
+ size++;
289
+ block.bitsPerPixel = headerByte & 63;
290
+ headerByte >>= 6;
291
+ block.numValidPixelsType = headerByte;
292
+ if (headerByte === 2) {
293
+ block.numValidPixels = view.getUint8(size);
294
+ size++;
295
+ } else if (headerByte === 1) {
296
+ block.numValidPixels = view.getUint16(size, true);
297
+ size += 2;
298
+ } else if (headerByte === 0) {
299
+ block.numValidPixels = view.getUint32(size, true);
300
+ size += 4;
301
+ } else {
302
+ throw "Invalid valid pixel count type";
303
+ }
304
+ }
305
+ }
306
+ fp += size;
307
+ if (block.encoding === 3) {
308
+ continue;
309
+ }
310
+ var arrayBuf, store8;
311
+ if (block.encoding === 0) {
312
+ var numPixels = (data.pixels.numBytes - 1) / 4;
313
+ if (numPixels !== Math.floor(numPixels)) {
314
+ throw "uncompressed block has invalid length";
315
+ }
316
+ arrayBuf = new ArrayBuffer(numPixels * 4);
317
+ store8 = new Uint8Array(arrayBuf);
318
+ store8.set(new Uint8Array(input, fp, numPixels * 4));
319
+ var rawData = new Float32Array(arrayBuf);
320
+ block.rawData = rawData;
321
+ fp += numPixels * 4;
322
+ } else if (block.encoding === 1) {
323
+ var dataBytes = Math.ceil(block.numValidPixels * block.bitsPerPixel / 8);
324
+ var dataWords = Math.ceil(dataBytes / 4);
325
+ arrayBuf = new ArrayBuffer(dataWords * 4);
326
+ store8 = new Uint8Array(arrayBuf);
327
+ store8.set(new Uint8Array(input, fp, dataBytes));
328
+ block.stuffedData = new Uint32Array(arrayBuf);
329
+ fp += dataBytes;
330
+ }
331
+ }
332
+ }
333
+ data.eofOffset = fp;
334
+ return data;
335
+ };
336
+ var unstuff = function(src, bitsPerPixel, numPixels, offset, scale, dest, maxValue) {
337
+ var bitMask = (1 << bitsPerPixel) - 1;
338
+ var i = 0, o;
339
+ var bitsLeft = 0;
340
+ var n, buffer;
341
+ var nmax = Math.ceil((maxValue - offset) / scale);
342
+ var numInvalidTailBytes = src.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8);
343
+ src[src.length - 1] <<= 8 * numInvalidTailBytes;
344
+ for (o = 0; o < numPixels; o++) {
345
+ if (bitsLeft === 0) {
346
+ buffer = src[i++];
347
+ bitsLeft = 32;
348
+ }
349
+ if (bitsLeft >= bitsPerPixel) {
350
+ n = buffer >>> bitsLeft - bitsPerPixel & bitMask;
351
+ bitsLeft -= bitsPerPixel;
352
+ } else {
353
+ var missingBits = bitsPerPixel - bitsLeft;
354
+ n = (buffer & bitMask) << missingBits & bitMask;
355
+ buffer = src[i++];
356
+ bitsLeft = 32 - missingBits;
357
+ n += buffer >>> bitsLeft;
358
+ }
359
+ dest[o] = n < nmax ? offset + n * scale : maxValue;
360
+ }
361
+ return dest;
362
+ };
363
+ return CntZImage;
364
+ }();
365
+ var Lerc2Decode = function() {
366
+ var BitStuffer = {
367
+ //methods ending with 2 are for the new byte order used by Lerc2.3 and above.
368
+ //originalUnstuff is used to unpack Huffman code table. code is duplicated to unstuffx for performance reasons.
369
+ unstuff: function(src, dest, bitsPerPixel, numPixels, lutArr, offset, scale, maxValue) {
370
+ var bitMask = (1 << bitsPerPixel) - 1;
371
+ var i = 0, o;
372
+ var bitsLeft = 0;
373
+ var n, buffer, missingBits, nmax;
374
+ var numInvalidTailBytes = src.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8);
375
+ src[src.length - 1] <<= 8 * numInvalidTailBytes;
376
+ if (lutArr) {
377
+ for (o = 0; o < numPixels; o++) {
378
+ if (bitsLeft === 0) {
379
+ buffer = src[i++];
380
+ bitsLeft = 32;
381
+ }
382
+ if (bitsLeft >= bitsPerPixel) {
383
+ n = buffer >>> bitsLeft - bitsPerPixel & bitMask;
384
+ bitsLeft -= bitsPerPixel;
385
+ } else {
386
+ missingBits = bitsPerPixel - bitsLeft;
387
+ n = (buffer & bitMask) << missingBits & bitMask;
388
+ buffer = src[i++];
389
+ bitsLeft = 32 - missingBits;
390
+ n += buffer >>> bitsLeft;
391
+ }
392
+ dest[o] = lutArr[n];
393
+ }
394
+ } else {
395
+ nmax = Math.ceil((maxValue - offset) / scale);
396
+ for (o = 0; o < numPixels; o++) {
397
+ if (bitsLeft === 0) {
398
+ buffer = src[i++];
399
+ bitsLeft = 32;
400
+ }
401
+ if (bitsLeft >= bitsPerPixel) {
402
+ n = buffer >>> bitsLeft - bitsPerPixel & bitMask;
403
+ bitsLeft -= bitsPerPixel;
404
+ } else {
405
+ missingBits = bitsPerPixel - bitsLeft;
406
+ n = (buffer & bitMask) << missingBits & bitMask;
407
+ buffer = src[i++];
408
+ bitsLeft = 32 - missingBits;
409
+ n += buffer >>> bitsLeft;
410
+ }
411
+ dest[o] = n < nmax ? offset + n * scale : maxValue;
412
+ }
413
+ }
414
+ },
415
+ unstuffLUT: function(src, bitsPerPixel, numPixels, offset, scale, maxValue) {
416
+ var bitMask = (1 << bitsPerPixel) - 1;
417
+ var i = 0, o = 0, missingBits = 0, bitsLeft = 0, n = 0;
418
+ var buffer;
419
+ var dest = [];
420
+ var numInvalidTailBytes = src.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8);
421
+ src[src.length - 1] <<= 8 * numInvalidTailBytes;
422
+ var nmax = Math.ceil((maxValue - offset) / scale);
423
+ for (o = 0; o < numPixels; o++) {
424
+ if (bitsLeft === 0) {
425
+ buffer = src[i++];
426
+ bitsLeft = 32;
427
+ }
428
+ if (bitsLeft >= bitsPerPixel) {
429
+ n = buffer >>> bitsLeft - bitsPerPixel & bitMask;
430
+ bitsLeft -= bitsPerPixel;
431
+ } else {
432
+ missingBits = bitsPerPixel - bitsLeft;
433
+ n = (buffer & bitMask) << missingBits & bitMask;
434
+ buffer = src[i++];
435
+ bitsLeft = 32 - missingBits;
436
+ n += buffer >>> bitsLeft;
437
+ }
438
+ dest[o] = n < nmax ? offset + n * scale : maxValue;
439
+ }
440
+ dest.unshift(offset);
441
+ return dest;
442
+ },
443
+ unstuff2: function(src, dest, bitsPerPixel, numPixels, lutArr, offset, scale, maxValue) {
444
+ var bitMask = (1 << bitsPerPixel) - 1;
445
+ var i = 0, o;
446
+ var bitsLeft = 0, bitPos = 0;
447
+ var n, buffer, missingBits;
448
+ if (lutArr) {
449
+ for (o = 0; o < numPixels; o++) {
450
+ if (bitsLeft === 0) {
451
+ buffer = src[i++];
452
+ bitsLeft = 32;
453
+ bitPos = 0;
454
+ }
455
+ if (bitsLeft >= bitsPerPixel) {
456
+ n = buffer >>> bitPos & bitMask;
457
+ bitsLeft -= bitsPerPixel;
458
+ bitPos += bitsPerPixel;
459
+ } else {
460
+ missingBits = bitsPerPixel - bitsLeft;
461
+ n = buffer >>> bitPos & bitMask;
462
+ buffer = src[i++];
463
+ bitsLeft = 32 - missingBits;
464
+ n |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits;
465
+ bitPos = missingBits;
466
+ }
467
+ dest[o] = lutArr[n];
468
+ }
469
+ } else {
470
+ var nmax = Math.ceil((maxValue - offset) / scale);
471
+ for (o = 0; o < numPixels; o++) {
472
+ if (bitsLeft === 0) {
473
+ buffer = src[i++];
474
+ bitsLeft = 32;
475
+ bitPos = 0;
476
+ }
477
+ if (bitsLeft >= bitsPerPixel) {
478
+ n = buffer >>> bitPos & bitMask;
479
+ bitsLeft -= bitsPerPixel;
480
+ bitPos += bitsPerPixel;
481
+ } else {
482
+ missingBits = bitsPerPixel - bitsLeft;
483
+ n = buffer >>> bitPos & bitMask;
484
+ buffer = src[i++];
485
+ bitsLeft = 32 - missingBits;
486
+ n |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits;
487
+ bitPos = missingBits;
488
+ }
489
+ dest[o] = n < nmax ? offset + n * scale : maxValue;
490
+ }
491
+ }
492
+ return dest;
493
+ },
494
+ unstuffLUT2: function(src, bitsPerPixel, numPixels, offset, scale, maxValue) {
495
+ var bitMask = (1 << bitsPerPixel) - 1;
496
+ var i = 0, o = 0, missingBits = 0, bitsLeft = 0, n = 0, bitPos = 0;
497
+ var buffer;
498
+ var dest = [];
499
+ var nmax = Math.ceil((maxValue - offset) / scale);
500
+ for (o = 0; o < numPixels; o++) {
501
+ if (bitsLeft === 0) {
502
+ buffer = src[i++];
503
+ bitsLeft = 32;
504
+ bitPos = 0;
505
+ }
506
+ if (bitsLeft >= bitsPerPixel) {
507
+ n = buffer >>> bitPos & bitMask;
508
+ bitsLeft -= bitsPerPixel;
509
+ bitPos += bitsPerPixel;
510
+ } else {
511
+ missingBits = bitsPerPixel - bitsLeft;
512
+ n = buffer >>> bitPos & bitMask;
513
+ buffer = src[i++];
514
+ bitsLeft = 32 - missingBits;
515
+ n |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits;
516
+ bitPos = missingBits;
517
+ }
518
+ dest[o] = n < nmax ? offset + n * scale : maxValue;
519
+ }
520
+ dest.unshift(offset);
521
+ return dest;
522
+ },
523
+ originalUnstuff: function(src, dest, bitsPerPixel, numPixels) {
524
+ var bitMask = (1 << bitsPerPixel) - 1;
525
+ var i = 0, o;
526
+ var bitsLeft = 0;
527
+ var n, buffer, missingBits;
528
+ var numInvalidTailBytes = src.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8);
529
+ src[src.length - 1] <<= 8 * numInvalidTailBytes;
530
+ for (o = 0; o < numPixels; o++) {
531
+ if (bitsLeft === 0) {
532
+ buffer = src[i++];
533
+ bitsLeft = 32;
534
+ }
535
+ if (bitsLeft >= bitsPerPixel) {
536
+ n = buffer >>> bitsLeft - bitsPerPixel & bitMask;
537
+ bitsLeft -= bitsPerPixel;
538
+ } else {
539
+ missingBits = bitsPerPixel - bitsLeft;
540
+ n = (buffer & bitMask) << missingBits & bitMask;
541
+ buffer = src[i++];
542
+ bitsLeft = 32 - missingBits;
543
+ n += buffer >>> bitsLeft;
544
+ }
545
+ dest[o] = n;
546
+ }
547
+ return dest;
548
+ },
549
+ originalUnstuff2: function(src, dest, bitsPerPixel, numPixels) {
550
+ var bitMask = (1 << bitsPerPixel) - 1;
551
+ var i = 0, o;
552
+ var bitsLeft = 0, bitPos = 0;
553
+ var n, buffer, missingBits;
554
+ for (o = 0; o < numPixels; o++) {
555
+ if (bitsLeft === 0) {
556
+ buffer = src[i++];
557
+ bitsLeft = 32;
558
+ bitPos = 0;
559
+ }
560
+ if (bitsLeft >= bitsPerPixel) {
561
+ n = buffer >>> bitPos & bitMask;
562
+ bitsLeft -= bitsPerPixel;
563
+ bitPos += bitsPerPixel;
564
+ } else {
565
+ missingBits = bitsPerPixel - bitsLeft;
566
+ n = buffer >>> bitPos & bitMask;
567
+ buffer = src[i++];
568
+ bitsLeft = 32 - missingBits;
569
+ n |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits;
570
+ bitPos = missingBits;
571
+ }
572
+ dest[o] = n;
573
+ }
574
+ return dest;
575
+ }
576
+ };
577
+ var Lerc2Helpers = {
578
+ HUFFMAN_LUT_BITS_MAX: 12,
579
+ //use 2^12 lut, treat it like constant
580
+ computeChecksumFletcher32: function(input) {
581
+ var sum1 = 65535, sum2 = 65535;
582
+ var len = input.length;
583
+ var words = Math.floor(len / 2);
584
+ var i = 0;
585
+ while (words) {
586
+ var tlen = words >= 359 ? 359 : words;
587
+ words -= tlen;
588
+ do {
589
+ sum1 += input[i++] << 8;
590
+ sum2 += sum1 += input[i++];
591
+ } while (--tlen);
592
+ sum1 = (sum1 & 65535) + (sum1 >>> 16);
593
+ sum2 = (sum2 & 65535) + (sum2 >>> 16);
594
+ }
595
+ if (len & 1) {
596
+ sum2 += sum1 += input[i] << 8;
597
+ }
598
+ sum1 = (sum1 & 65535) + (sum1 >>> 16);
599
+ sum2 = (sum2 & 65535) + (sum2 >>> 16);
600
+ return (sum2 << 16 | sum1) >>> 0;
601
+ },
602
+ readHeaderInfo: function(input, data) {
603
+ var ptr = data.ptr;
604
+ var fileIdView = new Uint8Array(input, ptr, 6);
605
+ var headerInfo = {};
606
+ headerInfo.fileIdentifierString = String.fromCharCode.apply(null, fileIdView);
607
+ if (headerInfo.fileIdentifierString.lastIndexOf("Lerc2", 0) !== 0) {
608
+ throw "Unexpected file identifier string (expect Lerc2 ): " + headerInfo.fileIdentifierString;
609
+ }
610
+ ptr += 6;
611
+ var view = new DataView(input, ptr, 8);
612
+ var fileVersion = view.getInt32(0, true);
613
+ headerInfo.fileVersion = fileVersion;
614
+ ptr += 4;
615
+ if (fileVersion >= 3) {
616
+ headerInfo.checksum = view.getUint32(4, true);
617
+ ptr += 4;
618
+ }
619
+ view = new DataView(input, ptr, 12);
620
+ headerInfo.height = view.getUint32(0, true);
621
+ headerInfo.width = view.getUint32(4, true);
622
+ ptr += 8;
623
+ if (fileVersion >= 4) {
624
+ headerInfo.numDims = view.getUint32(8, true);
625
+ ptr += 4;
626
+ } else {
627
+ headerInfo.numDims = 1;
628
+ }
629
+ view = new DataView(input, ptr, 40);
630
+ headerInfo.numValidPixel = view.getUint32(0, true);
631
+ headerInfo.microBlockSize = view.getInt32(4, true);
632
+ headerInfo.blobSize = view.getInt32(8, true);
633
+ headerInfo.imageType = view.getInt32(12, true);
634
+ headerInfo.maxZError = view.getFloat64(16, true);
635
+ headerInfo.zMin = view.getFloat64(24, true);
636
+ headerInfo.zMax = view.getFloat64(32, true);
637
+ ptr += 40;
638
+ data.headerInfo = headerInfo;
639
+ data.ptr = ptr;
640
+ var checksum, keyLength;
641
+ if (fileVersion >= 3) {
642
+ keyLength = fileVersion >= 4 ? 52 : 48;
643
+ checksum = this.computeChecksumFletcher32(new Uint8Array(input, ptr - keyLength, headerInfo.blobSize - 14));
644
+ if (checksum !== headerInfo.checksum) {
645
+ throw "Checksum failed.";
646
+ }
647
+ }
648
+ return true;
649
+ },
650
+ checkMinMaxRanges: function(input, data) {
651
+ var headerInfo = data.headerInfo;
652
+ var OutPixelTypeArray = this.getDataTypeArray(headerInfo.imageType);
653
+ var rangeBytes = headerInfo.numDims * this.getDataTypeSize(headerInfo.imageType);
654
+ var minValues = this.readSubArray(input, data.ptr, OutPixelTypeArray, rangeBytes);
655
+ var maxValues = this.readSubArray(input, data.ptr + rangeBytes, OutPixelTypeArray, rangeBytes);
656
+ data.ptr += 2 * rangeBytes;
657
+ var i, equal = true;
658
+ for (i = 0; i < headerInfo.numDims; i++) {
659
+ if (minValues[i] !== maxValues[i]) {
660
+ equal = false;
661
+ break;
662
+ }
663
+ }
664
+ headerInfo.minValues = minValues;
665
+ headerInfo.maxValues = maxValues;
666
+ return equal;
667
+ },
668
+ readSubArray: function(input, ptr, OutPixelTypeArray, numBytes) {
669
+ var rawData;
670
+ if (OutPixelTypeArray === Uint8Array) {
671
+ rawData = new Uint8Array(input, ptr, numBytes);
672
+ } else {
673
+ var arrayBuf = new ArrayBuffer(numBytes);
674
+ var store8 = new Uint8Array(arrayBuf);
675
+ store8.set(new Uint8Array(input, ptr, numBytes));
676
+ rawData = new OutPixelTypeArray(arrayBuf);
677
+ }
678
+ return rawData;
679
+ },
680
+ readMask: function(input, data) {
681
+ var ptr = data.ptr;
682
+ var headerInfo = data.headerInfo;
683
+ var numPixels = headerInfo.width * headerInfo.height;
684
+ var numValidPixel = headerInfo.numValidPixel;
685
+ var view = new DataView(input, ptr, 4);
686
+ var mask = {};
687
+ mask.numBytes = view.getUint32(0, true);
688
+ ptr += 4;
689
+ if ((0 === numValidPixel || numPixels === numValidPixel) && 0 !== mask.numBytes) {
690
+ throw "invalid mask";
691
+ }
692
+ var bitset, resultMask;
693
+ if (numValidPixel === 0) {
694
+ bitset = new Uint8Array(Math.ceil(numPixels / 8));
695
+ mask.bitset = bitset;
696
+ resultMask = new Uint8Array(numPixels);
697
+ data.pixels.resultMask = resultMask;
698
+ ptr += mask.numBytes;
699
+ } else if (mask.numBytes > 0) {
700
+ bitset = new Uint8Array(Math.ceil(numPixels / 8));
701
+ view = new DataView(input, ptr, mask.numBytes);
702
+ var cnt = view.getInt16(0, true);
703
+ var ip = 2, op = 0, val = 0;
704
+ do {
705
+ if (cnt > 0) {
706
+ while (cnt--) {
707
+ bitset[op++] = view.getUint8(ip++);
708
+ }
709
+ } else {
710
+ val = view.getUint8(ip++);
711
+ cnt = -cnt;
712
+ while (cnt--) {
713
+ bitset[op++] = val;
714
+ }
715
+ }
716
+ cnt = view.getInt16(ip, true);
717
+ ip += 2;
718
+ } while (ip < mask.numBytes);
719
+ if (cnt !== -32768 || op < bitset.length) {
720
+ throw "Unexpected end of mask RLE encoding";
721
+ }
722
+ resultMask = new Uint8Array(numPixels);
723
+ var mb = 0, k = 0;
724
+ for (k = 0; k < numPixels; k++) {
725
+ if (k & 7) {
726
+ mb = bitset[k >> 3];
727
+ mb <<= k & 7;
728
+ } else {
729
+ mb = bitset[k >> 3];
730
+ }
731
+ if (mb & 128) {
732
+ resultMask[k] = 1;
733
+ }
734
+ }
735
+ data.pixels.resultMask = resultMask;
736
+ mask.bitset = bitset;
737
+ ptr += mask.numBytes;
738
+ }
739
+ data.ptr = ptr;
740
+ data.mask = mask;
741
+ return true;
742
+ },
743
+ readDataOneSweep: function(input, data, OutPixelTypeArray, useBSQForOutputDim) {
744
+ var ptr = data.ptr;
745
+ var headerInfo = data.headerInfo;
746
+ var numDims = headerInfo.numDims;
747
+ var numPixels = headerInfo.width * headerInfo.height;
748
+ var imageType = headerInfo.imageType;
749
+ var numBytes = headerInfo.numValidPixel * Lerc2Helpers.getDataTypeSize(imageType) * numDims;
750
+ var rawData;
751
+ var mask = data.pixels.resultMask;
752
+ if (OutPixelTypeArray === Uint8Array) {
753
+ rawData = new Uint8Array(input, ptr, numBytes);
754
+ } else {
755
+ var arrayBuf = new ArrayBuffer(numBytes);
756
+ var store8 = new Uint8Array(arrayBuf);
757
+ store8.set(new Uint8Array(input, ptr, numBytes));
758
+ rawData = new OutPixelTypeArray(arrayBuf);
759
+ }
760
+ if (rawData.length === numPixels * numDims) {
761
+ if (useBSQForOutputDim) {
762
+ data.pixels.resultPixels = Lerc2Helpers.swapDimensionOrder(rawData, numPixels, numDims, OutPixelTypeArray, true);
763
+ } else {
764
+ data.pixels.resultPixels = rawData;
765
+ }
766
+ } else {
767
+ data.pixels.resultPixels = new OutPixelTypeArray(numPixels * numDims);
768
+ var z = 0, k = 0, i = 0, nStart = 0;
769
+ if (numDims > 1) {
770
+ if (useBSQForOutputDim) {
771
+ for (k = 0; k < numPixels; k++) {
772
+ if (mask[k]) {
773
+ nStart = k;
774
+ for (i = 0; i < numDims; i++, nStart += numPixels) {
775
+ data.pixels.resultPixels[nStart] = rawData[z++];
776
+ }
777
+ }
778
+ }
779
+ } else {
780
+ for (k = 0; k < numPixels; k++) {
781
+ if (mask[k]) {
782
+ nStart = k * numDims;
783
+ for (i = 0; i < numDims; i++) {
784
+ data.pixels.resultPixels[nStart + i] = rawData[z++];
785
+ }
786
+ }
787
+ }
788
+ }
789
+ } else {
790
+ for (k = 0; k < numPixels; k++) {
791
+ if (mask[k]) {
792
+ data.pixels.resultPixels[k] = rawData[z++];
793
+ }
794
+ }
795
+ }
796
+ }
797
+ ptr += numBytes;
798
+ data.ptr = ptr;
799
+ return true;
800
+ },
801
+ readHuffmanTree: function(input, data) {
802
+ var BITS_MAX = this.HUFFMAN_LUT_BITS_MAX;
803
+ var view = new DataView(input, data.ptr, 16);
804
+ data.ptr += 16;
805
+ var version = view.getInt32(0, true);
806
+ if (version < 2) {
807
+ throw "unsupported Huffman version";
808
+ }
809
+ var size = view.getInt32(4, true);
810
+ var i0 = view.getInt32(8, true);
811
+ var i1 = view.getInt32(12, true);
812
+ if (i0 >= i1) {
813
+ return false;
814
+ }
815
+ var blockDataBuffer = new Uint32Array(i1 - i0);
816
+ Lerc2Helpers.decodeBits(input, data, blockDataBuffer);
817
+ var codeTable = [];
818
+ var i, j, k, len;
819
+ for (i = i0; i < i1; i++) {
820
+ j = i - (i < size ? 0 : size);
821
+ codeTable[j] = { first: blockDataBuffer[i - i0], second: null };
822
+ }
823
+ var dataBytes = input.byteLength - data.ptr;
824
+ var dataWords = Math.ceil(dataBytes / 4);
825
+ var arrayBuf = new ArrayBuffer(dataWords * 4);
826
+ var store8 = new Uint8Array(arrayBuf);
827
+ store8.set(new Uint8Array(input, data.ptr, dataBytes));
828
+ var stuffedData = new Uint32Array(arrayBuf);
829
+ var bitPos = 0, word, srcPtr = 0;
830
+ word = stuffedData[0];
831
+ for (i = i0; i < i1; i++) {
832
+ j = i - (i < size ? 0 : size);
833
+ len = codeTable[j].first;
834
+ if (len > 0) {
835
+ codeTable[j].second = word << bitPos >>> 32 - len;
836
+ if (32 - bitPos >= len) {
837
+ bitPos += len;
838
+ if (bitPos === 32) {
839
+ bitPos = 0;
840
+ srcPtr++;
841
+ word = stuffedData[srcPtr];
842
+ }
843
+ } else {
844
+ bitPos += len - 32;
845
+ srcPtr++;
846
+ word = stuffedData[srcPtr];
847
+ codeTable[j].second |= word >>> 32 - bitPos;
848
+ }
849
+ }
850
+ }
851
+ var numBitsLUT = 0, numBitsLUTQick = 0;
852
+ var tree = new TreeNode();
853
+ for (i = 0; i < codeTable.length; i++) {
854
+ if (codeTable[i] !== void 0) {
855
+ numBitsLUT = Math.max(numBitsLUT, codeTable[i].first);
856
+ }
857
+ }
858
+ if (numBitsLUT >= BITS_MAX) {
859
+ numBitsLUTQick = BITS_MAX;
860
+ } else {
861
+ numBitsLUTQick = numBitsLUT;
862
+ }
863
+ var decodeLut = [], entry, code, numEntries, jj, currentBit, node;
864
+ for (i = i0; i < i1; i++) {
865
+ j = i - (i < size ? 0 : size);
866
+ len = codeTable[j].first;
867
+ if (len > 0) {
868
+ entry = [len, j];
869
+ if (len <= numBitsLUTQick) {
870
+ code = codeTable[j].second << numBitsLUTQick - len;
871
+ numEntries = 1 << numBitsLUTQick - len;
872
+ for (k = 0; k < numEntries; k++) {
873
+ decodeLut[code | k] = entry;
874
+ }
875
+ } else {
876
+ code = codeTable[j].second;
877
+ node = tree;
878
+ for (jj = len - 1; jj >= 0; jj--) {
879
+ currentBit = code >>> jj & 1;
880
+ if (currentBit) {
881
+ if (!node.right) {
882
+ node.right = new TreeNode();
883
+ }
884
+ node = node.right;
885
+ } else {
886
+ if (!node.left) {
887
+ node.left = new TreeNode();
888
+ }
889
+ node = node.left;
890
+ }
891
+ if (jj === 0 && !node.val) {
892
+ node.val = entry[1];
893
+ }
894
+ }
895
+ }
896
+ }
897
+ }
898
+ return {
899
+ decodeLut,
900
+ numBitsLUTQick,
901
+ numBitsLUT,
902
+ tree,
903
+ stuffedData,
904
+ srcPtr,
905
+ bitPos
906
+ };
907
+ },
908
+ readHuffman: function(input, data, OutPixelTypeArray, useBSQForOutputDim) {
909
+ var headerInfo = data.headerInfo;
910
+ var numDims = headerInfo.numDims;
911
+ var height = data.headerInfo.height;
912
+ var width = data.headerInfo.width;
913
+ var numPixels = width * height;
914
+ var huffmanInfo = this.readHuffmanTree(input, data);
915
+ var decodeLut = huffmanInfo.decodeLut;
916
+ var tree = huffmanInfo.tree;
917
+ var stuffedData = huffmanInfo.stuffedData;
918
+ var srcPtr = huffmanInfo.srcPtr;
919
+ var bitPos = huffmanInfo.bitPos;
920
+ var numBitsLUTQick = huffmanInfo.numBitsLUTQick;
921
+ var numBitsLUT = huffmanInfo.numBitsLUT;
922
+ var offset = data.headerInfo.imageType === 0 ? 128 : 0;
923
+ var node, val, delta, mask = data.pixels.resultMask, valTmp, valTmpQuick, currentBit;
924
+ var i, j, k, ii;
925
+ var prevVal = 0;
926
+ if (bitPos > 0) {
927
+ srcPtr++;
928
+ bitPos = 0;
929
+ }
930
+ var word = stuffedData[srcPtr];
931
+ var deltaEncode = data.encodeMode === 1;
932
+ var resultPixelsAllDim = new OutPixelTypeArray(numPixels * numDims);
933
+ var resultPixels = resultPixelsAllDim;
934
+ var iDim;
935
+ if (numDims < 2 || deltaEncode) {
936
+ for (iDim = 0; iDim < numDims; iDim++) {
937
+ if (numDims > 1) {
938
+ resultPixels = new OutPixelTypeArray(resultPixelsAllDim.buffer, numPixels * iDim, numPixels);
939
+ prevVal = 0;
940
+ }
941
+ if (data.headerInfo.numValidPixel === width * height) {
942
+ for (k = 0, i = 0; i < height; i++) {
943
+ for (j = 0; j < width; j++, k++) {
944
+ val = 0;
945
+ valTmp = word << bitPos >>> 32 - numBitsLUTQick;
946
+ valTmpQuick = valTmp;
947
+ if (32 - bitPos < numBitsLUTQick) {
948
+ valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUTQick;
949
+ valTmpQuick = valTmp;
950
+ }
951
+ if (decodeLut[valTmpQuick]) {
952
+ val = decodeLut[valTmpQuick][1];
953
+ bitPos += decodeLut[valTmpQuick][0];
954
+ } else {
955
+ valTmp = word << bitPos >>> 32 - numBitsLUT;
956
+ valTmpQuick = valTmp;
957
+ if (32 - bitPos < numBitsLUT) {
958
+ valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUT;
959
+ valTmpQuick = valTmp;
960
+ }
961
+ node = tree;
962
+ for (ii = 0; ii < numBitsLUT; ii++) {
963
+ currentBit = valTmp >>> numBitsLUT - ii - 1 & 1;
964
+ node = currentBit ? node.right : node.left;
965
+ if (!(node.left || node.right)) {
966
+ val = node.val;
967
+ bitPos = bitPos + ii + 1;
968
+ break;
969
+ }
970
+ }
971
+ }
972
+ if (bitPos >= 32) {
973
+ bitPos -= 32;
974
+ srcPtr++;
975
+ word = stuffedData[srcPtr];
976
+ }
977
+ delta = val - offset;
978
+ if (deltaEncode) {
979
+ if (j > 0) {
980
+ delta += prevVal;
981
+ } else if (i > 0) {
982
+ delta += resultPixels[k - width];
983
+ } else {
984
+ delta += prevVal;
985
+ }
986
+ delta &= 255;
987
+ resultPixels[k] = delta;
988
+ prevVal = delta;
989
+ } else {
990
+ resultPixels[k] = delta;
991
+ }
992
+ }
993
+ }
994
+ } else {
995
+ for (k = 0, i = 0; i < height; i++) {
996
+ for (j = 0; j < width; j++, k++) {
997
+ if (mask[k]) {
998
+ val = 0;
999
+ valTmp = word << bitPos >>> 32 - numBitsLUTQick;
1000
+ valTmpQuick = valTmp;
1001
+ if (32 - bitPos < numBitsLUTQick) {
1002
+ valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUTQick;
1003
+ valTmpQuick = valTmp;
1004
+ }
1005
+ if (decodeLut[valTmpQuick]) {
1006
+ val = decodeLut[valTmpQuick][1];
1007
+ bitPos += decodeLut[valTmpQuick][0];
1008
+ } else {
1009
+ valTmp = word << bitPos >>> 32 - numBitsLUT;
1010
+ valTmpQuick = valTmp;
1011
+ if (32 - bitPos < numBitsLUT) {
1012
+ valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUT;
1013
+ valTmpQuick = valTmp;
1014
+ }
1015
+ node = tree;
1016
+ for (ii = 0; ii < numBitsLUT; ii++) {
1017
+ currentBit = valTmp >>> numBitsLUT - ii - 1 & 1;
1018
+ node = currentBit ? node.right : node.left;
1019
+ if (!(node.left || node.right)) {
1020
+ val = node.val;
1021
+ bitPos = bitPos + ii + 1;
1022
+ break;
1023
+ }
1024
+ }
1025
+ }
1026
+ if (bitPos >= 32) {
1027
+ bitPos -= 32;
1028
+ srcPtr++;
1029
+ word = stuffedData[srcPtr];
1030
+ }
1031
+ delta = val - offset;
1032
+ if (deltaEncode) {
1033
+ if (j > 0 && mask[k - 1]) {
1034
+ delta += prevVal;
1035
+ } else if (i > 0 && mask[k - width]) {
1036
+ delta += resultPixels[k - width];
1037
+ } else {
1038
+ delta += prevVal;
1039
+ }
1040
+ delta &= 255;
1041
+ resultPixels[k] = delta;
1042
+ prevVal = delta;
1043
+ } else {
1044
+ resultPixels[k] = delta;
1045
+ }
1046
+ }
1047
+ }
1048
+ }
1049
+ }
1050
+ }
1051
+ } else {
1052
+ for (k = 0, i = 0; i < height; i++) {
1053
+ for (j = 0; j < width; j++) {
1054
+ k = i * width + j;
1055
+ if (!mask || mask[k]) {
1056
+ for (iDim = 0; iDim < numDims; iDim++, k += numPixels) {
1057
+ val = 0;
1058
+ valTmp = word << bitPos >>> 32 - numBitsLUTQick;
1059
+ valTmpQuick = valTmp;
1060
+ if (32 - bitPos < numBitsLUTQick) {
1061
+ valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUTQick;
1062
+ valTmpQuick = valTmp;
1063
+ }
1064
+ if (decodeLut[valTmpQuick]) {
1065
+ val = decodeLut[valTmpQuick][1];
1066
+ bitPos += decodeLut[valTmpQuick][0];
1067
+ } else {
1068
+ valTmp = word << bitPos >>> 32 - numBitsLUT;
1069
+ valTmpQuick = valTmp;
1070
+ if (32 - bitPos < numBitsLUT) {
1071
+ valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUT;
1072
+ valTmpQuick = valTmp;
1073
+ }
1074
+ node = tree;
1075
+ for (ii = 0; ii < numBitsLUT; ii++) {
1076
+ currentBit = valTmp >>> numBitsLUT - ii - 1 & 1;
1077
+ node = currentBit ? node.right : node.left;
1078
+ if (!(node.left || node.right)) {
1079
+ val = node.val;
1080
+ bitPos = bitPos + ii + 1;
1081
+ break;
1082
+ }
1083
+ }
1084
+ }
1085
+ if (bitPos >= 32) {
1086
+ bitPos -= 32;
1087
+ srcPtr++;
1088
+ word = stuffedData[srcPtr];
1089
+ }
1090
+ delta = val - offset;
1091
+ resultPixels[k] = delta;
1092
+ }
1093
+ }
1094
+ }
1095
+ }
1096
+ }
1097
+ data.ptr = data.ptr + (srcPtr + 1) * 4 + (bitPos > 0 ? 4 : 0);
1098
+ data.pixels.resultPixels = resultPixelsAllDim;
1099
+ if (numDims > 1 && !useBSQForOutputDim) {
1100
+ data.pixels.resultPixels = Lerc2Helpers.swapDimensionOrder(resultPixelsAllDim, numPixels, numDims, OutPixelTypeArray);
1101
+ }
1102
+ },
1103
+ decodeBits: function(input, data, blockDataBuffer, offset, iDim) {
1104
+ {
1105
+ var headerInfo = data.headerInfo;
1106
+ var fileVersion = headerInfo.fileVersion;
1107
+ var blockPtr = 0;
1108
+ var viewByteLength = input.byteLength - data.ptr >= 5 ? 5 : input.byteLength - data.ptr;
1109
+ var view = new DataView(input, data.ptr, viewByteLength);
1110
+ var headerByte = view.getUint8(0);
1111
+ blockPtr++;
1112
+ var bits67 = headerByte >> 6;
1113
+ var n = bits67 === 0 ? 4 : 3 - bits67;
1114
+ var doLut = (headerByte & 32) > 0 ? true : false;
1115
+ var numBits = headerByte & 31;
1116
+ var numElements = 0;
1117
+ if (n === 1) {
1118
+ numElements = view.getUint8(blockPtr);
1119
+ blockPtr++;
1120
+ } else if (n === 2) {
1121
+ numElements = view.getUint16(blockPtr, true);
1122
+ blockPtr += 2;
1123
+ } else if (n === 4) {
1124
+ numElements = view.getUint32(blockPtr, true);
1125
+ blockPtr += 4;
1126
+ } else {
1127
+ throw "Invalid valid pixel count type";
1128
+ }
1129
+ var scale = 2 * headerInfo.maxZError;
1130
+ var stuffedData, arrayBuf, store8, dataBytes, dataWords;
1131
+ var lutArr, lutData, lutBytes, bitsPerPixel;
1132
+ var zMax = headerInfo.numDims > 1 ? headerInfo.maxValues[iDim] : headerInfo.zMax;
1133
+ if (doLut) {
1134
+ data.counter.lut++;
1135
+ lutBytes = view.getUint8(blockPtr);
1136
+ blockPtr++;
1137
+ dataBytes = Math.ceil((lutBytes - 1) * numBits / 8);
1138
+ dataWords = Math.ceil(dataBytes / 4);
1139
+ arrayBuf = new ArrayBuffer(dataWords * 4);
1140
+ store8 = new Uint8Array(arrayBuf);
1141
+ data.ptr += blockPtr;
1142
+ store8.set(new Uint8Array(input, data.ptr, dataBytes));
1143
+ lutData = new Uint32Array(arrayBuf);
1144
+ data.ptr += dataBytes;
1145
+ bitsPerPixel = 0;
1146
+ while (lutBytes - 1 >>> bitsPerPixel) {
1147
+ bitsPerPixel++;
1148
+ }
1149
+ dataBytes = Math.ceil(numElements * bitsPerPixel / 8);
1150
+ dataWords = Math.ceil(dataBytes / 4);
1151
+ arrayBuf = new ArrayBuffer(dataWords * 4);
1152
+ store8 = new Uint8Array(arrayBuf);
1153
+ store8.set(new Uint8Array(input, data.ptr, dataBytes));
1154
+ stuffedData = new Uint32Array(arrayBuf);
1155
+ data.ptr += dataBytes;
1156
+ if (fileVersion >= 3) {
1157
+ lutArr = BitStuffer.unstuffLUT2(lutData, numBits, lutBytes - 1, offset, scale, zMax);
1158
+ } else {
1159
+ lutArr = BitStuffer.unstuffLUT(lutData, numBits, lutBytes - 1, offset, scale, zMax);
1160
+ }
1161
+ if (fileVersion >= 3) {
1162
+ BitStuffer.unstuff2(stuffedData, blockDataBuffer, bitsPerPixel, numElements, lutArr);
1163
+ } else {
1164
+ BitStuffer.unstuff(stuffedData, blockDataBuffer, bitsPerPixel, numElements, lutArr);
1165
+ }
1166
+ } else {
1167
+ data.counter.bitstuffer++;
1168
+ bitsPerPixel = numBits;
1169
+ data.ptr += blockPtr;
1170
+ if (bitsPerPixel > 0) {
1171
+ dataBytes = Math.ceil(numElements * bitsPerPixel / 8);
1172
+ dataWords = Math.ceil(dataBytes / 4);
1173
+ arrayBuf = new ArrayBuffer(dataWords * 4);
1174
+ store8 = new Uint8Array(arrayBuf);
1175
+ store8.set(new Uint8Array(input, data.ptr, dataBytes));
1176
+ stuffedData = new Uint32Array(arrayBuf);
1177
+ data.ptr += dataBytes;
1178
+ if (fileVersion >= 3) {
1179
+ if (offset == null) {
1180
+ BitStuffer.originalUnstuff2(stuffedData, blockDataBuffer, bitsPerPixel, numElements);
1181
+ } else {
1182
+ BitStuffer.unstuff2(stuffedData, blockDataBuffer, bitsPerPixel, numElements, false, offset, scale, zMax);
1183
+ }
1184
+ } else {
1185
+ if (offset == null) {
1186
+ BitStuffer.originalUnstuff(stuffedData, blockDataBuffer, bitsPerPixel, numElements);
1187
+ } else {
1188
+ BitStuffer.unstuff(stuffedData, blockDataBuffer, bitsPerPixel, numElements, false, offset, scale, zMax);
1189
+ }
1190
+ }
1191
+ }
1192
+ }
1193
+ }
1194
+ },
1195
+ readTiles: function(input, data, OutPixelTypeArray, useBSQForOutputDim) {
1196
+ var headerInfo = data.headerInfo;
1197
+ var width = headerInfo.width;
1198
+ var height = headerInfo.height;
1199
+ var numPixels = width * height;
1200
+ var microBlockSize = headerInfo.microBlockSize;
1201
+ var imageType = headerInfo.imageType;
1202
+ var dataTypeSize = Lerc2Helpers.getDataTypeSize(imageType);
1203
+ var numBlocksX = Math.ceil(width / microBlockSize);
1204
+ var numBlocksY = Math.ceil(height / microBlockSize);
1205
+ data.pixels.numBlocksY = numBlocksY;
1206
+ data.pixels.numBlocksX = numBlocksX;
1207
+ data.pixels.ptr = 0;
1208
+ var row = 0, col = 0, blockY = 0, blockX = 0, thisBlockHeight = 0, thisBlockWidth = 0, bytesLeft = 0, headerByte = 0, bits67 = 0, testCode = 0, outPtr = 0, outStride = 0, numBytes = 0, bytesleft = 0, z = 0, blockPtr = 0;
1209
+ var view, block, arrayBuf, store8, rawData;
1210
+ var blockEncoding;
1211
+ var blockDataBuffer = new OutPixelTypeArray(microBlockSize * microBlockSize);
1212
+ var lastBlockHeight = height % microBlockSize || microBlockSize;
1213
+ var lastBlockWidth = width % microBlockSize || microBlockSize;
1214
+ var offsetType, offset;
1215
+ var numDims = headerInfo.numDims, iDim;
1216
+ var mask = data.pixels.resultMask;
1217
+ var resultPixels = data.pixels.resultPixels;
1218
+ var fileVersion = headerInfo.fileVersion;
1219
+ var fileVersionCheckNum = fileVersion >= 5 ? 14 : 15;
1220
+ var isDiffEncoding;
1221
+ var zMax = headerInfo.zMax;
1222
+ var resultPixelsPrevDim;
1223
+ for (blockY = 0; blockY < numBlocksY; blockY++) {
1224
+ thisBlockHeight = blockY !== numBlocksY - 1 ? microBlockSize : lastBlockHeight;
1225
+ for (blockX = 0; blockX < numBlocksX; blockX++) {
1226
+ thisBlockWidth = blockX !== numBlocksX - 1 ? microBlockSize : lastBlockWidth;
1227
+ outPtr = blockY * width * microBlockSize + blockX * microBlockSize;
1228
+ outStride = width - thisBlockWidth;
1229
+ for (iDim = 0; iDim < numDims; iDim++) {
1230
+ if (numDims > 1) {
1231
+ resultPixelsPrevDim = resultPixels;
1232
+ outPtr = blockY * width * microBlockSize + blockX * microBlockSize;
1233
+ resultPixels = new OutPixelTypeArray(data.pixels.resultPixels.buffer, numPixels * iDim * dataTypeSize, numPixels);
1234
+ zMax = headerInfo.maxValues[iDim];
1235
+ } else {
1236
+ resultPixelsPrevDim = null;
1237
+ }
1238
+ bytesLeft = input.byteLength - data.ptr;
1239
+ view = new DataView(input, data.ptr, Math.min(10, bytesLeft));
1240
+ block = {};
1241
+ blockPtr = 0;
1242
+ headerByte = view.getUint8(0);
1243
+ blockPtr++;
1244
+ isDiffEncoding = headerInfo.fileVersion >= 5 ? headerByte & 4 : 0;
1245
+ bits67 = headerByte >> 6 & 255;
1246
+ testCode = headerByte >> 2 & fileVersionCheckNum;
1247
+ if (testCode !== (blockX * microBlockSize >> 3 & fileVersionCheckNum)) {
1248
+ throw "integrity issue";
1249
+ }
1250
+ if (isDiffEncoding && iDim === 0) {
1251
+ throw "integrity issue";
1252
+ }
1253
+ blockEncoding = headerByte & 3;
1254
+ if (blockEncoding > 3) {
1255
+ data.ptr += blockPtr;
1256
+ throw "Invalid block encoding (" + blockEncoding + ")";
1257
+ } else if (blockEncoding === 2) {
1258
+ if (isDiffEncoding) {
1259
+ if (mask) {
1260
+ for (row = 0; row < thisBlockHeight; row++) {
1261
+ for (col = 0; col < thisBlockWidth; col++) {
1262
+ if (mask[outPtr]) {
1263
+ resultPixels[outPtr] = resultPixelsPrevDim[outPtr];
1264
+ }
1265
+ outPtr++;
1266
+ }
1267
+ }
1268
+ } else {
1269
+ for (row = 0; row < thisBlockHeight; row++) {
1270
+ for (col = 0; col < thisBlockWidth; col++) {
1271
+ resultPixels[outPtr] = resultPixelsPrevDim[outPtr];
1272
+ outPtr++;
1273
+ }
1274
+ }
1275
+ }
1276
+ }
1277
+ data.counter.constant++;
1278
+ data.ptr += blockPtr;
1279
+ continue;
1280
+ } else if (blockEncoding === 0) {
1281
+ if (isDiffEncoding) {
1282
+ throw "integrity issue";
1283
+ }
1284
+ data.counter.uncompressed++;
1285
+ data.ptr += blockPtr;
1286
+ numBytes = thisBlockHeight * thisBlockWidth * dataTypeSize;
1287
+ bytesleft = input.byteLength - data.ptr;
1288
+ numBytes = numBytes < bytesleft ? numBytes : bytesleft;
1289
+ arrayBuf = new ArrayBuffer(numBytes % dataTypeSize === 0 ? numBytes : numBytes + dataTypeSize - numBytes % dataTypeSize);
1290
+ store8 = new Uint8Array(arrayBuf);
1291
+ store8.set(new Uint8Array(input, data.ptr, numBytes));
1292
+ rawData = new OutPixelTypeArray(arrayBuf);
1293
+ z = 0;
1294
+ if (mask) {
1295
+ for (row = 0; row < thisBlockHeight; row++) {
1296
+ for (col = 0; col < thisBlockWidth; col++) {
1297
+ if (mask[outPtr]) {
1298
+ resultPixels[outPtr] = rawData[z++];
1299
+ }
1300
+ outPtr++;
1301
+ }
1302
+ outPtr += outStride;
1303
+ }
1304
+ } else {
1305
+ for (row = 0; row < thisBlockHeight; row++) {
1306
+ for (col = 0; col < thisBlockWidth; col++) {
1307
+ resultPixels[outPtr++] = rawData[z++];
1308
+ }
1309
+ outPtr += outStride;
1310
+ }
1311
+ }
1312
+ data.ptr += z * dataTypeSize;
1313
+ } else {
1314
+ offsetType = Lerc2Helpers.getDataTypeUsed(isDiffEncoding && imageType < 6 ? 4 : imageType, bits67);
1315
+ offset = Lerc2Helpers.getOnePixel(block, blockPtr, offsetType, view);
1316
+ blockPtr += Lerc2Helpers.getDataTypeSize(offsetType);
1317
+ if (blockEncoding === 3) {
1318
+ data.ptr += blockPtr;
1319
+ data.counter.constantoffset++;
1320
+ if (mask) {
1321
+ for (row = 0; row < thisBlockHeight; row++) {
1322
+ for (col = 0; col < thisBlockWidth; col++) {
1323
+ if (mask[outPtr]) {
1324
+ resultPixels[outPtr] = isDiffEncoding ? Math.min(zMax, resultPixelsPrevDim[outPtr] + offset) : offset;
1325
+ }
1326
+ outPtr++;
1327
+ }
1328
+ outPtr += outStride;
1329
+ }
1330
+ } else {
1331
+ for (row = 0; row < thisBlockHeight; row++) {
1332
+ for (col = 0; col < thisBlockWidth; col++) {
1333
+ resultPixels[outPtr] = isDiffEncoding ? Math.min(zMax, resultPixelsPrevDim[outPtr] + offset) : offset;
1334
+ outPtr++;
1335
+ }
1336
+ outPtr += outStride;
1337
+ }
1338
+ }
1339
+ } else {
1340
+ data.ptr += blockPtr;
1341
+ Lerc2Helpers.decodeBits(input, data, blockDataBuffer, offset, iDim);
1342
+ blockPtr = 0;
1343
+ if (isDiffEncoding) {
1344
+ if (mask) {
1345
+ for (row = 0; row < thisBlockHeight; row++) {
1346
+ for (col = 0; col < thisBlockWidth; col++) {
1347
+ if (mask[outPtr]) {
1348
+ resultPixels[outPtr] = blockDataBuffer[blockPtr++] + resultPixelsPrevDim[outPtr];
1349
+ }
1350
+ outPtr++;
1351
+ }
1352
+ outPtr += outStride;
1353
+ }
1354
+ } else {
1355
+ for (row = 0; row < thisBlockHeight; row++) {
1356
+ for (col = 0; col < thisBlockWidth; col++) {
1357
+ resultPixels[outPtr] = blockDataBuffer[blockPtr++] + resultPixelsPrevDim[outPtr];
1358
+ outPtr++;
1359
+ }
1360
+ outPtr += outStride;
1361
+ }
1362
+ }
1363
+ } else if (mask) {
1364
+ for (row = 0; row < thisBlockHeight; row++) {
1365
+ for (col = 0; col < thisBlockWidth; col++) {
1366
+ if (mask[outPtr]) {
1367
+ resultPixels[outPtr] = blockDataBuffer[blockPtr++];
1368
+ }
1369
+ outPtr++;
1370
+ }
1371
+ outPtr += outStride;
1372
+ }
1373
+ } else {
1374
+ for (row = 0; row < thisBlockHeight; row++) {
1375
+ for (col = 0; col < thisBlockWidth; col++) {
1376
+ resultPixels[outPtr++] = blockDataBuffer[blockPtr++];
1377
+ }
1378
+ outPtr += outStride;
1379
+ }
1380
+ }
1381
+ }
1382
+ }
1383
+ }
1384
+ }
1385
+ }
1386
+ if (numDims > 1 && !useBSQForOutputDim) {
1387
+ data.pixels.resultPixels = Lerc2Helpers.swapDimensionOrder(data.pixels.resultPixels, numPixels, numDims, OutPixelTypeArray);
1388
+ }
1389
+ },
1390
+ /*****************
1391
+ * private methods (helper methods)
1392
+ *****************/
1393
+ formatFileInfo: function(data) {
1394
+ return {
1395
+ "fileIdentifierString": data.headerInfo.fileIdentifierString,
1396
+ "fileVersion": data.headerInfo.fileVersion,
1397
+ "imageType": data.headerInfo.imageType,
1398
+ "height": data.headerInfo.height,
1399
+ "width": data.headerInfo.width,
1400
+ "numValidPixel": data.headerInfo.numValidPixel,
1401
+ "microBlockSize": data.headerInfo.microBlockSize,
1402
+ "blobSize": data.headerInfo.blobSize,
1403
+ "maxZError": data.headerInfo.maxZError,
1404
+ "pixelType": Lerc2Helpers.getPixelType(data.headerInfo.imageType),
1405
+ "eofOffset": data.eofOffset,
1406
+ "mask": data.mask ? {
1407
+ "numBytes": data.mask.numBytes
1408
+ } : null,
1409
+ "pixels": {
1410
+ "numBlocksX": data.pixels.numBlocksX,
1411
+ "numBlocksY": data.pixels.numBlocksY,
1412
+ //"numBytes": data.pixels.numBytes,
1413
+ "maxValue": data.headerInfo.zMax,
1414
+ "minValue": data.headerInfo.zMin,
1415
+ "noDataValue": data.noDataValue
1416
+ }
1417
+ };
1418
+ },
1419
+ constructConstantSurface: function(data, useBSQForOutputDim) {
1420
+ var val = data.headerInfo.zMax;
1421
+ var valMin = data.headerInfo.zMin;
1422
+ var maxValues = data.headerInfo.maxValues;
1423
+ var numDims = data.headerInfo.numDims;
1424
+ var numPixels = data.headerInfo.height * data.headerInfo.width;
1425
+ var i = 0, k = 0, nStart = 0;
1426
+ var mask = data.pixels.resultMask;
1427
+ var resultPixels = data.pixels.resultPixels;
1428
+ if (mask) {
1429
+ if (numDims > 1) {
1430
+ if (useBSQForOutputDim) {
1431
+ for (i = 0; i < numDims; i++) {
1432
+ nStart = i * numPixels;
1433
+ val = maxValues[i];
1434
+ for (k = 0; k < numPixels; k++) {
1435
+ if (mask[k]) {
1436
+ resultPixels[nStart + k] = val;
1437
+ }
1438
+ }
1439
+ }
1440
+ } else {
1441
+ for (k = 0; k < numPixels; k++) {
1442
+ if (mask[k]) {
1443
+ nStart = k * numDims;
1444
+ for (i = 0; i < numDims; i++) {
1445
+ resultPixels[nStart + numDims] = maxValues[i];
1446
+ }
1447
+ }
1448
+ }
1449
+ }
1450
+ } else {
1451
+ for (k = 0; k < numPixels; k++) {
1452
+ if (mask[k]) {
1453
+ resultPixels[k] = val;
1454
+ }
1455
+ }
1456
+ }
1457
+ } else {
1458
+ if (numDims > 1 && valMin !== val) {
1459
+ if (useBSQForOutputDim) {
1460
+ for (i = 0; i < numDims; i++) {
1461
+ nStart = i * numPixels;
1462
+ val = maxValues[i];
1463
+ for (k = 0; k < numPixels; k++) {
1464
+ resultPixels[nStart + k] = val;
1465
+ }
1466
+ }
1467
+ } else {
1468
+ for (k = 0; k < numPixels; k++) {
1469
+ nStart = k * numDims;
1470
+ for (i = 0; i < numDims; i++) {
1471
+ resultPixels[nStart + i] = maxValues[i];
1472
+ }
1473
+ }
1474
+ }
1475
+ } else {
1476
+ for (k = 0; k < numPixels * numDims; k++) {
1477
+ resultPixels[k] = val;
1478
+ }
1479
+ }
1480
+ }
1481
+ return;
1482
+ },
1483
+ getDataTypeArray: function(t) {
1484
+ var tp;
1485
+ switch (t) {
1486
+ case 0:
1487
+ tp = Int8Array;
1488
+ break;
1489
+ case 1:
1490
+ tp = Uint8Array;
1491
+ break;
1492
+ case 2:
1493
+ tp = Int16Array;
1494
+ break;
1495
+ case 3:
1496
+ tp = Uint16Array;
1497
+ break;
1498
+ case 4:
1499
+ tp = Int32Array;
1500
+ break;
1501
+ case 5:
1502
+ tp = Uint32Array;
1503
+ break;
1504
+ case 6:
1505
+ tp = Float32Array;
1506
+ break;
1507
+ case 7:
1508
+ tp = Float64Array;
1509
+ break;
1510
+ default:
1511
+ tp = Float32Array;
1512
+ }
1513
+ return tp;
1514
+ },
1515
+ getPixelType: function(t) {
1516
+ var tp;
1517
+ switch (t) {
1518
+ case 0:
1519
+ tp = "S8";
1520
+ break;
1521
+ case 1:
1522
+ tp = "U8";
1523
+ break;
1524
+ case 2:
1525
+ tp = "S16";
1526
+ break;
1527
+ case 3:
1528
+ tp = "U16";
1529
+ break;
1530
+ case 4:
1531
+ tp = "S32";
1532
+ break;
1533
+ case 5:
1534
+ tp = "U32";
1535
+ break;
1536
+ case 6:
1537
+ tp = "F32";
1538
+ break;
1539
+ case 7:
1540
+ tp = "F64";
1541
+ break;
1542
+ default:
1543
+ tp = "F32";
1544
+ }
1545
+ return tp;
1546
+ },
1547
+ isValidPixelValue: function(t, val) {
1548
+ if (val == null) {
1549
+ return false;
1550
+ }
1551
+ var isValid;
1552
+ switch (t) {
1553
+ case 0:
1554
+ isValid = val >= -128 && val <= 127;
1555
+ break;
1556
+ case 1:
1557
+ isValid = val >= 0 && val <= 255;
1558
+ break;
1559
+ case 2:
1560
+ isValid = val >= -32768 && val <= 32767;
1561
+ break;
1562
+ case 3:
1563
+ isValid = val >= 0 && val <= 65536;
1564
+ break;
1565
+ case 4:
1566
+ isValid = val >= -2147483648 && val <= 2147483647;
1567
+ break;
1568
+ case 5:
1569
+ isValid = val >= 0 && val <= 4294967296;
1570
+ break;
1571
+ case 6:
1572
+ isValid = val >= -34027999387901484e22 && val <= 34027999387901484e22;
1573
+ break;
1574
+ case 7:
1575
+ isValid = val >= -17976931348623157e292 && val <= 17976931348623157e292;
1576
+ break;
1577
+ default:
1578
+ isValid = false;
1579
+ }
1580
+ return isValid;
1581
+ },
1582
+ getDataTypeSize: function(t) {
1583
+ var s = 0;
1584
+ switch (t) {
1585
+ case 0:
1586
+ case 1:
1587
+ s = 1;
1588
+ break;
1589
+ case 2:
1590
+ case 3:
1591
+ s = 2;
1592
+ break;
1593
+ case 4:
1594
+ case 5:
1595
+ case 6:
1596
+ s = 4;
1597
+ break;
1598
+ case 7:
1599
+ s = 8;
1600
+ break;
1601
+ default:
1602
+ s = t;
1603
+ }
1604
+ return s;
1605
+ },
1606
+ getDataTypeUsed: function(dt, tc) {
1607
+ var t = dt;
1608
+ switch (dt) {
1609
+ case 2:
1610
+ case 4:
1611
+ t = dt - tc;
1612
+ break;
1613
+ case 3:
1614
+ case 5:
1615
+ t = dt - 2 * tc;
1616
+ break;
1617
+ case 6:
1618
+ if (0 === tc) {
1619
+ t = dt;
1620
+ } else if (1 === tc) {
1621
+ t = 2;
1622
+ } else {
1623
+ t = 1;
1624
+ }
1625
+ break;
1626
+ case 7:
1627
+ if (0 === tc) {
1628
+ t = dt;
1629
+ } else {
1630
+ t = dt - 2 * tc + 1;
1631
+ }
1632
+ break;
1633
+ default:
1634
+ t = dt;
1635
+ break;
1636
+ }
1637
+ return t;
1638
+ },
1639
+ getOnePixel: function(block, blockPtr, offsetType, view) {
1640
+ var temp = 0;
1641
+ switch (offsetType) {
1642
+ case 0:
1643
+ temp = view.getInt8(blockPtr);
1644
+ break;
1645
+ case 1:
1646
+ temp = view.getUint8(blockPtr);
1647
+ break;
1648
+ case 2:
1649
+ temp = view.getInt16(blockPtr, true);
1650
+ break;
1651
+ case 3:
1652
+ temp = view.getUint16(blockPtr, true);
1653
+ break;
1654
+ case 4:
1655
+ temp = view.getInt32(blockPtr, true);
1656
+ break;
1657
+ case 5:
1658
+ temp = view.getUInt32(blockPtr, true);
1659
+ break;
1660
+ case 6:
1661
+ temp = view.getFloat32(blockPtr, true);
1662
+ break;
1663
+ case 7:
1664
+ temp = view.getFloat64(blockPtr, true);
1665
+ break;
1666
+ default:
1667
+ throw "the decoder does not understand this pixel type";
1668
+ }
1669
+ return temp;
1670
+ },
1671
+ swapDimensionOrder: function(pixels, numPixels, numDims, OutPixelTypeArray, inputIsBIP) {
1672
+ var i = 0, j = 0, iDim = 0, temp = 0, swap = pixels;
1673
+ if (numDims > 1) {
1674
+ swap = new OutPixelTypeArray(numPixels * numDims);
1675
+ if (inputIsBIP) {
1676
+ for (i = 0; i < numPixels; i++) {
1677
+ temp = i;
1678
+ for (iDim = 0; iDim < numDims; iDim++, temp += numPixels) {
1679
+ swap[temp] = pixels[j++];
1680
+ }
1681
+ }
1682
+ } else {
1683
+ for (i = 0; i < numPixels; i++) {
1684
+ temp = i;
1685
+ for (iDim = 0; iDim < numDims; iDim++, temp += numPixels) {
1686
+ swap[j++] = pixels[temp];
1687
+ }
1688
+ }
1689
+ }
1690
+ }
1691
+ return swap;
1692
+ }
1693
+ };
1694
+ var TreeNode = function(val, left, right) {
1695
+ this.val = val;
1696
+ this.left = left;
1697
+ this.right = right;
1698
+ };
1699
+ var Lerc2Decode2 = {
1700
+ /*
1701
+ * ********removed options compared to LERC1. We can bring some of them back if needed.
1702
+ * removed pixel type. LERC2 is typed and doesn't require user to give pixel type
1703
+ * changed encodedMaskData to maskData. LERC2 's js version make it faster to use maskData directly.
1704
+ * 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.
1705
+ * removed nodatavalue. Because LERC2 pixels are typed, nodatavalue will sacrify a useful value for many types (8bit, 16bit) etc,
1706
+ * user has to be knowledgable enough about raster and their data to avoid usability issues. so nodata value is simply removed now.
1707
+ * We can add it back later if their's a clear requirement.
1708
+ * removed encodedMask. This option was not implemented in LercDecode. It can be done after decoding (less efficient)
1709
+ * removed computeUsedBitDepths.
1710
+ *
1711
+ *
1712
+ * response changes compared to LERC1
1713
+ * 1. encodedMaskData is not available
1714
+ * 2. noDataValue is optional (returns only if user's noDataValue is with in the valid data type range)
1715
+ * 3. maskData is always available
1716
+ */
1717
+ /*****************
1718
+ * public properties
1719
+ ******************/
1720
+ //HUFFMAN_LUT_BITS_MAX: 12, //use 2^12 lut, not configurable
1721
+ /*****************
1722
+ * public methods
1723
+ *****************/
1724
+ /**
1725
+ * Decode a LERC2 byte stream and return an object containing the pixel data and optional metadata.
1726
+ *
1727
+ * @param {ArrayBuffer} input The LERC input byte stream
1728
+ * @param {object} [options] options Decoding options
1729
+ * @param {number} [options.inputOffset] The number of bytes to skip in the input byte stream. A valid LERC file is expected at that position
1730
+ * @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
1731
+ * @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...]
1732
+ */
1733
+ decode: function(input, options) {
1734
+ options = options || {};
1735
+ var noDataValue = options.noDataValue;
1736
+ var i = 0, data = {};
1737
+ data.ptr = options.inputOffset || 0;
1738
+ data.pixels = {};
1739
+ if (!Lerc2Helpers.readHeaderInfo(input, data)) {
1740
+ return;
1741
+ }
1742
+ var headerInfo = data.headerInfo;
1743
+ var fileVersion = headerInfo.fileVersion;
1744
+ var OutPixelTypeArray = Lerc2Helpers.getDataTypeArray(headerInfo.imageType);
1745
+ if (fileVersion > 5) {
1746
+ throw "unsupported lerc version 2." + fileVersion;
1747
+ }
1748
+ Lerc2Helpers.readMask(input, data);
1749
+ if (headerInfo.numValidPixel !== headerInfo.width * headerInfo.height && !data.pixels.resultMask) {
1750
+ data.pixels.resultMask = options.maskData;
1751
+ }
1752
+ var numPixels = headerInfo.width * headerInfo.height;
1753
+ data.pixels.resultPixels = new OutPixelTypeArray(numPixels * headerInfo.numDims);
1754
+ data.counter = {
1755
+ onesweep: 0,
1756
+ uncompressed: 0,
1757
+ lut: 0,
1758
+ bitstuffer: 0,
1759
+ constant: 0,
1760
+ constantoffset: 0
1761
+ };
1762
+ var useBSQForOutputDim = !options.returnPixelInterleavedDims;
1763
+ if (headerInfo.numValidPixel !== 0) {
1764
+ if (headerInfo.zMax === headerInfo.zMin) {
1765
+ Lerc2Helpers.constructConstantSurface(data, useBSQForOutputDim);
1766
+ } else if (fileVersion >= 4 && Lerc2Helpers.checkMinMaxRanges(input, data)) {
1767
+ Lerc2Helpers.constructConstantSurface(data, useBSQForOutputDim);
1768
+ } else {
1769
+ var view = new DataView(input, data.ptr, 2);
1770
+ var bReadDataOneSweep = view.getUint8(0);
1771
+ data.ptr++;
1772
+ if (bReadDataOneSweep) {
1773
+ Lerc2Helpers.readDataOneSweep(input, data, OutPixelTypeArray, useBSQForOutputDim);
1774
+ } else {
1775
+ if (fileVersion > 1 && headerInfo.imageType <= 1 && Math.abs(headerInfo.maxZError - 0.5) < 1e-5) {
1776
+ var flagHuffman = view.getUint8(1);
1777
+ data.ptr++;
1778
+ data.encodeMode = flagHuffman;
1779
+ if (flagHuffman > 2 || fileVersion < 4 && flagHuffman > 1) {
1780
+ throw "Invalid Huffman flag " + flagHuffman;
1781
+ }
1782
+ if (flagHuffman) {
1783
+ Lerc2Helpers.readHuffman(input, data, OutPixelTypeArray, useBSQForOutputDim);
1784
+ } else {
1785
+ Lerc2Helpers.readTiles(input, data, OutPixelTypeArray, useBSQForOutputDim);
1786
+ }
1787
+ } else {
1788
+ Lerc2Helpers.readTiles(input, data, OutPixelTypeArray, useBSQForOutputDim);
1789
+ }
1790
+ }
1791
+ }
1792
+ }
1793
+ data.eofOffset = data.ptr;
1794
+ var diff;
1795
+ if (options.inputOffset) {
1796
+ diff = data.headerInfo.blobSize + options.inputOffset - data.ptr;
1797
+ if (Math.abs(diff) >= 1) {
1798
+ data.eofOffset = options.inputOffset + data.headerInfo.blobSize;
1799
+ }
1800
+ } else {
1801
+ diff = data.headerInfo.blobSize - data.ptr;
1802
+ if (Math.abs(diff) >= 1) {
1803
+ data.eofOffset = data.headerInfo.blobSize;
1804
+ }
1805
+ }
1806
+ var result = {
1807
+ width: headerInfo.width,
1808
+ height: headerInfo.height,
1809
+ pixelData: data.pixels.resultPixels,
1810
+ minValue: headerInfo.zMin,
1811
+ maxValue: headerInfo.zMax,
1812
+ validPixelCount: headerInfo.numValidPixel,
1813
+ dimCount: headerInfo.numDims,
1814
+ dimStats: {
1815
+ minValues: headerInfo.minValues,
1816
+ maxValues: headerInfo.maxValues
1817
+ },
1818
+ maskData: data.pixels.resultMask
1819
+ //noDataValue: noDataValue
1820
+ };
1821
+ if (data.pixels.resultMask && Lerc2Helpers.isValidPixelValue(headerInfo.imageType, noDataValue)) {
1822
+ var mask = data.pixels.resultMask;
1823
+ for (i = 0; i < numPixels; i++) {
1824
+ if (!mask[i]) {
1825
+ result.pixelData[i] = noDataValue;
1826
+ }
1827
+ }
1828
+ result.noDataValue = noDataValue;
1829
+ }
1830
+ data.noDataValue = noDataValue;
1831
+ if (options.returnFileInfo) {
1832
+ result.fileInfo = Lerc2Helpers.formatFileInfo(data);
1833
+ }
1834
+ return result;
1835
+ },
1836
+ getBandCount: function(input) {
1837
+ var count = 0;
1838
+ var i = 0;
1839
+ var temp = {};
1840
+ temp.ptr = 0;
1841
+ temp.pixels = {};
1842
+ while (i < input.byteLength - 58) {
1843
+ Lerc2Helpers.readHeaderInfo(input, temp);
1844
+ i += temp.headerInfo.blobSize;
1845
+ count++;
1846
+ temp.ptr = i;
1847
+ }
1848
+ return count;
1849
+ }
1850
+ };
1851
+ return Lerc2Decode2;
1852
+ }();
1853
+ var isPlatformLittleEndian = function() {
1854
+ var a = new ArrayBuffer(4);
1855
+ var b = new Uint8Array(a);
1856
+ var c = new Uint32Array(a);
1857
+ c[0] = 1;
1858
+ return b[0] === 1;
1859
+ }();
1860
+ var Lerc2 = {
1861
+ /************wrapper**********************************************/
1862
+ /**
1863
+ * A wrapper for decoding both LERC1 and LERC2 byte streams capable of handling multiband pixel blocks for various pixel types.
1864
+ *
1865
+ * @alias module:Lerc
1866
+ * @param {ArrayBuffer} input The LERC input byte stream
1867
+ * @param {object} [options] The decoding options below are optional.
1868
+ * @param {number} [options.inputOffset] The number of bytes to skip in the input byte stream. A valid Lerc file is expected at that position.
1869
+ * @param {string} [options.pixelType] (LERC1 only) Default value is F32. Valid pixel types for input are U8/S8/S16/U16/S32/U32/F32.
1870
+ * @param {number} [options.noDataValue] (LERC1 only). It is recommended to use the returned mask instead of setting this value.
1871
+ * @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...]
1872
+ * @returns {{width, height, pixels, pixelType, mask, statistics}}
1873
+ * @property {number} width Width of decoded image.
1874
+ * @property {number} height Height of decoded image.
1875
+ * @property {array} pixels [band1, band2, …] Each band is a typed array of width*height.
1876
+ * @property {string} pixelType The type of pixels represented in the output.
1877
+ * @property {mask} mask Typed array with a size of width*height, or null if all pixels are valid.
1878
+ * @property {array} statistics [statistics_band1, statistics_band2, …] Each element is a statistics object representing min and max values
1879
+ **/
1880
+ decode: function(encodedData, options) {
1881
+ if (!isPlatformLittleEndian) {
1882
+ throw "Big endian system is not supported.";
1883
+ }
1884
+ options = options || {};
1885
+ var inputOffset = options.inputOffset || 0;
1886
+ var fileIdView = new Uint8Array(encodedData, inputOffset, 10);
1887
+ var fileIdentifierString = String.fromCharCode.apply(null, fileIdView);
1888
+ var lerc, majorVersion;
1889
+ if (fileIdentifierString.trim() === "CntZImage") {
1890
+ lerc = LercDecode2;
1891
+ majorVersion = 1;
1892
+ } else if (fileIdentifierString.substring(0, 5) === "Lerc2") {
1893
+ lerc = Lerc2Decode;
1894
+ majorVersion = 2;
1895
+ } else {
1896
+ throw "Unexpected file identifier string: " + fileIdentifierString;
1897
+ }
1898
+ var iPlane = 0, eof = encodedData.byteLength - 10, encodedMaskData, bandMasks = [], bandMask, maskData;
1899
+ var decodedPixelBlock = {
1900
+ width: 0,
1901
+ height: 0,
1902
+ pixels: [],
1903
+ pixelType: options.pixelType,
1904
+ mask: null,
1905
+ statistics: []
1906
+ };
1907
+ var uniqueBandMaskCount = 0;
1908
+ while (inputOffset < eof) {
1909
+ var result = lerc.decode(encodedData, {
1910
+ inputOffset,
1911
+ //for both lerc1 and lerc2
1912
+ encodedMaskData,
1913
+ //lerc1 only
1914
+ maskData,
1915
+ //lerc2 only
1916
+ returnMask: iPlane === 0 ? true : false,
1917
+ //lerc1 only
1918
+ returnEncodedMask: iPlane === 0 ? true : false,
1919
+ //lerc1 only
1920
+ returnFileInfo: true,
1921
+ //for both lerc1 and lerc2
1922
+ returnPixelInterleavedDims: options.returnPixelInterleavedDims,
1923
+ //for ndim lerc2 only
1924
+ pixelType: options.pixelType || null,
1925
+ //lerc1 only
1926
+ noDataValue: options.noDataValue || null
1927
+ //lerc1 only
1928
+ });
1929
+ inputOffset = result.fileInfo.eofOffset;
1930
+ maskData = result.maskData;
1931
+ if (iPlane === 0) {
1932
+ encodedMaskData = result.encodedMaskData;
1933
+ decodedPixelBlock.width = result.width;
1934
+ decodedPixelBlock.height = result.height;
1935
+ decodedPixelBlock.dimCount = result.dimCount || 1;
1936
+ decodedPixelBlock.pixelType = result.pixelType || result.fileInfo.pixelType;
1937
+ decodedPixelBlock.mask = maskData;
1938
+ }
1939
+ if (majorVersion > 1) {
1940
+ if (maskData) {
1941
+ bandMasks.push(maskData);
1942
+ }
1943
+ if (result.fileInfo.mask && result.fileInfo.mask.numBytes > 0) {
1944
+ uniqueBandMaskCount++;
1945
+ }
1946
+ }
1947
+ iPlane++;
1948
+ decodedPixelBlock.pixels.push(result.pixelData);
1949
+ decodedPixelBlock.statistics.push({
1950
+ minValue: result.minValue,
1951
+ maxValue: result.maxValue,
1952
+ noDataValue: result.noDataValue,
1953
+ dimStats: result.dimStats
1954
+ });
1955
+ }
1956
+ var i, j, numPixels;
1957
+ if (majorVersion > 1 && uniqueBandMaskCount > 1) {
1958
+ numPixels = decodedPixelBlock.width * decodedPixelBlock.height;
1959
+ decodedPixelBlock.bandMasks = bandMasks;
1960
+ maskData = new Uint8Array(numPixels);
1961
+ maskData.set(bandMasks[0]);
1962
+ for (i = 1; i < bandMasks.length; i++) {
1963
+ bandMask = bandMasks[i];
1964
+ for (j = 0; j < numPixels; j++) {
1965
+ maskData[j] = maskData[j] & bandMask[j];
1966
+ }
1967
+ }
1968
+ decodedPixelBlock.maskData = maskData;
1969
+ }
1970
+ return decodedPixelBlock;
1971
+ }
1972
+ };
1973
+ if (module.exports) {
1974
+ module.exports = Lerc2;
1975
+ } else {
1976
+ this.Lerc = Lerc2;
1977
+ }
1978
+ })();
1979
+ })(LercDecode);
1980
+ var LercDecodeExports = LercDecode.exports;
1981
+ const Lerc = /* @__PURE__ */ getDefaultExportFromCjs(LercDecodeExports);
1982
+ class LercDecoder extends BaseDecoder {
1983
+ constructor(fileDirectory) {
1984
+ super();
1985
+ this.planarConfiguration = typeof fileDirectory.PlanarConfiguration !== "undefined" ? fileDirectory.PlanarConfiguration : 1;
1986
+ this.samplesPerPixel = typeof fileDirectory.SamplesPerPixel !== "undefined" ? fileDirectory.SamplesPerPixel : 1;
1987
+ this.addCompression = fileDirectory.LercParameters[LercParameters.AddCompression];
1988
+ }
1989
+ decodeBlock(buffer) {
1990
+ switch (this.addCompression) {
1991
+ case LercAddCompression.None:
1992
+ break;
1993
+ case LercAddCompression.Deflate:
1994
+ buffer = inflate_1(new Uint8Array(buffer)).buffer;
1995
+ break;
1996
+ default:
1997
+ throw new Error(`Unsupported LERC additional compression method identifier: ${this.addCompression}`);
1998
+ }
1999
+ const lercResult = Lerc.decode(buffer, { returnPixelInterleavedDims: this.planarConfiguration === 1 });
2000
+ const lercData = lercResult.pixels[0];
2001
+ return lercData.buffer;
2002
+ }
2003
+ }
2004
+ export {
2005
+ LercDecoder as default
2006
+ };