@niivue/niivue
Version:
minimal webgl2 nifti image viewer
681 lines (624 loc) • 29.3 kB
text/typescript
import arrayEqual from 'array-equal'
import { mat4, vec3, vec4 } from 'gl-matrix'
// TODO: TypedNumberArray also in nvmesh-types.ts
type TypedNumberArray = Float64Array | Float32Array | Uint32Array | Uint16Array | Uint8Array | Int32Array | Int16Array | Int8Array
/**
* Namespace for utility functions
* @ignore
*/
/**
* Read ZIP files using asynchronous compression streams API, supports data descriptors
* todo: check ZIP64 support
* https://github.com/libyal/assorted/blob/main/documentation/ZIP%20archive%20format.asciidoc
* https://en.wikipedia.org/wiki/ZIP_(file_format)
* https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
* https://dev.to/ndesmic/writing-a-simple-browser-zip-file-decompressor-with-compressionstreams-5che
*/
interface Entry {
signature: string
version: number
generalPurpose: number
compressionMethod: number
lastModifiedTime: number
lastModifiedDate: number
crc: number
compressedSize: number
uncompressedSize: number
fileNameLength: number
extraLength: number
fileName: string
extra: string
startsAt?: number
extract?: () => Promise<Uint8Array>
}
interface CentralDirectoryEntry {
versionCreated: number
versionNeeded: number
fileCommentLength: number
diskNumber: number
internalAttributes: number
externalAttributes: number
offset: number
comments: string
fileNameLength: number
extraLength: number
}
interface EndOfCentralDirectory {
numberOfDisks: number
centralDirectoryStartDisk: number
numberCentralDirectoryRecordsOnThisDisk: number
numberCentralDirectoryRecords: number
centralDirectorySize: number
centralDirectoryOffset: number
commentLength: number
comment: string
}
export class Zip {
#dataView: DataView
#index: number = 0
#localFiles: Entry[] = []
#centralDirectories: CentralDirectoryEntry[] = []
#endOfCentralDirectory?: EndOfCentralDirectory
constructor(arrayBuffer: ArrayBuffer) {
this.#dataView = new DataView(arrayBuffer)
this.read()
}
async extract(entry: Entry): Promise<Uint8Array> {
const buffer = new Uint8Array(this.#dataView.buffer.slice(entry.startsAt!, entry.startsAt! + entry.compressedSize))
if (entry.compressionMethod === 0x00) {
return buffer
} else if (entry.compressionMethod === 0x08) {
const stream = new DecompressionStream('deflate-raw')
const writer = stream.writable.getWriter()
writer.write(buffer).catch(console.error)
const closePromise = writer.close().catch(console.error)
const response = new Response(stream.readable)
const result = new Uint8Array(await response.arrayBuffer())
await closePromise
return result
}
throw new Error(`Unsupported compression method: ${entry.compressionMethod}`)
}
private read(): void {
while (!this.#endOfCentralDirectory && this.#index < this.#dataView.byteLength) {
const signature = this.#dataView.getUint32(this.#index, true)
if (signature === 0x04034b50) {
const entry = this.readLocalFile(this.#index)
entry.extract = this.extract.bind(this, entry)
this.#localFiles.push(entry)
const hasDataDescriptor = (entry.generalPurpose & 0x0008) !== 0
entry.startsAt = this.#index + 30 + entry.fileNameLength + entry.extraLength
if (entry.compressedSize === 0 && hasDataDescriptor) {
let scanIndex = entry.startsAt
while (scanIndex! + 20 <= this.#dataView.byteLength) {
const possibleSignature = this.#dataView.getUint32(scanIndex!, true)
if (possibleSignature === 0x08074b50) {
const nextPK = this.#dataView.getUint16(scanIndex! + 16, true) === 0x4b50
if (nextPK) {
scanIndex! += 4
break
}
}
scanIndex!++
}
entry.crc = this.#dataView.getUint32(scanIndex!, true)
entry.compressedSize = this.#dataView.getUint32(scanIndex! + 4, true)
entry.uncompressedSize = this.#dataView.getUint32(scanIndex! + 8, true)
this.#index = scanIndex! + 12
} else {
this.#index = entry.startsAt + entry.compressedSize
}
} else if (signature === 0x02014b50) {
const entry = this.readCentralDirectory(this.#index)
this.#centralDirectories.push(entry)
this.#index += 46 + entry.fileNameLength + entry.extraLength + entry.fileCommentLength
} else if (signature === 0x06054b50) {
this.#endOfCentralDirectory = this.readEndCentralDirectory(this.#index)
break
} else if (signature === 0x06064b50) {
this.#endOfCentralDirectory = this.readEndCentralDirectory64(this.#index)
break
} else {
console.error(`Unexpected ZIP signature 0x${signature.toString(16).padStart(8, '0')} at index ${this.#index}`)
break
}
}
}
private readLocalFile(offset: number): Entry {
let compressedSize = this.#dataView.getUint32(offset + 18, true)
let uncompressedSize = this.#dataView.getUint32(offset + 22, true)
const fileNameLength = this.#dataView.getUint16(offset + 26, true)
const extraLength = this.#dataView.getUint16(offset + 28, true)
const extraOffset = offset + 30 + fileNameLength
const extra = this.readString(extraOffset, extraLength)
if (compressedSize === 0xffffffff && uncompressedSize === 0xffffffff) {
let zip64Offset = extraOffset
let foundZip64 = false
while (zip64Offset < extraOffset + extraLength - 4) {
const fieldSignature = this.#dataView.getUint16(zip64Offset, true)
const fieldLength = this.#dataView.getUint16(zip64Offset + 2, true)
zip64Offset += 4 // Move past signature and length
if (fieldSignature === 0x0001) {
// ZIP64 Extended Information Extra Field
if (fieldLength >= 16) {
// Ensure we have enough bytes
uncompressedSize = Number(this.#dataView.getBigUint64(zip64Offset, true))
zip64Offset += 8
compressedSize = Number(this.#dataView.getBigUint64(zip64Offset, true))
foundZip64 = true
break
} else {
throw new Error(`ZIP64 extra field found but is too small (expected at least 16 bytes, got ${fieldLength}).`)
}
}
zip64Offset += fieldLength // Move to the next extra field
}
if (!foundZip64) {
throw new Error('ZIP64 format missing extra field with signature 0x0001.')
}
}
return {
signature: this.readString(offset, 4),
version: this.#dataView.getUint16(offset + 4, true),
generalPurpose: this.#dataView.getUint16(offset + 6, true),
compressionMethod: this.#dataView.getUint16(offset + 8, true),
lastModifiedTime: this.#dataView.getUint16(offset + 10, true),
lastModifiedDate: this.#dataView.getUint16(offset + 12, true),
crc: this.#dataView.getUint32(offset + 14, true),
compressedSize,
uncompressedSize,
fileNameLength,
extraLength,
fileName: this.readString(offset + 30, fileNameLength),
extra: this.readString(offset + 30 + fileNameLength, extraLength)
}
}
private readCentralDirectory(offset: number): CentralDirectoryEntry {
return {
versionCreated: this.#dataView.getUint16(offset + 4, true),
versionNeeded: this.#dataView.getUint16(offset + 6, true),
fileNameLength: this.#dataView.getUint16(offset + 28, true),
extraLength: this.#dataView.getUint16(offset + 30, true),
fileCommentLength: this.#dataView.getUint16(offset + 32, true),
diskNumber: this.#dataView.getUint16(offset + 34, true),
internalAttributes: this.#dataView.getUint16(offset + 36, true),
externalAttributes: this.#dataView.getUint32(offset + 38, true),
offset: this.#dataView.getUint32(offset + 42, true),
comments: this.readString(offset + 46, this.#dataView.getUint16(offset + 32, true))
}
}
private readEndCentralDirectory(offset: number): EndOfCentralDirectory {
const commentLength = this.#dataView.getUint16(offset + 20, true)
return {
numberOfDisks: this.#dataView.getUint16(offset + 4, true),
centralDirectoryStartDisk: this.#dataView.getUint16(offset + 6, true),
numberCentralDirectoryRecordsOnThisDisk: this.#dataView.getUint16(offset + 8, true),
numberCentralDirectoryRecords: this.#dataView.getUint16(offset + 10, true),
centralDirectorySize: this.#dataView.getUint32(offset + 12, true),
centralDirectoryOffset: this.#dataView.getUint32(offset + 16, true),
commentLength,
comment: this.readString(offset + 22, commentLength)
}
}
private readEndCentralDirectory64(offset: number): EndOfCentralDirectory {
const commentLength = Number(this.#dataView.getBigUint64(offset + 0, true))
return {
numberOfDisks: this.#dataView.getUint32(offset + 16, true),
centralDirectoryStartDisk: this.#dataView.getUint32(offset + 20, true),
numberCentralDirectoryRecordsOnThisDisk: Number(this.#dataView.getBigUint64(offset + 24, true)),
numberCentralDirectoryRecords: Number(this.#dataView.getBigUint64(offset + 32, true)),
centralDirectorySize: Number(this.#dataView.getBigUint64(offset + 40, true)),
centralDirectoryOffset: Number(this.#dataView.getBigUint64(offset + 48, true)),
commentLength,
comment: ''
}
}
private readString(offset: number, length: number): string {
return Array.from({ length }, (_, i) => String.fromCharCode(this.#dataView.getUint8(offset + i))).join('')
}
get entries(): Entry[] {
return this.#localFiles
}
}
export class NVUtilities {
static arrayBufferToBase64(arrayBuffer: ArrayBuffer): string {
const bytes = new Uint8Array(arrayBuffer)
return NVUtilities.uint8tob64(bytes)
}
static async decompress(data: Uint8Array): Promise<Uint8Array> {
const format =
data[0] === 31 && data[1] === 139 && data[2] === 8 ? 'gzip' : data[0] === 120 && (data[1] === 1 || data[1] === 94 || data[1] === 156 || data[1] === 218) ? 'deflate' : 'deflate-raw'
const stream = new DecompressionStream(format)
const writer = stream.writable.getWriter()
writer.write(data).catch(console.error) // Do not await this
// Close without awaiting directly, preventing the hang issue
const closePromise = writer.close().catch(console.error)
const response = new Response(stream.readable)
const result = new Uint8Array(await response.arrayBuffer())
await closePromise // Ensure close happens eventually
return result
}
static async decompressToBuffer(data: Uint8Array): Promise<ArrayBuffer> {
const decompressed = await NVUtilities.decompress(data)
return decompressed.buffer.slice(decompressed.byteOffset, decompressed.byteOffset + decompressed.byteLength)
}
static async readMatV4(buffer: ArrayBuffer, isReplaceDots: boolean = false): Promise<Record<string, TypedNumberArray>> {
let len = buffer.byteLength
if (len < 40) {
throw new Error('File too small to be MAT v4: bytes = ' + buffer.byteLength)
}
let reader = new DataView(buffer)
let magic = reader.getUint16(0, true)
let _buffer = buffer
if (magic === 35615 || magic === 8075) {
// gzip signature 0x1F8B in little and big endian
const raw = await this.decompress(new Uint8Array(buffer))
reader = new DataView(raw.buffer)
magic = reader.getUint16(0, true)
_buffer = raw.buffer
len = _buffer.byteLength
}
const textDecoder = new TextDecoder('utf-8')
const bytes = new Uint8Array(_buffer)
let pos = 0
const mat: Record<string, TypedNumberArray> = {}
function getTensDigit(v: number): number {
return Math.floor(v / 10) % 10
}
function readArray(tagDataType: number, tagBytesStart: number, tagBytesEnd: number): TypedNumberArray {
const byteArray = new Uint8Array(bytes.subarray(tagBytesStart, tagBytesEnd))
if (tagDataType === 1) {
return new Float32Array(byteArray.buffer)
}
if (tagDataType === 2) {
return new Int32Array(byteArray.buffer)
}
if (tagDataType === 3) {
return new Int16Array(byteArray.buffer)
}
if (tagDataType === 4) {
return new Uint16Array(byteArray.buffer)
}
if (tagDataType === 5) {
return new Uint8Array(byteArray.buffer)
}
return new Float64Array(byteArray.buffer)
}
function readTag(): void {
const mtype = reader.getUint32(pos, true)
const mrows = reader.getUint32(pos + 4, true)
const ncols = reader.getUint32(pos + 8, true)
const imagf = reader.getUint32(pos + 12, true)
const namlen = reader.getUint32(pos + 16, true)
pos += 20 // skip header
if (imagf !== 0) {
throw new Error('Matlab V4 reader does not support imaginary numbers')
}
const tagArrayItems = mrows * ncols
if (tagArrayItems < 1) {
throw new Error('mrows * ncols must be greater than one')
}
const byteArray = new Uint8Array(bytes.subarray(pos, pos + namlen))
let tagName = textDecoder.decode(byteArray).trim().replaceAll('\x00', '')
// n.b. DSI studio have array mat.dti_fa[] and mat.dti_fa.slope
if (isReplaceDots) {
// kludge for invalid DSIstudio FZ files
tagName = tagName.replaceAll('.', '_')
}
const tagDataType = getTensDigit(mtype)
// 0 double-precision (64-bit) floating-point numbers
// 1 single-precision (32-bit) floating-point numbers
// 2 32-bit signed integers
// 3 16-bit signed integers
// 4 16-bit unsigned integers
// 5 8-bit unsigned integers
let tagBytesPerItem = 8
if (tagDataType >= 1 && tagDataType <= 2) {
tagBytesPerItem = 4
} else if (tagDataType >= 3 && tagDataType <= 4) {
tagBytesPerItem = 2
} else if (tagDataType === 5) {
tagBytesPerItem = 1
} else if (tagDataType !== 0) {
throw new Error('impossible Matlab v4 datatype')
}
pos += namlen // skip name
if (mtype > 50) {
throw new Error('Does not appear to be little-endian V4 Matlab file')
}
const posEnd = pos + tagArrayItems * tagBytesPerItem
mat[tagName] = readArray(tagDataType, pos, posEnd)
pos = posEnd
}
while (pos + 20 < len) {
readTag()
}
return mat
} // readMatV4()
static b64toUint8(base64: string): Uint8Array {
const binaryString = atob(base64)
const length = binaryString.length
const bytes = new Uint8Array(length)
for (let i = 0; i < length; i++) {
bytes[i] = binaryString.charCodeAt(i)
}
return bytes
}
/*
https://gist.github.com/jonleighton/958841
MIT LICENSE
Copyright 2011 Jon Leighton
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
static uint8tob64(bytes: Uint8Array): string {
// TODO: use TextDecoder instead of shipping own implementation
let base64 = ''
const encodings = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
const byteLength = bytes.byteLength
const byteRemainder = byteLength % 3
const mainLength = byteLength - byteRemainder
let a, b, c, d
let chunk
// Main loop deals with bytes in chunks of 3
for (let i = 0; i < mainLength; i = i + 3) {
// Combine the three bytes into a single integer
chunk = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2]
// Use bitmasks to extract 6-bit segments from the triplet
a = (chunk & 16515072) >> 18 // 16515072 = (2^6 - 1) << 18
b = (chunk & 258048) >> 12 // 258048 = (2^6 - 1) << 12
c = (chunk & 4032) >> 6 // 4032 = (2^6 - 1) << 6
d = chunk & 63 // 63 = 2^6 - 1
// Convert the raw binary segments to the appropriate ASCII encoding
base64 += encodings[a] + encodings[b] + encodings[c] + encodings[d]
}
// Deal with the remaining bytes and padding
if (byteRemainder === 1) {
chunk = bytes[mainLength]
a = (chunk & 252) >> 2 // 252 = (2^6 - 1) << 2
// Set the 4 least significant bits to zero
b = (chunk & 3) << 4 // 3 = 2^2 - 1
base64 += encodings[a] + encodings[b] + '=='
} else if (byteRemainder === 2) {
chunk = (bytes[mainLength] << 8) | bytes[mainLength + 1]
a = (chunk & 64512) >> 10 // 64512 = (2^6 - 1) << 10
b = (chunk & 1008) >> 4 // 1008 = (2^6 - 1) << 4
// Set the 2 least significant bits to zero
c = (chunk & 15) << 2 // 15 = 2^4 - 1
base64 += encodings[a] + encodings[b] + encodings[c] + '='
}
return base64
}
// https://stackoverflow.com/questions/34156282/how-do-i-save-json-to-local-text-file
static download(content: string | ArrayBuffer, fileName: string, contentType: string): void {
const a = document.createElement('a')
const contentArray = Array.isArray(content) ? content : [content]
const file = new Blob(contentArray, { type: contentType })
a.href = URL.createObjectURL(file)
a.download = fileName
a.click()
}
static readFileAsync(file: Blob): Promise<ArrayBuffer> {
return new Promise((resolve, reject) => {
const reader = new FileReader()
reader.onload = (): void => {
resolve(reader.result as ArrayBuffer)
}
reader.onerror = reject
reader.readAsArrayBuffer(file)
})
}
static blobToBase64(blob: Blob): Promise<string> {
return new Promise((resolve) => {
const reader = new FileReader()
reader.onloadend = (): void => resolve(reader.result as string)
reader.readAsDataURL(blob)
})
}
static async decompressBase64String(base64: string): Promise<string> {
const compressed = atob(base64)
// convert to an array buffer
const compressedBuffer = new ArrayBuffer(compressed.length)
const compressedView = new Uint8Array(compressedBuffer)
for (let i = 0; i < compressed.length; i++) {
compressedView[i] = compressed.charCodeAt(i)
}
return NVUtilities.decompressArrayBuffer(compressedView)
}
static async compressToBase64String(string: string): Promise<string> {
const buf = await NVUtilities.compressStringToArrayBuffer(string)
return NVUtilities.uint8tob64(new Uint8Array(buf))
}
/**
* Converts a string into a Uint8Array for use with compression/decompression methods (101arrowz/fflate: MIT License)
* @param str The string to encode
* @param latin1 Whether or not to interpret the data as Latin-1. This should
* not need to be true unless decoding a binary string.
* @returns The string encoded in UTF-8/Latin-1 binary
*/
static strToU8(str: string, latin1?: boolean): Uint8Array {
if (latin1) {
const ar = new Uint8Array(str.length)
for (let i = 0; i < str.length; ++i) {
ar[i] = str.charCodeAt(i)
}
return ar
}
const l = str.length
// TODO: strToU8 and strFromU8 both define slc
// typed array slice - allows garbage collector to free original reference,
// while being more compatible than .slice
const slc = (v: Uint8Array, s: number, e?: number): Uint8Array => {
if (s == null || s < 0) {
s = 0
}
if (e == null || e > v.length) {
e = v.length
}
// can't use .constructor in case user-supplied
return new Uint8Array(v.subarray(s, e))
}
let ar = new Uint8Array(str.length + (str.length >> 1))
let ai = 0
const w = (v: number): void => {
ar[ai++] = v
}
for (let i = 0; i < l; ++i) {
if (ai + 5 > ar.length) {
const n = new Uint8Array(ai + 8 + ((l - i) << 1))
n.set(ar)
ar = n
}
let c = str.charCodeAt(i)
if (c < 128 || latin1) {
w(c)
} else if (c < 2048) {
w(192 | (c >> 6))
w(128 | (c & 63))
} else if (c > 55295 && c < 57344) {
c = (65536 + (c & (1023 << 10))) | (str.charCodeAt(++i) & 1023)
w(240 | (c >> 18))
w(128 | ((c >> 12) & 63))
w(128 | ((c >> 6) & 63))
w(128 | (c & 63))
} else {
c = (65536 + (c & (1023 << 10))) | (str.charCodeAt(++i) & 1023)
w(240 | (c >> 18))
w(128 | ((c >> 12) & 63))
w(128 | ((c >> 6) & 63))
w(128 | (c & 63))
}
}
return slc(ar, 0, ai)
}
static async compress(data: Uint8Array, format: CompressionFormat = 'gzip'): Promise<ArrayBuffer> {
// mimics fflate, use 'deflate-raw' 'deflate' or 'gzip' if needed
// const format = 'deflate-raw'
const stream = new CompressionStream(format)
const writer = stream.writable.getWriter()
writer.write(data).catch(console.error) // Do not await this
const closePromise = writer.close().catch(console.error)
const response = new Response(stream.readable)
const result = await response.arrayBuffer()
await closePromise // Ensure close happens eventually
return result
}
static async compressStringToArrayBuffer(input: string): Promise<ArrayBuffer> {
const uint8Array = this.strToU8(input)
return await this.compress(uint8Array)
}
static isArrayBufferCompressed(buffer: ArrayBuffer): boolean {
if (buffer && buffer.byteLength) {
const arr = new Uint8Array(buffer)
const magicNumber = (arr[0] << 8) | arr[1]
return magicNumber === 0x1f8b
} else {
return false
}
}
/**
* Converts a Uint8Array to a string (101arrowz/fflate: MIT License)
* @param dat The data to decode to string
* @param latin1 Whether or not to interpret the data as Latin-1. This should
* not need to be true unless encoding to binary string.
* @returns The original UTF-8/Latin-1 string
*/
static strFromU8(dat: Uint8Array, latin1?: boolean): string {
if (latin1) {
let r = ''
for (let i = 0; i < dat.length; i += 16384) {
r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384))
}
return r
} else {
// typed array slice - allows garbage collector to free original reference,
// while being more compatible than .slice
const slc = (v: Uint8Array, s: number, e?: number): Uint8Array => {
if (s == null || s < 0) {
s = 0
}
if (e == null || e > v.length) {
e = v.length
}
// can't use .constructor in case user-supplied
return new Uint8Array(v.subarray(s, e))
}
// decode UTF8
const dutf8 = (d: Uint8Array): { s: string; r: Uint8Array } => {
for (let r = '', i = 0; ; ) {
let c = d[i++]
const eb = ((c > 127) as unknown as number) + ((c > 223) as unknown as number) + ((c > 239) as unknown as number)
if (i + eb > d.length) {
return { s: r, r: slc(d, i - 1) }
}
if (!eb) {
r += String.fromCharCode(c)
} else if (eb === 3) {
c = (((c & 15) << 18) | ((d[i++] & 63) << 12) | ((d[i++] & 63) << 6) | (d[i++] & 63)) - 65536
r += String.fromCharCode(55296 | (c >> 10), 56320 | (c & 1023))
} else if (eb & 1) {
r += String.fromCharCode(((c & 31) << 6) | (d[i++] & 63))
} else {
r += String.fromCharCode(((c & 15) << 12) | ((d[i++] & 63) << 6) | (d[i++] & 63))
}
}
}
const { s, r } = dutf8(dat)
if (r.length) {
throw new Error('Unexpected trailing bytes in UTF-8 decoding')
}
return s
}
}
static async decompressArrayBuffer(buffer: ArrayBuffer): Promise<string> {
const decompressed = await this.decompress(new Uint8Array(buffer))
return this.strFromU8(decompressed)
}
static arraysAreEqual(a: unknown[], b: unknown[]): boolean {
return arrayEqual(a, b)
}
/**
* Generate a pre-filled number array.
*
* @param start - start value
* @param stop - stop value
* @param step - step value
* @returns filled number array
*/
static range(start: number, stop: number, step: number): number[] {
return Array.from({ length: (stop - start) / step + 1 }, (_, i) => start + i * step)
}
/**
* convert spherical AZIMUTH, ELEVATION to Cartesian
* @param azimuth - azimuth number
* @param elevation - elevation number
* @returns the converted [x, y, z] coordinates
* @example
* xyz = NVUtilities.sph2cartDeg(42, 42)
*/
static sph2cartDeg(azimuth: number, elevation: number): number[] {
// convert spherical AZIMUTH,ELEVATION,RANGE to Cartesian
// see Matlab's [x,y,z] = sph2cart(THETA,PHI,R)
// reverse with cart2sph
const Phi = -elevation * (Math.PI / 180)
const Theta = ((azimuth - 90) % 360) * (Math.PI / 180)
const ret = [Math.cos(Phi) * Math.cos(Theta), Math.cos(Phi) * Math.sin(Theta), Math.sin(Phi)]
const len = Math.sqrt(ret[0] * ret[0] + ret[1] * ret[1] + ret[2] * ret[2])
if (len <= 0.0) {
return ret
}
ret[0] /= len
ret[1] /= len
ret[2] /= len
return ret
}
static vox2mm(XYZ: number[], mtx: mat4): vec3 {
const sform = mat4.clone(mtx)
mat4.transpose(sform, sform)
const pos = vec4.fromValues(XYZ[0], XYZ[1], XYZ[2], 1)
vec4.transformMat4(pos, pos, sform)
const pos3 = vec3.fromValues(pos[0], pos[1], pos[2])
return pos3
}
}