astro-viewer 2.0.0 → 3.0.0

package/lib-esm/model/earth/types.js

@@ -0,0 +1 @@
+export {};

package/lib-esm/model/earth/wmts/WMTSAdapter.d.ts

@@ -0,0 +1,11 @@
+import type { WMTSLayerConfig, XYZLayerConfig, XYZTileCoord } from '../types.js';
+export declare class WMTSAdapter {
+    private _config;
+    constructor(config: WMTSLayerConfig);
+    toXYZLayerConfig(): XYZLayerConfig;
+    private getInferredMaxZoom;
+    getTileUrl(tile: XYZTileCoord): string;
+    private buildRestUrl;
+    private buildKvpUrl;
+    private getCommonTokenValues;
+}

package/lib-esm/model/earth/wmts/WMTSAdapter.js

@@ -0,0 +1,85 @@
+function replaceTokens(template, values) {
+    return Object.entries(values).reduce((result, [key, value]) => result.replace(new RegExp(`\\{${key}\\}`, 'g'), value), template);
+}
+export class WMTSAdapter {
+    _config;
+    constructor(config) {
+        this._config = config;
+    }
+    toXYZLayerConfig() {
+        const inferredMaxZoom = this.getInferredMaxZoom();
+        return {
+            urlTemplate: this._config.urlTemplate ?? this._config.baseUrl,
+            minZoom: this._config.minZoom,
+            maxZoom: inferredMaxZoom,
+            segmentsPerSide: this._config.segmentsPerSide,
+            tileSize: this._config.tileSize,
+            maxCachedTiles: this._config.maxCachedTiles,
+            subdomains: this._config.subdomains,
+            attribution: this._config.attribution,
+            flipY: this._config.flipY,
+            urlResolver: (tile) => this.getTileUrl(tile),
+        };
+    }
+    getInferredMaxZoom() {
+        const matrixLabelCount = this._config.matrixLabels?.length ?? 0;
+        const maxFromLabels = matrixLabelCount > 0 ? matrixLabelCount - 1 : undefined;
+        if (maxFromLabels == null) {
+            return this._config.maxZoom;
+        }
+        if (this._config.maxZoom == null) {
+            return maxFromLabels;
+        }
+        return Math.min(this._config.maxZoom, maxFromLabels);
+    }
+    getTileUrl(tile) {
+        return this._config.requestEncoding === 'rest'
+            ? this.buildRestUrl(tile)
+            : this.buildKvpUrl(tile);
+    }
+    buildRestUrl(tile) {
+        const template = this._config.urlTemplate ?? this._config.baseUrl;
+        const values = this.getCommonTokenValues(tile);
+        const resolved = replaceTokens(template, values);
+        return resolved.replace(/(?<!:)\/{2,}/g, '/');
+    }
+    buildKvpUrl(tile) {
+        const baseUrl = new URL(this._config.baseUrl);
+        const values = this.getCommonTokenValues(tile);
+        const params = baseUrl.searchParams;
+        params.set('SERVICE', 'WMTS');
+        params.set('REQUEST', 'GetTile');
+        params.set('VERSION', this._config.version ?? '1.0.0');
+        params.set('LAYER', this._config.layer);
+        params.set('STYLE', this._config.style ?? 'default');
+        params.set('FORMAT', this._config.format ?? 'image/png');
+        params.set('TILEMATRIXSET', this._config.tileMatrixSet);
+        params.set('TILEMATRIX', values.TileMatrix);
+        params.set('TILEROW', values.TileRow);
+        params.set('TILECOL', values.TileCol);
+        for (const [key, value] of Object.entries(this._config.dimensions ?? {})) {
+            params.set(key, value);
+        }
+        return baseUrl.toString();
+    }
+    getCommonTokenValues(tile) {
+        const dim = 2 ** tile.z;
+        const effectiveY = this._config.flipY ? dim - 1 - tile.y : tile.y;
+        const matrixLabel = this._config.matrixLabels?.[tile.z] ?? String(tile.z);
+        const tileFormat = this._config.format ?? 'image/png';
+        const tileFormatExtension = tileFormat.replace(/^image\//, '');
+        return {
+            Layer: this._config.layer,
+            Style: this._config.style ?? 'default',
+            Time: this._config.time ?? '',
+            TileMatrixSet: this._config.tileMatrixSet,
+            TileMatrix: matrixLabel,
+            TileRow: String(effectiveY),
+            TileCol: String(tile.x),
+            Format: tileFormatExtension,
+            TileFormat: tileFormat,
+            TileFormatExtension: tileFormatExtension,
+            ...Object.fromEntries(Object.entries(this._config.dimensions ?? {}).map(([key, value]) => [key, value])),
+        };
+    }
+}

package/lib-esm/model/earth/wmts/types.d.ts

@@ -0,0 +1 @@
+export type {};

package/lib-esm/model/earth/wmts/types.js

@@ -0,0 +1 @@
+export {};

package/lib-esm/model/footprints/FootprintSetGL.js

@@ -126,7 +126,7 @@ export class FootprintSetGL {
             throw new Error("geomColumn or its index is undefined in footprintsetProps");
         }
         for (let j = 0; j < in_data.length; j++) {
-            if (in_data[j][0] !== null) {
+            if (in_data[j][geomDataIndex] !== null) {
                 const footprint = new Footprint(in_data[j][geomDataIndex], in_data[j]);
                 if (footprint._valid) {
                     this.addFootprint(footprint);

package/lib-esm/model/terra/TerraFootprintSetGL.d.ts

@@ -0,0 +1,4 @@
+import { FootprintSetGL } from '../footprints/FootprintSetGL.js';
+export declare class TerraFootprintSetGL extends FootprintSetGL {
+    _kind: string;
+}

package/lib-esm/model/terra/TerraFootprintSetGL.js

@@ -0,0 +1,4 @@
+import { FootprintSetGL } from '../footprints/FootprintSetGL.js';
+export class TerraFootprintSetGL extends FootprintSetGL {
+    _kind = 'TerraFootprintSetGL';
+}

package/lib-esm/model/terra/TerraPointSetGL.d.ts

@@ -0,0 +1,4 @@
+import { CatalogueGL } from '../catalogues/CatalogueGL.js';
+export declare class TerraPointSetGL extends CatalogueGL {
+    _kind: string;
+}

package/lib-esm/model/terra/TerraPointSetGL.js

@@ -0,0 +1,4 @@
+import { CatalogueGL } from '../catalogues/CatalogueGL.js';
+export class TerraPointSetGL extends CatalogueGL {
+    _kind = 'TerraPointSetGL';
+}

package/lib-esm/shader/XYZShaderProgram.d.ts

@@ -0,0 +1,20 @@
+type XYZLocations = {
+    pMatrix: WebGLUniformLocation | null;
+    mMatrix: WebGLUniformLocation | null;
+    vMatrix: WebGLUniformLocation | null;
+    sampler: WebGLUniformLocation | null;
+    vertexPositionAttribute: number;
+    textureCoordAttribute: number;
+};
+export declare class XYZShaderProgram {
+    readonly locations: XYZLocations;
+    private _webgl;
+    private _shaderProgram?;
+    constructor(webgl: WebGL2RenderingContext);
+    get shaderProgram(): WebGLProgram;
+    enableProgram(): void;
+    enableShaders(pMatrix: Float32Array, vMatrix: Float32Array, mMatrix: Float32Array): void;
+    private initShaders;
+    private compileShader;
+}
+export {};

package/lib-esm/shader/XYZShaderProgram.js

@@ -0,0 +1,88 @@
+export class XYZShaderProgram {
+    locations;
+    _webgl;
+    _shaderProgram;
+    constructor(webgl) {
+        this._webgl = webgl;
+        this.locations = {
+            pMatrix: null,
+            mMatrix: null,
+            vMatrix: null,
+            sampler: null,
+            vertexPositionAttribute: -1,
+            textureCoordAttribute: -1,
+        };
+    }
+    get shaderProgram() {
+        const gl = this._webgl;
+        if (!this._shaderProgram) {
+            const program = gl.createProgram();
+            if (!program) {
+                throw new Error('Could not create XYZ shader program');
+            }
+            this._shaderProgram = program;
+            this.initShaders();
+        }
+        gl.useProgram(this._shaderProgram);
+        return this._shaderProgram;
+    }
+    enableProgram() {
+        this._webgl.useProgram(this.shaderProgram);
+    }
+    enableShaders(pMatrix, vMatrix, mMatrix) {
+        const gl = this._webgl;
+        const program = this.shaderProgram;
+        gl.useProgram(program);
+        this.locations.pMatrix = gl.getUniformLocation(program, 'uPMatrix');
+        this.locations.mMatrix = gl.getUniformLocation(program, 'uMMatrix');
+        this.locations.vMatrix = gl.getUniformLocation(program, 'uVMatrix');
+        this.locations.sampler = gl.getUniformLocation(program, 'uSampler');
+        this.locations.vertexPositionAttribute = gl.getAttribLocation(program, 'aVertexPosition');
+        this.locations.textureCoordAttribute = gl.getAttribLocation(program, 'aTextureCoord');
+        gl.uniformMatrix4fv(this.locations.pMatrix, false, pMatrix);
+        gl.uniformMatrix4fv(this.locations.vMatrix, false, vMatrix);
+        gl.uniformMatrix4fv(this.locations.mMatrix, false, mMatrix);
+        gl.uniform1i(this.locations.sampler, 0);
+    }
+    initShaders() {
+        const gl = this._webgl;
+        const vertexShader = this.compileShader(gl.VERTEX_SHADER, `#version 300 es
+      in vec3 aVertexPosition;
+      in vec2 aTextureCoord;
+      uniform mat4 uPMatrix;
+      uniform mat4 uVMatrix;
+      uniform mat4 uMMatrix;
+      out vec2 vTextureCoord;
+      void main(void) {
+        vTextureCoord = aTextureCoord;
+        gl_Position = uPMatrix * uVMatrix * uMMatrix * vec4(aVertexPosition, 1.0);
+      }`);
+        const fragmentShader = this.compileShader(gl.FRAGMENT_SHADER, `#version 300 es
+      precision mediump float;
+      in vec2 vTextureCoord;
+      uniform sampler2D uSampler;
+      out vec4 outColor;
+      void main(void) {
+        outColor = texture(uSampler, vTextureCoord);
+      }`);
+        gl.attachShader(this._shaderProgram, vertexShader);
+        gl.attachShader(this._shaderProgram, fragmentShader);
+        gl.linkProgram(this._shaderProgram);
+        if (!gl.getProgramParameter(this._shaderProgram, gl.LINK_STATUS)) {
+            throw new Error(gl.getProgramInfoLog(this._shaderProgram) || 'Could not initialise XYZ shaders');
+        }
+    }
+    compileShader(type, source) {
+        const gl = this._webgl;
+        const shader = gl.createShader(type);
+        if (!shader) {
+            throw new Error('Could not create XYZ shader');
+        }
+        gl.shaderSource(shader, source);
+        gl.compileShader(shader);
+        if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+            throw new Error(gl.getShaderInfoLog(shader) || 'XYZ shader compile error');
+        }
+        return shader;
+    }
+}

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "astro-viewer",
   "description": "Astrobrowser 3d engine.",
-
-  "version": "2.0.0",
+  "version": "3.0.0",
   "keywords": [
     "HiPS",
     "HiPS cutout",