@niivue/niivue 0.40.0 → 0.41.1

package/build/index.d.ts

@@ -1,4 +1,3 @@
-import { Subject, Subscription } from 'rxjs';
 import { mat4, vec3, vec4, vec2 } from 'gl-matrix';
 import * as nifti from 'nifti-reader-js';
 import { WebSocketSubject } from 'rxjs/webSocket';
@@ -87,8 +86,8 @@ declare class NiivueObject3D {
     fieldOfViewDeObliqueMM?: vec3;
     mm?: vec4;
     constructor(id: number, vertexBuffer: WebGLBuffer, mode: number, indexCount: number, indexBuffer?: WebGLVertexArrayObject | null, vao?: WebGLVertexArrayObject | null);
-    static generateCrosshairs: (gl: WebGL2RenderingContext, id: number, xyzMM: vec4, xyzMin: vec3, xyzMax: vec3, radius: number, sides?: number) => NiivueObject3D;
-    static generateCrosshairsGeometry: (gl: WebGL2RenderingContext, xyzMM: vec4, xyzMin: vec3, xyzMax: vec3, radius: number, sides?: number) => Geometry;
+    static generateCrosshairs: (gl: WebGL2RenderingContext, id: number, xyzMM: vec4, xyzMin: vec3, xyzMax: vec3, radius: number, sides?: number, gap?: number) => NiivueObject3D;
+    static generateCrosshairsGeometry: (gl: WebGL2RenderingContext, xyzMM: vec4, xyzMin: vec3, xyzMax: vec3, radius: number, sides?: number, gap?: number) => Geometry;
     static getFirstPerpVector: (v1: vec3) => vec3;
     static subdivide: (verts: number[], faces: number[]) => void;
     static weldVertices: (verts: number[], faces: number[]) => number[];
@@ -183,6 +182,7 @@ type NiftiHeader = {
     intent_name: string;
     magic: string;
 };
+type Volume = Record<string, any>;
 type Point = {
     comments: Array<{
         text: string;
@@ -226,6 +226,7 @@ type ConnectomeOptions = {
     edgeMin: number;
     edgeMax: number;
     edgeScale: number;
+    legendLineThickness?: number;
 };
 type Connectome = ConnectomeOptions & {
     nodes: NVConnectomeNode[];
@@ -247,7 +248,7 @@ type LegacyConnectome = Partial<ConnectomeOptions> & {
 
 type ValuesArray = Array<{
     id: string;
-    vals: number[];
+    vals: Float32Array;
     global_min?: number;
     global_max?: number;
     cal_min?: number;
@@ -257,21 +258,21 @@ type TypedNumberArray = Float64Array | Float32Array | Uint32Array | Uint16Array
 type AnyNumberArray = number[] | TypedNumberArray;
 type DefaultMeshType = {
     positions: Float32Array;
-    indices: Int32Array;
+    indices: Uint32Array;
     colors?: Float32Array;
 };
 type TRACT = {
-    pts: number[];
-    offsetPt0: number[];
+    pts: Float32Array;
+    offsetPt0: Uint32Array;
     dps: ValuesArray;
 };
 type TT = {
-    pts: number[];
-    offsetPt0: number[];
+    pts: Float32Array;
+    offsetPt0: Uint32Array;
 };
 type TRX = {
-    pts: number[];
-    offsetPt0: number[];
+    pts: Float32Array;
+    offsetPt0: Uint32Array;
     dpg: ValuesArray;
     dps: ValuesArray;
     dpv: ValuesArray;
@@ -297,14 +298,14 @@ type ANNOT = Uint32Array | {
 };
 type MZ3 = Float32Array | {
     positions: Float32Array | null;
-    indices: Int32Array | null;
+    indices: Uint32Array | null;
     scalars: Float32Array;
     colors: Float32Array | null;
 };
 type GII = {
     scalars: Float32Array;
     positions?: Float32Array;
-    indices?: Int32Array;
+    indices?: Uint32Array;
     colormapLabel?: LUT;
     anatomicalStructurePrimary: string;
 };
@@ -313,9 +314,9 @@ type MGH = AnyNumberArray | {
     colormapLabel: LUT;
 };
 type X3D = {
-    positions: number[];
-    indices: Int32Array;
-    rgba255: number[];
+    positions: Float32Array;
+    indices: Uint32Array;
+    rgba255: Uint8Array;
 };
 
 /** Enum for text alignment
@@ -346,7 +347,7 @@ type NVMeshLayer = {
     frame4D: number;
     nFrame4D: number;
     values: number[];
-    isOutlineBorder: boolean;
+    outlineBorder?: number;
     isTransparentBelowCalMin?: boolean;
     alphaThreshold: boolean;
     base64?: string;
@@ -357,17 +358,17 @@ declare class NVMeshFromUrlOptions {
     gl: WebGL2RenderingContext | null;
     name: string;
     opacity: number;
-    rgba255: number[];
+    rgba255: Uint8Array;
     visible: boolean;
     layers: NVMeshLayer[];
     colorbarVisible: boolean;
-    constructor(url?: string, gl?: null, name?: string, opacity?: number, rgba255?: number[], visible?: boolean, layers?: never[], colorbarVisible?: boolean);
+    constructor(url?: string, gl?: null, name?: string, opacity?: number, rgba255?: Uint8Array, visible?: boolean, layers?: never[], colorbarVisible?: boolean);
 }
 type BaseLoadParams = {
     gl: WebGL2RenderingContext;
     name: string;
     opacity: number;
-    rgba255: number[];
+    rgba255: number[] | Uint8Array;
     visible: boolean;
     layers: NVMeshLayer[];
 };
@@ -395,21 +396,21 @@ declare class NVMesh {
     opacity: number;
     visible: boolean;
     meshShaderIndex: number;
-    offsetPt0: number[] | Uint32Array | null;
+    offsetPt0: Uint32Array | null;
     colormapInvert: boolean;
     fiberGroupColormap: ColorMap | null;
     indexBuffer: WebGLBuffer;
     vertexBuffer: WebGLBuffer;
     vao: WebGLVertexArrayObject;
     vaoFiber: WebGLVertexArrayObject;
-    pts: number[] | Float32Array;
-    tris?: number[] | Uint32Array;
+    pts: Float32Array;
+    tris?: Uint32Array;
     layers: NVMeshLayer[];
     type: MeshType;
     data_type?: string;
-    rgba255: number[];
+    rgba255: Uint8Array;
     fiberLength?: number;
-    fiberLengths?: number[];
+    fiberLengths?: Uint32Array;
     fiberDither: number;
     fiberColor: string;
     fiberDecimationStride: number;
@@ -427,6 +428,7 @@ declare class NVMesh {
     vertexCount: number;
     nodeScale: number;
     edgeScale: number;
+    legendLineThickness: number;
     nodeColormap: string;
     edgeColormap: string;
     nodeColormapNegative?: string;
@@ -453,22 +455,17 @@ declare class NVMesh {
      * @param colorbarVisible - does this mesh display a colorbar
      * @param anatomicalStructurePrimary - region for mesh. Default is an empty string
      */
-    constructor(pts: number[] | Float32Array, tris: number[] | Uint32Array, name: string | undefined, rgba255: number[] | undefined, opacity: number | undefined, visible: boolean | undefined, gl: WebGL2RenderingContext, connectome?: LegacyConnectome | string | null, dpg?: ValuesArray | null, dps?: ValuesArray | null, dpv?: ValuesArray | null, colorbarVisible?: boolean, anatomicalStructurePrimary?: string);
+    constructor(pts: Float32Array, tris: Uint32Array, name: string | undefined, rgba255: Uint8Array | undefined, opacity: number | undefined, visible: boolean | undefined, gl: WebGL2RenderingContext, connectome?: LegacyConnectome | string | null, dpg?: ValuesArray | null, dps?: ValuesArray | null, dpv?: ValuesArray | null, colorbarVisible?: boolean, anatomicalStructurePrimary?: string);
+    initValuesArray(va: ValuesArray): ValuesArray;
     linesToCylinders(gl: WebGL2RenderingContext, posClrF32: Float32Array, indices: number[]): void;
     updateFibers(gl: WebGL2RenderingContext): void;
-    updateConnectome(gl: WebGL2RenderingContext): void;
     indexNearestXYZmm(Xmm: number, Ymm: number, Zmm: number): number[];
     updateMesh(gl: WebGL2RenderingContext): void;
     reverseFaces(gl: WebGL2RenderingContext): void;
     setLayerProperty(id: number, key: keyof NVMeshLayer, val: number | string | boolean, gl: WebGL2RenderingContext): void;
     setProperty(key: keyof this, val: unknown, gl: WebGL2RenderingContext): void;
-    generatePosNormClr(pts: number[] | Float32Array, tris: number[] | Uint32Array, rgba255: number[]): Float32Array;
-    static loadConnectomeFromFreeSurfer(json: {
-        points?: Point[];
-        data_type: string;
-    }, gl: WebGL2RenderingContext, name?: string, opacity?: number, visible?: boolean): NVMesh;
-    static loadConnectomeFromJSON(json: Record<string, unknown>, gl: WebGL2RenderingContext, name?: string, opacity?: number, visible?: boolean): NVMesh;
-    static readMesh(buffer: ArrayBuffer, name: string, gl: WebGL2RenderingContext, opacity?: number, rgba255?: number[], visible?: boolean): NVMesh;
+    generatePosNormClr(pts: Float32Array, tris: Uint32Array, rgba255: Uint8Array): Float32Array;
+    static readMesh(buffer: ArrayBuffer, name: string, gl: WebGL2RenderingContext, opacity?: number, rgba255?: Uint8Array, visible?: boolean): NVMesh;
     static loadLayer(layer: NVMeshLayer, nvmesh: NVMesh): Promise<void>;
     /**
      * factory function to load and return a new NVMesh instance from a given URL
@@ -550,7 +547,6 @@ type ImageFromUrlOptions = {
     cal_max?: number;
     trustCalMinMax?: boolean;
     percentileFrac?: number;
-    visible?: boolean;
     useQFormNotSForm?: boolean;
     alphaThreshold?: boolean;
     colormapNegative?: string;
@@ -577,7 +573,6 @@ type ImageFromFileOptions = {
     trustCalMinMax?: boolean;
     percentileFrac?: number;
     ignoreZeroVoxels?: boolean;
-    visible?: boolean;
     useQFormNotSForm?: boolean;
     colormapNegative?: string;
     imageType?: ImageType;
@@ -594,7 +589,6 @@ type ImageFromBase64 = {
     trustCalMinMax?: boolean;
     percentileFrac?: number;
     ignoreZeroVoxels?: boolean;
-    visible?: boolean;
 };
 type ImageMetadata = {
     id: string;
@@ -609,7 +603,7 @@ type ImageMetadata = {
     dt: number;
     bpv: number;
 };
-declare const NVImageFromUrlOptions: (url: string, urlImageData?: string, name?: string, colormap?: string, opacity?: number, cal_min?: number, cal_max?: number, trustCalMinMax?: boolean, percentileFrac?: number, ignoreZeroVoxels?: boolean, visible?: boolean, useQFormNotSForm?: boolean, colormapNegative?: string, frame4D?: number, imageType?: ImageType, cal_minNeg?: number, cal_maxNeg?: number, colorbarVisible?: boolean, alphaThreshold?: boolean, colormapLabel?: string[]) => ImageFromUrlOptions;
+declare const NVImageFromUrlOptions: (url: string, urlImageData?: string, name?: string, colormap?: string, opacity?: number, cal_min?: number, cal_max?: number, trustCalMinMax?: boolean, percentileFrac?: number, ignoreZeroVoxels?: boolean, useQFormNotSForm?: boolean, colormapNegative?: string, frame4D?: number, imageType?: ImageType, cal_minNeg?: number, cal_maxNeg?: number, colorbarVisible?: boolean, alphaThreshold?: boolean, colormapLabel?: string[]) => ImageFromUrlOptions;
 
 /**
  * a NVImage encapsulates some images data and provides methods to query and operate on images
@@ -633,7 +627,6 @@ declare class NVImage {
     cal_minNeg: number;
     cal_maxNeg: number;
     colorbarVisible: boolean;
-    visible: boolean;
     modulationImage: number | null;
     modulateAlpha: number;
     series: any;
@@ -708,7 +701,6 @@ declare class NVImage {
      * @param trustCalMinMax - whether or not to trust cal_min and cal_max from the nifti header (trusting results in faster loading)
      * @param percentileFrac - the percentile to use for setting the robust range of the display values (smart intensity setting for images with large ranges)
      * @param ignoreZeroVoxels - whether or not to ignore zero voxels in setting the robust range of display values
-     * @param visible - whether or not this image is to be visible
      * @param useQFormNotSForm - give precedence to QForm (Quaternion) or SForm (Matrix)
      * @param colormapNegative - a color map to use for symmetrical negative intensities
      * @param frame4D - volume displayed, 0 indexed, must be less than nFrame4D
@@ -724,7 +716,7 @@ declare class NVImage {
      * @param colorbarVisible - TODO
      * @param colormapLabel - TODO
      */
-    constructor(dataBuffer?: ArrayBuffer | ArrayBuffer[] | null, name?: string, colormap?: string, opacity?: number, pairedImgData?: ArrayBuffer | null, cal_min?: number, cal_max?: number, trustCalMinMax?: boolean, percentileFrac?: number, ignoreZeroVoxels?: boolean, visible?: boolean, useQFormNotSForm?: boolean, colormapNegative?: string, frame4D?: number, imageType?: ImageType, cal_minNeg?: number, cal_maxNeg?: number, colorbarVisible?: boolean, colormapLabel?: LUT | null);
+    constructor(dataBuffer?: ArrayBuffer | ArrayBuffer[] | null, name?: string, colormap?: string, opacity?: number, pairedImgData?: ArrayBuffer | null, cal_min?: number, cal_max?: number, trustCalMinMax?: boolean, percentileFrac?: number, ignoreZeroVoxels?: boolean, useQFormNotSForm?: boolean, colormapNegative?: string, frame4D?: number, imageType?: ImageType, cal_minNeg?: number, cal_maxNeg?: number, colorbarVisible?: boolean, colormapLabel?: LUT | null);
     computeObliqueAngle(mtx44: mat4): number;
     calculateOblique(): void;
     THD_daxes_to_NIFTI(xyzDelta: number[], xyzOrigin: number[], orientSpecific: number[]): void;
@@ -763,7 +755,7 @@ declare class NVImage {
      * factory function to load and return a new NVImage instance from a given URL
      * @returns  NVImage instance
      */
-    static loadFromUrl({ url, urlImgData, headers, name, colormap, opacity, cal_min, cal_max, trustCalMinMax, percentileFrac, ignoreZeroVoxels, visible, useQFormNotSForm, colormapNegative, frame4D, isManifest, limitFrames4D, imageType, colorbarVisible }?: Partial<Omit<ImageFromUrlOptions, 'url'>> & {
+    static loadFromUrl({ url, urlImgData, headers, name, colormap, opacity, cal_min, cal_max, trustCalMinMax, percentileFrac, ignoreZeroVoxels, useQFormNotSForm, colormapNegative, frame4D, isManifest, limitFrames4D, imageType, colorbarVisible }?: Partial<Omit<ImageFromUrlOptions, 'url'>> & {
         url?: string | Uint8Array | ArrayBuffer;
     }): Promise<NVImage>;
     static readFileAsync(file: File, bytesToLoad?: number): Promise<ArrayBuffer>;
@@ -771,7 +763,7 @@ declare class NVImage {
      * factory function to load and return a new NVImage instance from a file in the browser
      */
     static loadFromFile({ file, // file can be an array of file objects or a single file object
-    name, colormap, opacity, urlImgData, cal_min, cal_max, trustCalMinMax, percentileFrac, ignoreZeroVoxels, visible, useQFormNotSForm, colormapNegative, frame4D, limitFrames4D, imageType }: ImageFromFileOptions): Promise<NVImage>;
+    name, colormap, opacity, urlImgData, cal_min, cal_max, trustCalMinMax, percentileFrac, ignoreZeroVoxels, useQFormNotSForm, colormapNegative, frame4D, limitFrames4D, imageType }: ImageFromFileOptions): Promise<NVImage>;
     /**
      * factory function to load and return a new NVImage instance from a base64 encoded string
      *
@@ -779,7 +771,7 @@ declare class NVImage {
      * @example
      * myImage = NVImage.loadFromBase64('SomeBase64String')
      */
-    static loadFromBase64({ base64, name, colormap, opacity, cal_min, cal_max, trustCalMinMax, percentileFrac, ignoreZeroVoxels, visible }: ImageFromBase64): NVImage;
+    static loadFromBase64({ base64, name, colormap, opacity, cal_min, cal_max, trustCalMinMax, percentileFrac, ignoreZeroVoxels }: ImageFromBase64): NVImage;
     /**
      * make a clone of a NVImage instance and return a new NVImage
      * @returns NVImage instance
@@ -850,7 +842,6 @@ type FreeSurferConnectome = {
 declare class NVConnectome extends NVMesh {
     gl: WebGL2RenderingContext;
     nodesChanged: EventTarget;
-    legendLineThickness?: number;
     constructor(gl: WebGL2RenderingContext, connectome: LegacyConnectome);
     static convertLegacyConnectome(json: LegacyConnectome): Connectome;
     static convertFreeSurferConnectome(json: FreeSurferConnectome, colormap?: string): Connectome;
@@ -902,6 +893,7 @@ type NVConfigOptions = {
     textHeight: number;
     colorbarHeight: number;
     crosshairWidth: number;
+    crosshairGap: number;
     rulerWidth: number;
     show3Dcrosshair: boolean;
     backColor: number[];
@@ -918,7 +910,7 @@ type NVConfigOptions = {
     longTouchTimeout: number;
     keyDebounceTime: number;
     isNearestInterpolation: boolean;
-    isAtlasOutline: boolean;
+    atlasOutline: number;
     isRuler: boolean;
     isColorbar: boolean;
     isOrientCube: boolean;
@@ -1358,7 +1350,7 @@ declare class NVMeshLoaders {
     static readTCK(buffer: ArrayBuffer): TCK;
     static readTRK(buffer: ArrayBuffer): TRK;
     static readTxtVTK(buffer: ArrayBuffer): VTK;
-    static readLayer(name: string | undefined, buffer: ArrayBuffer, nvmesh: NVMesh, opacity?: number, colormap?: string, colormapNegative?: string, useNegativeCmap?: boolean, cal_min?: number | null, cal_max?: number | null, isOutlineBorder?: boolean): void;
+    static readLayer(name: string | undefined, buffer: ArrayBuffer, nvmesh: NVMesh, opacity?: number, colormap?: string, colormapNegative?: string, useNegativeCmap?: boolean, cal_min?: number | null, cal_max?: number | null, outlineBorder?: number): void;
     static readSMP(buffer: ArrayBuffer, n_vert: number): Float32Array;
     static readSTC(buffer: ArrayBuffer, n_vert: number): Float32Array;
     static readCURV(buffer: ArrayBuffer, n_vert: number): Float32Array;
@@ -1372,6 +1364,7 @@ declare class NVMeshLoaders {
     static readICO(buffer: ArrayBuffer): DefaultMeshType;
     static readGEO(buffer: ArrayBuffer, isFlipWinding?: boolean): DefaultMeshType;
     static readOFF(buffer: ArrayBuffer): DefaultMeshType;
+    static readOBJMNI(buffer: ArrayBuffer): DefaultMeshType;
     static readOBJ(buffer: ArrayBuffer): DefaultMeshType;
     static readFreeSurfer(buffer: ArrayBuffer): DefaultMeshType;
     static readSRF(buffer: ArrayBuffer): DefaultMeshType;
@@ -1484,7 +1477,7 @@ type NiiVueOptions = {
     loadingText?: string;
     dragAndDropEnabled?: boolean;
     isNearestInterpolation?: boolean;
-    isAtlasOutline?: boolean;
+    atlasOutline?: number;
     isRuler?: boolean;
     isColorbar?: boolean;
     isOrientCube?: boolean;
@@ -1529,7 +1522,6 @@ type UIData = {
     dragClipPlaneStartDepthAziElev: number[];
     lastTwoTouchDistance: number;
     multiTouchGesture: boolean;
-    loading$: Subject<unknown>;
     dpr?: number;
 };
 type SaveImageOptions = {
@@ -1614,10 +1606,10 @@ declare class Niivue {
     position?: vec3;
     extentsMin?: vec3;
     extentsMax?: vec3;
+    private resizeObserver;
     syncOpts: Record<string, unknown>;
     readyForSync: boolean;
     uiData: UIData;
-    eventsToSubjects: Record<string, Subject<unknown>>;
     back: NVImage | null;
     overlays: NVImage[];
     deferredVolumes: ImageFromUrlOptions[];
@@ -1829,6 +1821,7 @@ declare class Niivue {
         textHeight: number;
         colorbarHeight: number;
         crosshairWidth: number;
+        crosshairGap: number;
         rulerWidth: number;
         show3Dcrosshair: boolean;
         backColor: number[];
@@ -1845,7 +1838,7 @@ declare class Niivue {
         longTouchTimeout: number;
         keyDebounceTime: number;
         isNearestInterpolation: boolean;
-        isAtlasOutline: boolean;
+        atlasOutline: number;
         isRuler: boolean;
         isColorbar: boolean;
         isOrientCube: boolean;
@@ -1909,7 +1902,6 @@ declare class Niivue {
     initialized: boolean;
     currentDrawUndoBitmap: number;
     loadingText: string;
-    subscriptions: Array<Record<string, Subscription>>;
     /**
      * @param options - options object to set modifiable Niivue properties
      */
@@ -1938,28 +1930,6 @@ declare class Niivue {
      * @see {@link https://niivue.github.io/niivue/features/multiplanar.html|live demo usage}
      */
     attachTo(id: string, isAntiAlias?: null): Promise<this>;
-    /**
-     * register a callback function to run when known Niivue events happen
-     * @param event - the name of the event to watch for. Event names are shown in the type column
-     * @param callback - the function to call when the event happens
-     * @example
-     * niivue = new Niivue()
-     *
-     * // 'location' update event is fired when the crosshair changes position via user input
-     * function doSomethingWithLocationData(data)\{
-     *    // data has the shape \{mm: [N, N, N], vox: [N, N, N], frac: [N, N, N], values: this.volumes.map(v =\> \{return val\})\}
-     *    //...
-     * \}
-     */
-    on(event: string, callback: (data: unknown) => void): void;
-    /**
-     * off unsubscribes events and subjects (the opposite of on)
-     * @param event - the name of the event to watch for. Event names are shown in the type column
-     * @example
-     * niivue = new Niivue()
-     * niivue.off('location')
-     */
-    off(event: string): void;
     /**
      * attach the Niivue instance to a canvas element directly
      * @param canvas - the canvas element reference
@@ -2245,6 +2215,17 @@ declare class Niivue {
      * @see {@link https://niivue.github.io/niivue/features/meshes.html|live demo usage}
      */
     setMeshProperty(id: number, key: keyof NVMesh, val: number): void;
+    /**
+     * returns the index of the mesh vertex that is closest to the provided coordinates
+     * @param id - identity of mesh to change
+     * @param Xmm - location in left/right dimension
+     * @param Ymm - location in posterior/anterior dimension
+     * @param Zmm - location in foot/head dimension
+     * @returns the an array where ret[0] is the mesh index and ret[1] is distance from vertex to coordinates
+     * @example niivue.indexNearestXYZmm(niivue.meshes[0].id, -22, 42, 13)
+     * @see {@link https://niivue.github.io/niivue/features/clipplanes.html | live demo usage}
+     */
+    indexNearestXYZmm(mesh: number, Xmm: number, Ymm: number, Zmm: number): number[];
     /**
      * reverse triangle winding of mesh (swap front and back faces)
      * @param id - identity of mesh to change
@@ -2578,6 +2559,7 @@ declare class Niivue {
             node: NVConnectomeNode;
         };
     }): void;
+    loadConnectomeAsMesh(json: Connectome | LegacyConnectome | FreeSurferConnectome): NVMesh;
     /**
      * load a connectome specified by json
      * @param connectome - model
@@ -2786,7 +2768,7 @@ declare class Niivue {
     /**
      * modulate intensity of one image based on intensity of another
      * @param idTarget - the ID of the NVImage to be biased
-     * @param idModulation - the ID of the NVImage that controls bias (null to disable modulation)
+     * @param idModulation - the ID of the NVImage that controls bias (empty string to disable modulation)
      * @param modulateAlpha - does the modulation influence alpha transparency (values greater than 1).
      * @example niivue.setModulationImage(niivue.volumes[0].id, niivue.volumes[1].id);
      * @see {@link https://niivue.github.io/niivue/features/modulate.html|live demo scalar usage}
@@ -2862,7 +2844,7 @@ declare class Niivue {
     drawTextBetween(startXYendXY: number[], str: string, scale?: number, color?: number[] | null): void;
     drawTextBelow(xy: number[], str: string, scale?: number, color?: number[] | null): void;
     updateInterpolation(layer: number, isForceLinear?: boolean): void;
-    setAtlasOutline(isOutline: boolean): void;
+    setAtlasOutline(isOutline: number): void;
     /**
      * select between nearest and linear interpolation for voxel based images
      * @param isNearest - whether nearest neighbor interpolation is used, else linear interpolation
@@ -2942,4 +2924,4 @@ declare class Niivue {
     set gl(gl: WebGL2RenderingContext | null);
 }
 
-export { DEFAULT_OPTIONS, DRAG_MODE, type DocumentData, type ExportDocumentData, LabelLineTerminator, LabelTextAlignment, MULTIPLANAR_TYPE, NVController, NVDocument, NVImage, NVImageFromUrlOptions, NVLabel3D, NVLabel3DStyle, NVMesh, NVMeshFromUrlOptions, NVMeshLoaders, NVUtilities, Niivue, SLICE_TYPE, cmapper, ColorTables as colortables };
+export { type Connectome, type ConnectomeOptions, DEFAULT_OPTIONS, DRAG_MODE, type DocumentData, type ExportDocumentData, LabelLineTerminator, LabelTextAlignment, type LegacyConnectome, type LegacyNodes, MULTIPLANAR_TYPE, type NVConnectomeEdge, type NVConnectomeNode, NVController, NVDocument, NVImage, NVImageFromUrlOptions, NVLabel3D, NVLabel3DStyle, NVMesh, NVMeshFromUrlOptions, NVMeshLoaders, NVUtilities, type NiftiHeader, Niivue, type Point, SLICE_TYPE, type Volume, cmapper, ColorTables as colortables };