diff --git a/src/helpers.d.ts b/src/helpers.d.ts
deleted file mode 100644
index 654affd3f465a3c5d64f168acb7d89eac3b94b8a..0000000000000000000000000000000000000000
--- a/src/helpers.d.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-/**
- * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-declare module Helpers {
- export type Mutable<T> = {
- -readonly [P in keyof T]: T[P]
- }
- export type TypedIntArray = Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array
- export type TypedFloatArray = Float32Array | Float64Array
-
- export type TypedArray = TypedIntArray | TypedFloatArray
- export type NumberArray = TypedArray | number[]
- export type UintArray = Uint8Array | Uint16Array | Uint32Array | number[]
- export type ValueOf<T> = T[keyof T]
- export type ArrayCtor<T> = { new(size: number): { [i: number]: T, length: number } }
- /** assignable ArrayLike version */
- export type ArrayLike<T> = { [i: number]: T, length: number }
-}
\ No newline at end of file
diff --git a/src/mol-data/util/array.ts b/src/mol-data/util/array.ts
index 94311c38c2ad057768411f1c65c9762244c341e5..4df70a7115c4b51ae5d414d099120a6ae8c40a26 100644
--- a/src/mol-data/util/array.ts
+++ b/src/mol-data/util/array.ts
@@ -5,6 +5,8 @@
* @author David Sehnal <david.sehnal@gmail.com>
*/
+import { ArrayCtor } from 'mol-util/type-helpers';
+
export function arrayFind<T>(array: ArrayLike<T>, f: (v: T) => boolean): T | undefined {
for (let i = 0, _i = array.length; i < _i; i++) {
if (f(array[i])) return array[i];
@@ -25,7 +27,7 @@ export function iterableToArray<T>(it: IterableIterator<T>): T[] {
}
/** Fills the array so that array[0] = start and array[array.length - 1] = end */
-export function createRangeArray(start: number, end: number, ctor?: Helpers.ArrayCtor<number>) {
+export function createRangeArray(start: number, end: number, ctor?: ArrayCtor<number>) {
const len = end - start + 1;
const array = ctor ? new ctor(len) : new Int32Array(len);
for (let i = 0; i < len; i++) {
@@ -42,7 +44,7 @@ export function arrayPickIndices<T>(array: ArrayLike<T>, indices: ArrayLike<numb
return ret;
}
-export function arrayGetCtor<T>(data: ArrayLike<T>): Helpers.ArrayCtor<T> {
+export function arrayGetCtor<T>(data: ArrayLike<T>): ArrayCtor<T> {
const ret = (data as any).constructor;
if (!ret) throw new Error('data does not define a constructor and it should');
return ret;
diff --git a/src/mol-data/util/buckets.ts b/src/mol-data/util/buckets.ts
index 1e8568a09cefa714427585147f261a62fa753815..956a8e365e7259b3b4d8cb9dadf6dfd46c420d78 100644
--- a/src/mol-data/util/buckets.ts
+++ b/src/mol-data/util/buckets.ts
@@ -5,6 +5,7 @@
*/
import { sort, arraySwap } from './sort';
+import { AssignableArrayLike } from 'mol-util/type-helpers';
type Bucket = {
key: any,
@@ -14,7 +15,7 @@ type Bucket = {
function sortAsc(bs: Bucket[], i: number, j: number) { return bs[i].key < bs[j].key ? -1 : 1; }
-function _makeBuckets(indices: Helpers.ArrayLike<number>,
+function _makeBuckets(indices: AssignableArrayLike<number>,
getKey: (i: number) => any, sortBuckets: boolean, start: number, end: number) {
const buckets = new Map<any, Bucket>();
@@ -95,7 +96,7 @@ export interface MakeBucketsOptions<K> {
* Returns the offsets of buckets. So that [offsets[i], offsets[i + 1]) determines the range.
*/
export function makeBuckets<K extends string | number>(
- indices: Helpers.ArrayLike<number>, getKey: (i: number) => K, options?: MakeBucketsOptions<K>): ArrayLike<number> {
+ indices: AssignableArrayLike<number>, getKey: (i: number) => K, options?: MakeBucketsOptions<K>): ArrayLike<number> {
const s = (options && options.start) || 0;
const e = (options && options.end) || indices.length;
if (e - s <= 0) throw new Error('Can only bucket non-empty collections.');
diff --git a/src/mol-geo/geometry/geometry.ts b/src/mol-geo/geometry/geometry.ts
index 76ef6d452f4e2ffd374afe72447b4adf5bcd3e8e..668e118df8cb0377f01069cf1c9ffadcd0a36d51 100644
--- a/src/mol-geo/geometry/geometry.ts
+++ b/src/mol-geo/geometry/geometry.ts
@@ -20,6 +20,7 @@ import { arrayMax } from 'mol-util/array';
import { TransformData } from './transform-data';
import { Theme } from 'mol-theme/theme';
import { RenderObjectValuesType } from 'mol-gl/render-object';
+import { ValueOf } from 'mol-util/type-helpers';
export type GeometryKindType = {
'mesh': Mesh,
@@ -38,7 +39,7 @@ export type GeometryKindParams = {
'direct-volume': DirectVolume.Params,
}
export type GeometryKind = keyof GeometryKindType
-export type Geometry = Helpers.ValueOf<GeometryKindType>
+export type Geometry = ValueOf<GeometryKindType>
export interface GeometryUtils<G extends Geometry, P extends PD.Params = GeometryKindParams[G['kind']], V = RenderObjectValuesType[G['kind']]> {
Params: P
diff --git a/src/mol-geo/util.ts b/src/mol-geo/util.ts
index ad2156c06c38cccc9ec3ae6b5b87745276785738..d683696c56ca6101e99169c8e3875c35d6400929 100644
--- a/src/mol-geo/util.ts
+++ b/src/mol-geo/util.ts
@@ -5,8 +5,9 @@
*/
import { Vec3, Mat4, Mat3 } from 'mol-math/linear-algebra'
+import { NumberArray } from 'mol-util/type-helpers';
-export function normalizeVec3Array<T extends Helpers.NumberArray> (a: T) {
+export function normalizeVec3Array<T extends NumberArray> (a: T) {
const n = a.length
for (let i = 0; i < n; i += 3) {
const x = a[ i ]
@@ -28,7 +29,7 @@ export function getNormalMatrix(out: Mat3, t: Mat4) {
const tmpV3 = Vec3.zero()
-export function transformPositionArray (t: Mat4, array: Helpers.NumberArray, offset: number, count: number) {
+export function transformPositionArray (t: Mat4, array: NumberArray, offset: number, count: number) {
for (let i = 0, il = count * 3; i < il; i += 3) {
Vec3.fromArray(tmpV3, array, offset + i)
Vec3.transformMat4(tmpV3, tmpV3, t)
@@ -36,7 +37,7 @@ export function transformPositionArray (t: Mat4, array: Helpers.NumberArray, off
}
}
-export function transformDirectionArray (n: Mat3, array: Helpers.NumberArray, offset: number, count: number) {
+export function transformDirectionArray (n: Mat3, array: NumberArray, offset: number, count: number) {
for (let i = 0, il = count * 3; i < il; i += 3) {
Vec3.fromArray(tmpV3, array, offset + i)
Vec3.transformMat3(tmpV3, tmpV3, n)
@@ -44,13 +45,13 @@ export function transformDirectionArray (n: Mat3, array: Helpers.NumberArray, of
}
}
-export function setArrayZero(array: Helpers.NumberArray) {
+export function setArrayZero(array: NumberArray) {
const n = array.length
for (let i = 0; i < n; ++i) array[i] = 0
}
/** iterate over the entire buffer and apply the radius to each vertex */
-export function appplyRadius(vertices: Helpers.NumberArray, radius: number) {
+export function appplyRadius(vertices: NumberArray, radius: number) {
const v = Vec3.zero()
const n = vertices.length
for (let i = 0; i < n; i += 3) {
@@ -65,7 +66,7 @@ export function appplyRadius(vertices: Helpers.NumberArray, radius: number) {
* indexed vertex normals weighted by triangle areas http://www.iquilezles.org/www/articles/normals/normals.htm
* normal array must contain only zeros
*/
-export function computeIndexedVertexNormals<T extends Helpers.NumberArray> (vertices: Helpers.NumberArray, indices: Helpers.NumberArray, normals: T) {
+export function computeIndexedVertexNormals<T extends NumberArray> (vertices: NumberArray, indices: NumberArray, normals: T) {
const a = Vec3.zero()
const b = Vec3.zero()
const c = Vec3.zero()
@@ -103,7 +104,7 @@ export function computeIndexedVertexNormals<T extends Helpers.NumberArray> (vert
}
/** vertex normals for unindexed triangle soup, normal array must contain only zeros */
-export function computeVertexNormals<T extends Helpers.NumberArray> (vertices: Helpers.NumberArray, normals: T) {
+export function computeVertexNormals<T extends NumberArray> (vertices: NumberArray, normals: T) {
setArrayZero(normals)
const a = Vec3.zero()
diff --git a/src/mol-gl/webgl/buffer.ts b/src/mol-gl/webgl/buffer.ts
index 5c2d5b0801427b8f586be8f8c9695a55a32f124b..80cd13401bfe84604f844b89b75d5c42d816812d 100644
--- a/src/mol-gl/webgl/buffer.ts
+++ b/src/mol-gl/webgl/buffer.ts
@@ -8,6 +8,7 @@ import { WebGLContext } from './context'
import { ValueCell } from 'mol-util';
import { RenderableSchema } from '../renderable/schema';
import { idFactory } from 'mol-util/id-factory';
+import { ValueOf } from 'mol-util/type-helpers';
const getNextBufferId = idFactory()
@@ -24,7 +25,7 @@ export type DataTypeArrayType = {
'int32': Int32Array
'float32': Float32Array
}
-export type ArrayType = Helpers.ValueOf<DataTypeArrayType>
+export type ArrayType = ValueOf<DataTypeArrayType>
export type ArrayKind = keyof DataTypeArrayType
export type BufferItemSize = 1 | 2 | 3 | 4 | 16
diff --git a/src/mol-gl/webgl/render-target.ts b/src/mol-gl/webgl/render-target.ts
index 52203d0134b92584511a7fd6ab7df5d92b77a7da..d26ec40b136d87c9669b32d2ddfca8ee55c7285c 100644
--- a/src/mol-gl/webgl/render-target.ts
+++ b/src/mol-gl/webgl/render-target.ts
@@ -10,6 +10,7 @@ import { createTexture, Texture } from './texture';
import { createFramebuffer } from './framebuffer';
import { createRenderbuffer } from './renderbuffer';
import { TextureImage } from '../renderable/util';
+import { Mutable } from 'mol-util/type-helpers';
const getNextRenderTargetId = idFactory()
@@ -32,7 +33,7 @@ export interface RenderTarget {
export function createRenderTarget (ctx: WebGLContext, _width: number, _height: number): RenderTarget {
const { gl } = ctx
- const image: Helpers.Mutable<TextureImage<Uint8Array>> = {
+ const image: Mutable<TextureImage<Uint8Array>> = {
array: new Uint8Array(_width * _height * 4),
width: _width,
height: _height
diff --git a/src/mol-gl/webgl/texture.ts b/src/mol-gl/webgl/texture.ts
index 763bf9fdc396e77bed78eef13b0295e41995d529..b08790f3321dd154deff6d8eeb6eb68297fcb8f9 100644
--- a/src/mol-gl/webgl/texture.ts
+++ b/src/mol-gl/webgl/texture.ts
@@ -11,6 +11,7 @@ import { RenderableSchema } from '../renderable/schema';
import { idFactory } from 'mol-util/id-factory';
import { Framebuffer } from './framebuffer';
import { isWebGL2 } from './compat';
+import { ValueOf } from 'mol-util/type-helpers';
const getNextTextureId = idFactory()
@@ -21,7 +22,7 @@ export type TextureKindValue = {
'volume-float32': TextureVolume<Float32Array>
'texture': Texture
}
-export type TextureValueType = Helpers.ValueOf<TextureKindValue>
+export type TextureValueType = ValueOf<TextureKindValue>
export type TextureKind = keyof TextureKindValue
export type TextureType = 'ubyte' | 'float'
export type TextureFormat = 'alpha' | 'rgb' | 'rgba'
diff --git a/src/mol-io/common/binary-cif/array-encoder.ts b/src/mol-io/common/binary-cif/array-encoder.ts
index a681faeef47f5645f73c32128ba5f360f6613f81..0d745598e5e645989d7451246fc5ad75236384bf 100644
--- a/src/mol-io/common/binary-cif/array-encoder.ts
+++ b/src/mol-io/common/binary-cif/array-encoder.ts
@@ -10,6 +10,7 @@
import { ChunkedArray } from 'mol-data/util'
import { Encoding, EncodedData } from './encoding'
import { classifyIntArray } from './classifier';
+import { TypedIntArray, TypedFloatArray } from 'mol-util/type-helpers';
export interface ArrayEncoder {
and(f: ArrayEncoding.Provider): ArrayEncoder,
@@ -119,7 +120,7 @@ export namespace ArrayEncoding {
[Encoding.FloatDataType.Float64]: 8
}
- export function byteArray(data: Encoding.TypedFloatArray | Encoding.TypedIntArray) {
+ export function byteArray(data: TypedFloatArray | TypedIntArray) {
const type = Encoding.getDataType(data);
if (type === Encoding.IntDataType.Int8) return int8(data as Int8Array);
@@ -137,7 +138,7 @@ export namespace ArrayEncoding {
};
}
- function _fixedPoint(data: Encoding.TypedFloatArray, factor: number): Result {
+ function _fixedPoint(data: TypedFloatArray, factor: number): Result {
const srcType = Encoding.getDataType(data) as Encoding.FloatDataType;
const result = new Int32Array(data.length);
for (let i = 0, n = data.length; i < n; i++) {
@@ -148,9 +149,9 @@ export namespace ArrayEncoding {
data: result
};
}
- export function fixedPoint(factor: number): Provider { return data => _fixedPoint(data as Encoding.TypedFloatArray, factor); }
+ export function fixedPoint(factor: number): Provider { return data => _fixedPoint(data as TypedFloatArray, factor); }
- function _intervalQuantizaiton(data: Encoding.TypedFloatArray, min: number, max: number, numSteps: number, arrayType: new (size: number) => Encoding.TypedIntArray): Result {
+ function _intervalQuantizaiton(data: TypedFloatArray, min: number, max: number, numSteps: number, arrayType: new (size: number) => TypedIntArray): Result {
const srcType = Encoding.getDataType(data) as Encoding.FloatDataType;
if (!data.length) {
return {
@@ -180,11 +181,11 @@ export namespace ArrayEncoding {
data: output
};
}
- export function intervalQuantizaiton(min: number, max: number, numSteps: number, arrayType: new (size: number) => Encoding.TypedIntArray = Int32Array): Provider {
- return data => _intervalQuantizaiton(data as Encoding.TypedFloatArray, min, max, numSteps, arrayType);
+ export function intervalQuantizaiton(min: number, max: number, numSteps: number, arrayType: new (size: number) => TypedIntArray = Int32Array): Provider {
+ return data => _intervalQuantizaiton(data as TypedFloatArray, min, max, numSteps, arrayType);
}
- export function runLength(data: Encoding.TypedIntArray): Result {
+ export function runLength(data: TypedIntArray): Result {
let srcType = Encoding.getDataType(data) as Encoding.IntDataType;
if (srcType === void 0) {
data = new Int32Array(data);
diff --git a/src/mol-io/common/binary-cif/encoding.ts b/src/mol-io/common/binary-cif/encoding.ts
index 6fc0d20a092e7dad6df07756618ad773fbc328ec..899d246adf90bc46565a97dc16cbae9101c4857f 100644
--- a/src/mol-io/common/binary-cif/encoding.ts
+++ b/src/mol-io/common/binary-cif/encoding.ts
@@ -5,6 +5,8 @@
* @author David Sehnal <david.sehnal@gmail.com>
*/
+import { TypedIntArray, TypedFloatArray } from 'mol-util/type-helpers';
+
export const VERSION = '0.3.0';
export type Encoding =
@@ -71,9 +73,6 @@ export namespace Encoding {
export type DataType = IntDataType | FloatDataType
- export type TypedIntArray = Helpers.TypedIntArray
- export type TypedFloatArray = Helpers.TypedFloatArray
-
export function getDataType(data: TypedIntArray | TypedFloatArray): DataType {
let srcType: DataType;
if (data instanceof Int8Array) srcType = Encoding.IntDataType.Int8;
diff --git a/src/mol-io/writer/cif/encoder/binary.ts b/src/mol-io/writer/cif/encoder/binary.ts
index f85d81aa93045b9e157b0811b96c396a3c6fd588..c9b39a799c775ee62cbce8dd13358e44b6469faf 100644
--- a/src/mol-io/writer/cif/encoder/binary.ts
+++ b/src/mol-io/writer/cif/encoder/binary.ts
@@ -15,6 +15,7 @@ import { Field, Category, Encoder } from '../encoder'
import Writer from '../../writer'
import { getIncludedFields, getCategoryInstanceData, CategoryInstanceData } from './util';
import { classifyIntArray, classifyFloatArray } from '../../../common/binary-cif/classifier';
+import { ArrayCtor } from 'mol-util/type-helpers';
export interface EncodingProvider {
get(category: string, field: string): ArrayEncoder | undefined;
@@ -96,7 +97,7 @@ export default class BinaryEncoder implements Encoder<Uint8Array> {
}
}
-function getArrayCtor(field: Field, format: Field.Format | undefined): Helpers.ArrayCtor<string | number> {
+function getArrayCtor(field: Field, format: Field.Format | undefined): ArrayCtor<string | number> {
if (format && format.typedArray) return format.typedArray;
if (field.defaultFormat && field.defaultFormat.typedArray) return field.defaultFormat.typedArray;
if (field.type === Field.Type.Str) return Array;
@@ -157,7 +158,7 @@ function encodeField(categoryName: string, field: Field, data: CategoryInstanceD
};
}
-function getFieldData(field: Field<any, any>, arrayCtor: Helpers.ArrayCtor<string | number>, totalCount: number, data: CategoryInstanceData['source']) {
+function getFieldData(field: Field<any, any>, arrayCtor: ArrayCtor<string | number>, totalCount: number, data: CategoryInstanceData['source']) {
const isStr = field.type === Field.Type.Str;
const array = new arrayCtor(totalCount);
const mask = new Uint8Array(totalCount);
diff --git a/src/mol-math/geometry/distance-transform.ts b/src/mol-math/geometry/distance-transform.ts
index fa9551c4d29c03ff65abce37d4b70b48ddf54460..df3c5693fcc64e6091e4e8ba38a38ad35f9fc1a0 100644
--- a/src/mol-math/geometry/distance-transform.ts
+++ b/src/mol-math/geometry/distance-transform.ts
@@ -4,10 +4,12 @@
* @author Alexander Rose <alexander.rose@weirdbyte.de>
*/
+import { NumberArray } from 'mol-util/type-helpers';
+
/**
* 2D Euclidean distance transform by Felzenszwalb & Huttenlocher https://cs.brown.edu/~pff/papers/dt-final.pdf
*/
-export function edt(data: Helpers.NumberArray, width: number, height: number, f: Helpers.NumberArray, d: Helpers.NumberArray, v: Helpers.NumberArray, z: Helpers.NumberArray) {
+export function edt(data: NumberArray, width: number, height: number, f: NumberArray, d: NumberArray, v: NumberArray, z: NumberArray) {
for (let x = 0; x < width; x++) {
for (let y = 0; y < height; y++) {
f[y] = data[y * width + x]
@@ -31,7 +33,7 @@ export function edt(data: Helpers.NumberArray, width: number, height: number, f:
/**
* 1D squared distance transform
*/
-function edt1d(f: Helpers.NumberArray, d: Helpers.NumberArray, v: Helpers.NumberArray, z: Helpers.NumberArray, n: number) {
+function edt1d(f: NumberArray, d: NumberArray, v: NumberArray, z: NumberArray, n: number) {
v[0] = 0
z[0] = Number.MIN_SAFE_INTEGER
z[1] = Number.MAX_SAFE_INTEGER
diff --git a/src/mol-math/geometry/primitives/sphere3d.ts b/src/mol-math/geometry/primitives/sphere3d.ts
index 5dbbf1315b9ea054ff2d2d46ded3fdc0cfa57892..94c9593f9889b9a68b694cb71968a2cfc221d762 100644
--- a/src/mol-math/geometry/primitives/sphere3d.ts
+++ b/src/mol-math/geometry/primitives/sphere3d.ts
@@ -8,6 +8,7 @@
import { Vec3, Mat4, EPSILON } from '../../linear-algebra'
import { PositionData } from '../common'
import { OrderedSet } from 'mol-data/int';
+import { NumberArray } from 'mol-util/type-helpers';
interface Sphere3D { center: Vec3, radius: number }
@@ -64,12 +65,12 @@ namespace Sphere3D {
return out
}
- export function toArray(s: Sphere3D, out: Helpers.NumberArray, offset: number) {
+ export function toArray(s: Sphere3D, out: NumberArray, offset: number) {
Vec3.toArray(s.center, out, offset)
out[offset + 3] = s.radius
}
- export function fromArray(out: Sphere3D, array: Helpers.NumberArray, offset: number) {
+ export function fromArray(out: Sphere3D, array: NumberArray, offset: number) {
Vec3.fromArray(out.center, array, offset)
out.radius = array[offset + 3]
return out
diff --git a/src/mol-math/linear-algebra/3d/mat3.ts b/src/mol-math/linear-algebra/3d/mat3.ts
index f18d68fb2dac152966f946dedbddceba64a7bcfd..a646193d7d6ecc7403bde52b2ec097610169e964 100644
--- a/src/mol-math/linear-algebra/3d/mat3.ts
+++ b/src/mol-math/linear-algebra/3d/mat3.ts
@@ -18,6 +18,7 @@
*/
import { Mat4 } from '../3d'
+import { NumberArray } from 'mol-util/type-helpers';
interface Mat3 extends Array<number> { [d: number]: number, '@type': 'mat3', length: 9 }
@@ -56,7 +57,7 @@ namespace Mat3 {
return mat;
}
- export function toArray(a: Mat3, out: Helpers.NumberArray, offset: number) {
+ export function toArray(a: Mat3, out: NumberArray, offset: number) {
out[offset + 0] = a[0];
out[offset + 1] = a[1];
out[offset + 2] = a[2];
@@ -68,7 +69,7 @@ namespace Mat3 {
out[offset + 8] = a[8];
}
- export function fromArray(a: Mat3, array: Helpers.NumberArray, offset: number) {
+ export function fromArray(a: Mat3, array: NumberArray, offset: number) {
a[0] = array[offset + 0]
a[1] = array[offset + 1]
a[2] = array[offset + 2]
diff --git a/src/mol-math/linear-algebra/3d/mat4.ts b/src/mol-math/linear-algebra/3d/mat4.ts
index be275d960bf494d3937f4537d666336ddeed7d7a..b18fb3e5cc57036ca1ea9d69a9dba0f5162bf7cb 100644
--- a/src/mol-math/linear-algebra/3d/mat4.ts
+++ b/src/mol-math/linear-algebra/3d/mat4.ts
@@ -21,6 +21,7 @@ import { EPSILON, equalEps } from './common'
import Vec3 from './vec3';
import Quat from './quat';
import { degToRad } from '../../misc';
+import { NumberArray } from 'mol-util/type-helpers';
interface Mat4 extends Array<number> { [d: number]: number, '@type': 'mat4', length: 16 }
interface ReadonlyMat4 extends Array<number> { readonly [d: number]: number, '@type': 'mat4', length: 16 }
@@ -118,7 +119,7 @@ namespace Mat4 {
a[4 * j + i] = value;
}
- export function toArray(a: Mat4, out: Helpers.NumberArray, offset: number) {
+ export function toArray(a: Mat4, out: NumberArray, offset: number) {
out[offset + 0] = a[0];
out[offset + 1] = a[1];
out[offset + 2] = a[2];
@@ -137,7 +138,7 @@ namespace Mat4 {
out[offset + 15] = a[15];
}
- export function fromArray(a: Mat4, array: Helpers.NumberArray, offset: number) {
+ export function fromArray(a: Mat4, array: NumberArray, offset: number) {
a[0] = array[offset + 0]
a[1] = array[offset + 1]
a[2] = array[offset + 2]
@@ -370,7 +371,7 @@ namespace Mat4 {
/**
* Like `mul` but with offsets into arrays
*/
- export function mulOffset(out: Helpers.NumberArray, a: Helpers.NumberArray, b: Helpers.NumberArray, oOut: number, oA: number, oB: number) {
+ export function mulOffset(out: NumberArray, a: NumberArray, b: NumberArray, oOut: number, oA: number, oB: number) {
const a00 = a[0 + oA], a01 = a[1 + oA], a02 = a[2 + oA], a03 = a[3 + oA],
a10 = a[4 + oA], a11 = a[5 + oA], a12 = a[6 + oA], a13 = a[7 + oA],
a20 = a[8 + oA], a21 = a[9 + oA], a22 = a[10 + oA], a23 = a[11 + oA],
diff --git a/src/mol-math/linear-algebra/3d/quat.ts b/src/mol-math/linear-algebra/3d/quat.ts
index 8c85b36c094284689029d852aa42a4cfb7c48f09..59e68c88bd5fe70b02d7e19bbc4cac22ed614956 100644
--- a/src/mol-math/linear-algebra/3d/quat.ts
+++ b/src/mol-math/linear-algebra/3d/quat.ts
@@ -25,6 +25,7 @@
import Mat3 from './mat3';
import Vec3 from './vec3';
import { EPSILON } from './common';
+import { NumberArray } from 'mol-util/type-helpers';
interface Quat extends Array<number> { [d: number]: number, '@type': 'quat', length: 4 }
@@ -312,14 +313,14 @@ namespace Quat {
return out;
}
- export function toArray(a: Quat, out: Helpers.NumberArray, offset: number) {
+ export function toArray(a: Quat, out: NumberArray, offset: number) {
out[offset + 0] = a[0];
out[offset + 1] = a[1];
out[offset + 2] = a[2];
out[offset + 3] = a[3];
}
- export function fromArray(a: Quat, array: Helpers.NumberArray, offset: number) {
+ export function fromArray(a: Quat, array: NumberArray, offset: number) {
a[0] = array[offset + 0]
a[1] = array[offset + 1]
a[2] = array[offset + 2]
diff --git a/src/mol-math/linear-algebra/3d/vec2.ts b/src/mol-math/linear-algebra/3d/vec2.ts
index 34bdb70bfd5d7a45c82c323c7462f775d3a6f7a6..be7b7cdf93b52dac9b90fca247f42f75485fd383 100644
--- a/src/mol-math/linear-algebra/3d/vec2.ts
+++ b/src/mol-math/linear-algebra/3d/vec2.ts
@@ -1,3 +1,5 @@
+import { NumberArray } from 'mol-util/type-helpers';
+
/**
* Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
*
@@ -44,12 +46,12 @@ namespace Vec2 {
return isNaN(a[0]) || isNaN(a[1])
}
- export function toArray(a: Vec2, out: Helpers.NumberArray, offset: number) {
+ export function toArray(a: Vec2, out: NumberArray, offset: number) {
out[offset + 0] = a[0];
out[offset + 1] = a[1];
}
- export function fromArray(a: Vec2, array: Helpers.NumberArray, offset: number) {
+ export function fromArray(a: Vec2, array: NumberArray, offset: number) {
a[0] = array[offset + 0]
a[1] = array[offset + 1]
return a
diff --git a/src/mol-math/linear-algebra/3d/vec3.ts b/src/mol-math/linear-algebra/3d/vec3.ts
index 5a230ea9054ebe66f723285bd26e79f0897c92e6..0be0f033dcbff1020f4ea5f9ac22566f45daf100 100644
--- a/src/mol-math/linear-algebra/3d/vec3.ts
+++ b/src/mol-math/linear-algebra/3d/vec3.ts
@@ -20,6 +20,7 @@
import Mat4 from './mat4';
import { Quat, Mat3, EPSILON } from '../3d';
import { spline as _spline, clamp } from '../../interpolate'
+import { NumberArray } from 'mol-util/type-helpers';
interface Vec3 extends Array<number> { [d: number]: number, '@type': 'vec3', length: 3 }
@@ -57,7 +58,7 @@ namespace Vec3 {
return v
}
- export function toArray(v: Vec3, out: Helpers.NumberArray, offset: number) {
+ export function toArray(v: Vec3, out: NumberArray, offset: number) {
out[offset + 0] = v[0]
out[offset + 1] = v[1]
out[offset + 2] = v[2]
@@ -372,7 +373,7 @@ namespace Vec3 {
/**
* Like `transformMat4` but with offsets into arrays
*/
- export function transformMat4Offset(out: Helpers.NumberArray, a: Helpers.NumberArray, m: Helpers.NumberArray, outO: number, aO: number, oM: number) {
+ export function transformMat4Offset(out: NumberArray, a: NumberArray, m: NumberArray, outO: number, aO: number, oM: number) {
const x = a[0 + aO], y = a[1 + aO], z = a[2 + aO],
w = 1 / ((m[3 + oM] * x + m[7 + oM] * y + m[11 + oM] * z + m[15 + oM]) || 1.0);
out[0 + outO] = (m[0 + oM] * x + m[4 + oM] * y + m[8 + oM] * z + m[12 + oM]) * w;
diff --git a/src/mol-math/linear-algebra/3d/vec4.ts b/src/mol-math/linear-algebra/3d/vec4.ts
index e54d6d4970a6b4468b50f4d8719c5eab24cd2149..c7c4e3380250572a684ce87ce4bdbd90ee8d19df 100644
--- a/src/mol-math/linear-algebra/3d/vec4.ts
+++ b/src/mol-math/linear-algebra/3d/vec4.ts
@@ -19,6 +19,7 @@
import Mat4 from './mat4';
import { EPSILON } from '../3d';
+import { NumberArray } from 'mol-util/type-helpers';
interface Vec4 extends Array<number> { [d: number]: number, '@type': 'vec4', length: 4 }
@@ -52,14 +53,14 @@ namespace Vec4 {
return isNaN(a[0]) || isNaN(a[1]) || isNaN(a[2]) || isNaN(a[3])
}
- export function toArray(a: Vec4, out: Helpers.NumberArray, offset: number) {
+ export function toArray(a: Vec4, out: NumberArray, offset: number) {
out[offset + 0] = a[0];
out[offset + 1] = a[1];
out[offset + 2] = a[2];
out[offset + 3] = a[3];
}
- export function fromArray(a: Vec4, array: Helpers.NumberArray, offset: number) {
+ export function fromArray(a: Vec4, array: NumberArray, offset: number) {
a[0] = array[offset + 0]
a[1] = array[offset + 1]
a[2] = array[offset + 2]
@@ -67,13 +68,13 @@ namespace Vec4 {
return a
}
- export function toVec3Array(a: Vec4, out: Helpers.NumberArray, offset: number) {
+ export function toVec3Array(a: Vec4, out: NumberArray, offset: number) {
out[offset + 0] = a[0];
out[offset + 1] = a[1];
out[offset + 2] = a[2];
}
- export function fromVec3Array(a: Vec4, array: Helpers.NumberArray, offset: number) {
+ export function fromVec3Array(a: Vec4, array: NumberArray, offset: number) {
a[0] = array[offset + 0]
a[1] = array[offset + 1]
a[2] = array[offset + 2]
diff --git a/src/mol-math/linear-algebra/matrix/matrix.ts b/src/mol-math/linear-algebra/matrix/matrix.ts
index 549635053c5ce1ff03ecd97490d6cba7a76ea9ee..0610a4648d3715a6cb1c833663fbe751a99ec515 100644
--- a/src/mol-math/linear-algebra/matrix/matrix.ts
+++ b/src/mol-math/linear-algebra/matrix/matrix.ts
@@ -4,15 +4,17 @@
* @author Alexander Rose <alexander.rose@weirdbyte.de>
*/
-interface Matrix { data: Helpers.NumberArray, size: number, cols: number, rows: number }
+import { NumberArray } from 'mol-util/type-helpers';
+
+interface Matrix { data: NumberArray, size: number, cols: number, rows: number }
namespace Matrix {
- export function create(cols: number, rows: number, ctor: { new (size: number): Helpers.NumberArray } = Float32Array): Matrix {
+ export function create(cols: number, rows: number, ctor: { new (size: number): NumberArray } = Float32Array): Matrix {
const size = cols * rows
return { data: new ctor(size), size, cols, rows }
}
- export function fromArray(data: Helpers.NumberArray, cols: number, rows: number): Matrix {
+ export function fromArray(data: NumberArray, cols: number, rows: number): Matrix {
return { data, size: cols * rows, cols, rows }
}
@@ -61,7 +63,7 @@ namespace Matrix {
}
/** Subtract `row` from all rows in `mat` */
- export function subRows (mat: Matrix, row: Helpers.NumberArray) {
+ export function subRows (mat: Matrix, row: NumberArray) {
const nrows = mat.rows, ncols = mat.cols
const md = mat.data
diff --git a/src/mol-math/linear-algebra/matrix/svd.ts b/src/mol-math/linear-algebra/matrix/svd.ts
index e7ace3f959ae173d49c9869ce0015cce89c18b3f..ad276f4ac0fed1fb6b2adce2868a327013f2ea20 100644
--- a/src/mol-math/linear-algebra/matrix/svd.ts
+++ b/src/mol-math/linear-algebra/matrix/svd.ts
@@ -5,10 +5,11 @@
*/
import Matrix from './matrix';
+import { NumberArray } from 'mol-util/type-helpers';
// svd method adapted from http://inspirit.github.io/jsfeat/ MIT Eugene Zatepyakin
-export function swap(A: Helpers.NumberArray, i0: number, i1: number, t: number) {
+export function swap(A: NumberArray, i0: number, i1: number, t: number) {
t = A[i0]
A[i0] = A[i1]
A[i1] = t
@@ -31,7 +32,7 @@ export function hypot(a: number, b: number) {
const EPSILON = 0.0000001192092896
const FLT_MIN = 1E-37
-export function JacobiSVDImpl(At: Helpers.NumberArray, astep: number, _W: Helpers.NumberArray, Vt: Helpers.NumberArray, vstep: number, m: number, n: number, n1: number) {
+export function JacobiSVDImpl(At: NumberArray, astep: number, _W: NumberArray, Vt: NumberArray, vstep: number, m: number, n: number, n1: number) {
const eps = EPSILON * 2.0
const minval = FLT_MIN
let i = 0
diff --git a/src/mol-repr/structure/visual/util/polymer/curve-segment.ts b/src/mol-repr/structure/visual/util/polymer/curve-segment.ts
index bef8bd5e91958bdf819f8b0202169699ad3f083c..1231c6bb0f9e160f9ed62b36cae038b867f9c2f8 100644
--- a/src/mol-repr/structure/visual/util/polymer/curve-segment.ts
+++ b/src/mol-repr/structure/visual/util/polymer/curve-segment.ts
@@ -5,12 +5,13 @@
*/
import { Vec3 } from 'mol-math/linear-algebra';
+import { NumberArray } from 'mol-util/type-helpers';
export interface CurveSegmentState {
- curvePoints: Helpers.NumberArray,
- tangentVectors: Helpers.NumberArray,
- normalVectors: Helpers.NumberArray,
- binormalVectors: Helpers.NumberArray,
+ curvePoints: NumberArray,
+ tangentVectors: NumberArray,
+ normalVectors: NumberArray,
+ binormalVectors: NumberArray,
linearSegments: number
}
diff --git a/src/mol-util/array.ts b/src/mol-util/array.ts
index 6895f81ed2b5b7a5db5172170a0b76656bad1aba..95b5ef5be19ea24383680e0e6ca84054cf6c70d7 100644
--- a/src/mol-util/array.ts
+++ b/src/mol-util/array.ts
@@ -4,10 +4,12 @@
* @author Alexander Rose <alexander.rose@weirdbyte.de>
*/
+import { NumberArray } from './type-helpers';
+
// TODO move to mol-math as Vector???
/** Get the maximum value in an array */
-export function arrayMax(array: Helpers.NumberArray) {
+export function arrayMax(array: NumberArray) {
let max = -Infinity
for (let i = 0, il = array.length; i < il; ++i) {
if (array[i] > max) max = array[i]
@@ -16,7 +18,7 @@ export function arrayMax(array: Helpers.NumberArray) {
}
/** Get the minimum value in an array */
-export function arrayMin(array: Helpers.NumberArray) {
+export function arrayMin(array: NumberArray) {
let min = Infinity
for (let i = 0, il = array.length; i < il; ++i) {
if (array[i] < min) min = array[i]
@@ -25,7 +27,7 @@ export function arrayMin(array: Helpers.NumberArray) {
}
/** Get the sum of values in an array */
-export function arraySum(array: Helpers.NumberArray, stride = 1, offset = 0) {
+export function arraySum(array: NumberArray, stride = 1, offset = 0) {
const n = array.length
let sum = 0
for (let i = offset; i < n; i += stride) {
@@ -35,12 +37,12 @@ export function arraySum(array: Helpers.NumberArray, stride = 1, offset = 0) {
}
/** Get the mean of values in an array */
-export function arrayMean(array: Helpers.NumberArray, stride = 1, offset = 0) {
+export function arrayMean(array: NumberArray, stride = 1, offset = 0) {
return arraySum(array, stride, offset) / (array.length / stride)
}
/** Get the root mean square of values in an array */
-export function arrayRms(array: Helpers.NumberArray) {
+export function arrayRms(array: NumberArray) {
const n = array.length
let sumSq = 0
for (let i = 0; i < n; ++i) {
@@ -51,7 +53,7 @@ export function arrayRms(array: Helpers.NumberArray) {
}
/** Fill an array with serial numbers starting from 0 until n - 1 (defaults to array.length) */
-export function fillSerial<T extends Helpers.NumberArray> (array: T, n?: number) {
+export function fillSerial<T extends NumberArray> (array: T, n?: number) {
for (let i = 0, il = n ? Math.min(n, array.length) : array.length; i < il; ++i) array[ i ] = i
return array
}
\ No newline at end of file
diff --git a/src/mol-util/color/color.ts b/src/mol-util/color/color.ts
index ec15dbf3e49fd23fa2b52e585d0605b9984cc39e..150417a6820ebfb44ac7fe6ff46884b0c1e926fa 100644
--- a/src/mol-util/color/color.ts
+++ b/src/mol-util/color/color.ts
@@ -4,6 +4,8 @@
* @author Alexander Rose <alexander.rose@weirdbyte.de>
*/
+import { NumberArray } from 'mol-util/type-helpers';
+
/** RGB color triplet expressed as a single number */
export type Color = { readonly '@type': 'color' } & number
@@ -38,16 +40,16 @@ export namespace Color {
return (((r * 255) << 16) | ((g * 255) << 8) | (b * 255)) as Color
}
- export function fromArray(array: Helpers.NumberArray, offset: number): Color {
+ export function fromArray(array: NumberArray, offset: number): Color {
return fromRgb(array[offset], array[offset + 1], array[offset + 2])
}
- export function fromNormalizedArray(array: Helpers.NumberArray, offset: number): Color {
+ export function fromNormalizedArray(array: NumberArray, offset: number): Color {
return fromNormalizedRgb(array[offset], array[offset + 1], array[offset + 2])
}
/** Copies hex color to rgb array */
- export function toArray(hexColor: Color, array: Helpers.NumberArray, offset: number) {
+ export function toArray(hexColor: Color, array: NumberArray, offset: number) {
array[ offset ] = (hexColor >> 16 & 255)
array[ offset + 1 ] = (hexColor >> 8 & 255)
array[ offset + 2 ] = (hexColor & 255)
@@ -55,7 +57,7 @@ export namespace Color {
}
/** Copies normalized (0 to 1) hex color to rgb array */
- export function toArrayNormalized<T extends Helpers.NumberArray>(hexColor: Color, array: T, offset: number) {
+ export function toArrayNormalized<T extends NumberArray>(hexColor: Color, array: T, offset: number) {
array[ offset ] = (hexColor >> 16 & 255) / 255
array[ offset + 1 ] = (hexColor >> 8 & 255) / 255
array[ offset + 2 ] = (hexColor & 255) / 255
diff --git a/src/mol-util/color/scale.ts b/src/mol-util/color/scale.ts
index 3437b80d84a49da05b46c604786c8cf8a7cc09c6..39f1b716c2511002c81578c45ac8fdb7742c3281 100644
--- a/src/mol-util/color/scale.ts
+++ b/src/mol-util/color/scale.ts
@@ -7,6 +7,7 @@
import { Color } from './color'
import { ColorBrewer, ColorMatplotlib, ColorOther } from './tables'
import { defaults } from 'mol-util';
+import { NumberArray } from 'mol-util/type-helpers';
export type ColorListName = (
keyof typeof ColorBrewer | keyof typeof ColorMatplotlib | keyof typeof ColorOther
@@ -44,9 +45,9 @@ export interface ColorScale {
/** Returns hex color for given value */
color: (value: number) => Color
/** Copies color to rgb int8 array */
- colorToArray: (value: number, array: Helpers.NumberArray, offset: number) => void
+ colorToArray: (value: number, array: NumberArray, offset: number) => void
/** Copies normalized (0 to 1) hex color to rgb array */
- normalizedColorToArray: (value: number, array: Helpers.NumberArray, offset: number) => void
+ normalizedColorToArray: (value: number, array: NumberArray, offset: number) => void
/** */
setDomain: (min: number, max: number) => void
/** Legend */
@@ -90,10 +91,10 @@ export namespace ColorScale {
}
return {
color,
- colorToArray: (value: number, array: Helpers.NumberArray, offset: number) => {
+ colorToArray: (value: number, array: NumberArray, offset: number) => {
Color.toArray(color(value), array, offset)
},
- normalizedColorToArray: (value: number, array: Helpers.NumberArray, offset: number) => {
+ normalizedColorToArray: (value: number, array: NumberArray, offset: number) => {
Color.toArrayNormalized(color(value), array, offset)
},
setDomain,
diff --git a/src/mol-util/type-helpers.ts b/src/mol-util/type-helpers.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a6e5f3c4206311ab97ceea6d6ff591c68577830d
--- /dev/null
+++ b/src/mol-util/type-helpers.ts
@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2018-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+export type Mutable<T> = {
+ -readonly [P in keyof T]: T[P]
+}
+export type TypedIntArray = Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array
+export type TypedFloatArray = Float32Array | Float64Array
+
+export type TypedArray = TypedIntArray | TypedFloatArray
+export type NumberArray = TypedArray | number[]
+export type UintArray = Uint8Array | Uint16Array | Uint32Array | number[]
+export type ValueOf<T> = T[keyof T]
+export type ArrayCtor<T> = { new(size: number): { [i: number]: T, length: number } }
+/** assignable ArrayLike version */
+export type AssignableArrayLike<T> = { [i: number]: T, length: number }
\ No newline at end of file