| |
| |
|
|
| |
| |
| |
|
|
| export function parseOBJ(text) { |
| const P = [], T = [], key = new Map(), pos = [], uv = [], idx = []; |
| let line = 0; |
| const vert = (tok) => { |
| const k = tok; |
| let v = key.get(k); |
| if (v !== undefined) return v; |
| const [a, b] = tok.split('/'); |
| let pi = parseInt(a, 10), ti = parseInt(b, 10); |
| if (!Number.isFinite(pi)) throw new Error(`OBJ line ${line}: bad face vertex "${tok}"`); |
| if (!Number.isFinite(ti)) throw new Error(`OBJ line ${line}: face vertex "${tok}" has no texture coordinate. Every face needs v/vt indices (UVs).`); |
| pi = pi < 0 ? P.length / 3 + pi : pi - 1; |
| ti = ti < 0 ? T.length / 2 + ti : ti - 1; |
| if (pi < 0 || pi * 3 >= P.length) throw new Error(`OBJ line ${line}: vertex index out of range`); |
| if (ti < 0 || ti * 2 >= T.length) throw new Error(`OBJ line ${line}: texture index out of range`); |
| v = pos.length / 3; |
| pos.push(P[pi * 3], P[pi * 3 + 1], P[pi * 3 + 2]); |
| uv.push(T[ti * 2], T[ti * 2 + 1]); |
| key.set(k, v); |
| return v; |
| }; |
| let i0 = 0; |
| while (i0 < text.length) { |
| let i1 = text.indexOf('\n', i0); |
| if (i1 < 0) i1 = text.length; |
| const s = text.slice(i0, i1).trim(); |
| i0 = i1 + 1; line++; |
| if (!s || s[0] === '#') continue; |
| const t = s.split(/\s+/); |
| if (t[0] === 'v') P.push(+t[1], +t[2], +t[3]); |
| else if (t[0] === 'vt') T.push(+t[1], +(t[2] ?? 0)); |
| else if (t[0] === 'f') { |
| const f = t.slice(1).map(vert); |
| for (let k = 1; k + 1 < f.length; k++) idx.push(f[0], f[k], f[k + 1]); |
| } |
| } |
| if (!P.length) throw new Error('OBJ has no vertices ("v" lines).'); |
| if (!T.length) throw new Error('OBJ has no texture coordinates ("vt" lines). The mesh needs UVs to place the image layers.'); |
| if (!idx.length) throw new Error('OBJ has no faces ("f" lines).'); |
| return finish(pos, uv, idx); |
| } |
|
|
| function finish(pos, uv, idx) { |
| const out = { pos: Float32Array.from(pos), uv: Float32Array.from(uv), index: Uint32Array.from(idx) }; |
| out.vertices = out.pos.length / 3; out.faces = out.index.length / 3; |
| for (let i = 0; i < out.pos.length; i++) if (!Number.isFinite(out.pos[i])) throw new Error('The mesh has a vertex with a non-numeric coordinate.'); |
| for (let i = 0; i < out.uv.length; i++) if (!Number.isFinite(out.uv[i])) throw new Error('The mesh has a non-numeric texture coordinate.'); |
| return out; |
| } |
|
|
| const PLY_TYPES = { |
| char: ['getInt8', 1], int8: ['getInt8', 1], uchar: ['getUint8', 1], uint8: ['getUint8', 1], |
| short: ['getInt16', 2], int16: ['getInt16', 2], ushort: ['getUint16', 2], uint16: ['getUint16', 2], |
| int: ['getInt32', 4], int32: ['getInt32', 4], uint: ['getUint32', 4], uint32: ['getUint32', 4], |
| float: ['getFloat32', 4], float32: ['getFloat32', 4], double: ['getFloat64', 8], float64: ['getFloat64', 8], |
| }; |
|
|
| export function parsePLY(buf) { |
| const u8 = new Uint8Array(buf); |
| const head = new TextDecoder().decode(u8.subarray(0, Math.min(u8.length, 8192))); |
| const end = head.indexOf('end_header'); |
| if (!head.startsWith('ply') || end < 0) throw new Error('Not a PLY file (no "ply" header).'); |
| const hlen = head.indexOf('\n', end) + 1; |
| const lines = head.slice(0, hlen).split(/\r?\n/).map((s) => s.trim()).filter(Boolean); |
| let fmt = null; const els = []; |
| for (const l of lines) { |
| const t = l.split(/\s+/); |
| if (t[0] === 'format') fmt = t[1]; |
| else if (t[0] === 'element') els.push({ name: t[1], n: +t[2], props: [] }); |
| else if (t[0] === 'property') { |
| const e = els[els.length - 1]; |
| if (t[1] === 'list') e.props.push({ list: true, ct: t[2], it: t[3], name: t[4] }); |
| else e.props.push({ type: t[1], name: t[2] }); |
| } |
| } |
| if (!['ascii', 'binary_little_endian', 'binary_big_endian'].includes(fmt)) throw new Error(`PLY format "${fmt}" is not supported.`); |
| const V = els.find((e) => e.name === 'vertex'); |
| if (!V) throw new Error('PLY has no vertex element.'); |
| const pn = V.props.map((p) => p.name); |
| const uName = ['u', 's', 'texture_u', 'texture_s'].find((n) => pn.includes(n)); |
| const vName = ['v', 't', 'texture_v', 'texture_t'].find((n) => pn.includes(n)); |
| if (!uName || !vName) throw new Error('PLY vertices have no texture coordinates (u, v or s, t). The mesh needs UVs to place the image layers.'); |
| const pos = new Float32Array(V.n * 3), uv = new Float32Array(V.n * 2), idx = []; |
| const store = (e, i, rec) => { |
| if (e === V) { |
| pos[i * 3] = rec.x; pos[i * 3 + 1] = rec.y; pos[i * 3 + 2] = rec.z; |
| uv[i * 2] = rec[uName]; uv[i * 2 + 1] = rec[vName]; |
| } else if (e.name === 'face') { |
| const f = rec.vertex_indices || rec.vertex_index; |
| if (!f) throw new Error('PLY faces have no vertex_indices list.'); |
| for (let k = 1; k + 1 < f.length; k++) idx.push(f[0], f[k], f[k + 1]); |
| } |
| }; |
| if (fmt === 'ascii') { |
| const body = new TextDecoder().decode(u8.subarray(hlen)).split(/\s+/).filter(Boolean); |
| let p = 0; |
| for (const e of els) for (let i = 0; i < e.n; i++) { |
| const rec = {}; |
| for (const pr of e.props) { |
| if (pr.list) { const n = +body[p++]; rec[pr.name] = body.slice(p, p + n).map(Number); p += n; } |
| else rec[pr.name] = +body[p++]; |
| } |
| store(e, i, rec); |
| } |
| } else { |
| const dv = new DataView(buf, 0), le = fmt === 'binary_little_endian'; |
| let o = hlen; |
| const rd = (type) => { const [fn, n] = PLY_TYPES[type] || []; if (!fn) throw new Error(`PLY type "${type}" is not supported.`); const v = dv[fn](o, le); o += n; return v; }; |
| for (const e of els) for (let i = 0; i < e.n; i++) { |
| const rec = {}; |
| for (const pr of e.props) { |
| if (pr.list) { const n = rd(pr.ct); const a = new Array(n); for (let k = 0; k < n; k++) a[k] = rd(pr.it); rec[pr.name] = a; } |
| else rec[pr.name] = rd(pr.type); |
| } |
| if (o > buf.byteLength) throw new Error('PLY file ends early.'); |
| store(e, i, rec); |
| } |
| } |
| for (const k of idx) if (k >= V.n) throw new Error('PLY face index out of range.'); |
| if (!idx.length) throw new Error('PLY has no faces.'); |
| return finish(pos, uv, idx); |
| } |
|
|
| |
| |
| |
|
|
| export async function decodeTIFF(buf, maxSide = 8192) { |
| const dv = new DataView(buf); |
| const bo = dv.getUint16(0); |
| if (bo !== 0x4949 && bo !== 0x4d4d) throw new Error('Not a TIFF file.'); |
| const le = bo === 0x4949; |
| if (dv.getUint16(2, le) === 43) throw new Error('BigTIFF is not supported; save as a standard TIFF or PNG.'); |
| const ifd = dv.getUint32(4, le); |
| const n = dv.getUint16(ifd, le); |
| const tags = {}; |
| const SZ = { 1: 1, 2: 1, 3: 2, 4: 4, 5: 8, 6: 1, 7: 1, 8: 2, 9: 4, 10: 8, 11: 4, 12: 8, 16: 8 }; |
| for (let i = 0; i < n; i++) { |
| const e = ifd + 2 + i * 12; |
| const tag = dv.getUint16(e, le), type = dv.getUint16(e + 2, le), cnt = dv.getUint32(e + 4, le); |
| const size = (SZ[type] || 1) * cnt; |
| const off = size <= 4 ? e + 8 : dv.getUint32(e + 8, le); |
| const vals = []; |
| for (let k = 0; k < Math.min(cnt, 1 << 20); k++) { |
| if (type === 3) vals.push(dv.getUint16(off + k * 2, le)); |
| else if (type === 4) vals.push(dv.getUint32(off + k * 4, le)); |
| else if (type === 1 || type === 7) vals.push(dv.getUint8(off + k)); |
| else if (type === 16) vals.push(Number(dv.getBigUint64(off + k * 8, le))); |
| else break; |
| } |
| tags[tag] = vals; |
| } |
| const W = tags[256]?.[0], H = tags[257]?.[0]; |
| if (!W || !H) throw new Error('TIFF has no width or height.'); |
| if (W > maxSide || H > maxSide) throw new Error(`TIFF is ${W} x ${H} px; the limit is ${maxSide} px on a side.`); |
| const bps = tags[258]?.[0] || 1, spp = tags[277]?.[0] || 1, comp = tags[259]?.[0] || 1; |
| const pred = tags[317]?.[0] || 1, fmt = tags[339]?.[0] || 1, photo = tags[262]?.[0] ?? 1; |
| if (![8, 16, 32].includes(bps)) throw new Error(`TIFF with ${bps} bits per sample is not supported (use 8, 16 or 32).`); |
| if ((tags[284]?.[0] || 1) !== 1 && spp > 1) throw new Error('Planar TIFF is not supported.'); |
| if (photo === 3) throw new Error('Palette TIFF is not supported.'); |
| const tiled = !!tags[322]; |
| const tw = tiled ? tags[322][0] : W, th = tiled ? tags[323][0] : (tags[278]?.[0] || H); |
| const offs = tiled ? tags[324] : tags[273], cnts = tiled ? tags[325] : tags[279]; |
| if (!offs || !cnts) throw new Error('TIFF has no image data offsets.'); |
| const B = bps / 8, rowB = tw * spp * B; |
| const raw = new Uint8Array(W * H * spp * B); |
| const across = Math.ceil(W / tw); |
| for (let c = 0; c < offs.length; c++) { |
| let chunk = new Uint8Array(buf, offs[c], cnts[c]); |
| if (comp === 5) chunk = lzw(chunk, rowB * th); |
| else if (comp === 8 || comp === 32946) chunk = await inflate(chunk, 'deflate'); |
| else if (comp === 32773) chunk = packbits(chunk, rowB * th); |
| else if (comp !== 1) throw new Error(`TIFF compression ${comp} is not supported (use none, LZW or Deflate).`); |
| const x0 = tiled ? (c % across) * tw : 0, y0 = tiled ? Math.floor(c / across) * th : c * th; |
| for (let y = 0; y < th && y0 + y < H; y++) { |
| const row = chunk.subarray(y * rowB, (y + 1) * rowB); |
| if (pred === 2) { |
| if (B === 1) for (let i = spp; i < row.length; i++) row[i] = (row[i] + row[i - spp]) & 255; |
| else if (B === 2) { const d = new DataView(row.buffer, row.byteOffset, row.length); for (let i = spp; i < tw * spp; i++) d.setUint16(i * 2, (d.getUint16(i * 2, le) + d.getUint16((i - spp) * 2, le)) & 65535, le); } |
| } |
| const w = Math.min(tw, W - x0) * spp * B; |
| raw.set(row.subarray(0, w), ((y0 + y) * W + x0) * spp * B); |
| } |
| } |
| |
| const N = W * H, d = new DataView(raw.buffer); |
| const get = B === 1 ? (i) => raw[i] : B === 2 ? (i) => d.getUint16(i * 2, le) |
| : fmt === 3 ? (i) => d.getFloat32(i * 4, le) : (i) => d.getUint32(i * 4, le); |
| let lo = 0, hi = 255; |
| if (B > 1) { |
| lo = Infinity; hi = -Infinity; |
| for (let i = 0; i < N * spp; i += Math.max(1, Math.floor(N * spp / 200000))) { const v = get(i); if (Number.isFinite(v)) { if (v < lo) lo = v; if (v > hi) hi = v; } } |
| if (!(hi > lo)) { lo = 0; hi = 1; } |
| } |
| const k = 255 / (hi - lo); |
| const out = new Uint8ClampedArray(N * 4); |
| for (let p = 0; p < N; p++) { |
| const s = p * spp; |
| const r = (get(s) - lo) * k; |
| const g = spp >= 3 ? (get(s + 1) - lo) * k : r, b = spp >= 3 ? (get(s + 2) - lo) * k : r; |
| const a = spp === 4 ? (get(s + 3) - lo) * k : spp === 2 ? (get(s + 1) - lo) * k : 255; |
| const inv = photo === 0 ? 255 : 0; |
| out[p * 4] = Math.abs(inv - r); out[p * 4 + 1] = Math.abs(inv - g); out[p * 4 + 2] = Math.abs(inv - b); out[p * 4 + 3] = a; |
| } |
| return new ImageData(out, W, H); |
| } |
|
|
| function lzw(src, expect) { |
| const out = new Uint8Array(Math.max(expect, 16)); |
| let o = 0, bit = 0, size = 9; |
| let dict = []; |
| const reset = () => { dict = []; for (let i = 0; i < 256; i++) dict.push([i]); dict.push(null, null); size = 9; }; |
| const read = () => { |
| let v = 0; |
| for (let i = 0; i < size; i++) { const B = src[(bit + i) >> 3]; v = (v << 1) | ((B >> (7 - ((bit + i) & 7))) & 1); } |
| bit += size; return v; |
| }; |
| reset(); |
| let prev = null; |
| while ((bit + size) <= src.length * 8) { |
| const c = read(); |
| if (c === 257) break; |
| if (c === 256) { reset(); prev = null; continue; } |
| let e; |
| if (c < dict.length && dict[c]) e = dict[c]; |
| else if (prev) e = prev.concat(prev[0]); |
| else throw new Error('Damaged LZW data in TIFF.'); |
| for (const x of e) { if (o < out.length) out[o++] = x; } |
| if (prev) dict.push(prev.concat(e[0])); |
| prev = e; |
| if (dict.length + 1 >= (1 << size) && size < 12) size++; |
| } |
| return out; |
| } |
|
|
| function packbits(src, expect) { |
| const out = new Uint8Array(expect); let o = 0, i = 0; |
| while (i < src.length && o < expect) { |
| const n = (src[i++] << 24) >> 24; |
| if (n >= 0) { for (let k = 0; k <= n; k++) out[o++] = src[i++]; } |
| else if (n !== -128) { const v = src[i++]; for (let k = 0; k < 1 - n; k++) out[o++] = v; } |
| } |
| return out; |
| } |
|
|
| async function inflate(bytes, fmt) { |
| const ds = new DecompressionStream(fmt); |
| const r = new Response(new Blob([bytes]).stream().pipeThrough(ds)); |
| return new Uint8Array(await r.arrayBuffer()); |
| } |
|
|
| |
|
|
| export async function readZip(buf, limits) { |
| const u8 = new Uint8Array(buf), dv = new DataView(buf); |
| let eocd = -1; |
| for (let i = u8.length - 22; i >= Math.max(0, u8.length - 65557); i--) if (dv.getUint32(i, true) === 0x06054b50) { eocd = i; break; } |
| if (eocd < 0) throw new Error('This is not a zip file, or it is damaged.'); |
| const count = dv.getUint16(eocd + 10, true); |
| let p = dv.getUint32(eocd + 16, true); |
| const files = []; |
| let total = 0; |
| for (let n = 0; n < count; n++) { |
| if (dv.getUint32(p, true) !== 0x02014b50) throw new Error('Damaged zip directory.'); |
| const method = dv.getUint16(p + 10, true), csize = dv.getUint32(p + 20, true), usize = dv.getUint32(p + 24, true); |
| const nl = dv.getUint16(p + 28, true), xl = dv.getUint16(p + 30, true), cl = dv.getUint16(p + 32, true); |
| const flags = dv.getUint16(p + 8, true); |
| const lho = dv.getUint32(p + 42, true); |
| const name = new TextDecoder().decode(u8.subarray(p + 46, p + 46 + nl)); |
| p += 46 + nl + xl + cl; |
| if (name.endsWith('/')) continue; |
| if (flags & 1) throw new Error(`${name} in the zip is encrypted.`); |
| if (usize === 0xffffffff || csize === 0xffffffff) throw new Error('Zip64 archives are not supported.'); |
| if (limits && usize > limits.maxFileBytes) throw new Error(`${name} is ${(usize / 1e6).toFixed(1)} MB unzipped; the limit per file is ${(limits.maxFileBytes / 1048576).toFixed(0)} MB.`); |
| total += usize; |
| if (limits && total > limits.maxTotalBytes) throw new Error(`The zip unpacks to more than ${(limits.maxTotalBytes / 1048576).toFixed(0)} MB.`); |
| const ln = dv.getUint16(lho + 26, true), lx = dv.getUint16(lho + 28, true); |
| const data = u8.subarray(lho + 30 + ln + lx, lho + 30 + ln + lx + csize); |
| let bytes; |
| if (method === 0) bytes = data.slice(); |
| else if (method === 8) bytes = await inflate(data, 'deflate-raw'); |
| else throw new Error(`${name} uses zip compression method ${method}; only stored and deflated files are supported.`); |
| files.push({ name, blob: new Blob([bytes]), size: bytes.length }); |
| } |
| return files; |
| } |
|
|
| const CRC = (() => { const t = new Uint32Array(256); for (let n = 0; n < 256; n++) { let c = n; for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1; t[n] = c >>> 0; } return t; })(); |
| function crc32(u8) { let c = 0xffffffff; for (let i = 0; i < u8.length; i++) c = CRC[(c ^ u8[i]) & 255] ^ (c >>> 8); return (c ^ 0xffffffff) >>> 0; } |
|
|
| |
| export function writeZip(entries) { |
| const enc = new TextEncoder(); |
| const parts = [], cen = []; |
| let off = 0; |
| for (const e of entries) { |
| const name = enc.encode(e.name), crc = crc32(e.bytes), n = e.bytes.length; |
| const h = new DataView(new ArrayBuffer(30)); |
| h.setUint32(0, 0x04034b50, true); h.setUint16(4, 20, true); h.setUint16(6, 0x0800, true); |
| h.setUint32(14, crc, true); h.setUint32(18, n, true); h.setUint32(22, n, true); h.setUint16(26, name.length, true); |
| parts.push(new Uint8Array(h.buffer), name, e.bytes); |
| const c = new DataView(new ArrayBuffer(46)); |
| c.setUint32(0, 0x02014b50, true); c.setUint16(4, 20, true); c.setUint16(6, 20, true); c.setUint16(8, 0x0800, true); |
| c.setUint32(16, crc, true); c.setUint32(20, n, true); c.setUint32(24, n, true); c.setUint16(28, name.length, true); c.setUint32(42, off, true); |
| cen.push(new Uint8Array(c.buffer), name); |
| off += 30 + name.length + n; |
| } |
| const csz = cen.reduce((a, b) => a + b.length, 0); |
| const z = new DataView(new ArrayBuffer(22)); |
| z.setUint32(0, 0x06054b50, true); z.setUint16(8, entries.length, true); z.setUint16(10, entries.length, true); |
| z.setUint32(12, csz, true); z.setUint32(16, off, true); |
| return new Blob([...parts, ...cen, new Uint8Array(z.buffer)], { type: 'application/zip' }); |
| } |
|
|
| |
| |
| |
| export function unshuffleInt16(planes) { |
| const b = new Uint8Array(planes), n = b.length >> 1; |
| if (b.length & 1) throw new Error('packed int16 data has an odd length'); |
| const out = new Uint8Array(b.length); |
| for (let i = 0; i < n; i++) { out[2 * i] = b[i]; out[2 * i + 1] = b[n + i]; } |
| return out.buffer; |
| } |
| export async function gunzip(buf) { |
| const s = new Blob([buf]).stream().pipeThrough(new DecompressionStream('gzip')); |
| return new Response(s).arrayBuffer(); |
| } |
| export async function unpackInt16(buf) { return unshuffleInt16(await gunzip(buf)); } |
|
|
