@sswroom/sswr 1.6.13 → 1.6.15

package/hash.d.ts

@@ -72,4 +72,29 @@ export class MD5 extends Hash
 	getBlockSize(): number;
 
 	static calcBlock(hVals: number[], block: DataView): void;
+}
+
+export class CRC32
+{
+	static getPolynormialIEEE(): number;
+	static getPolynormialCastagnoli(): number;
+}
+
+export class CRC32R extends Hash
+{
+	crctab: number[];
+	currVal: number;
+
+	initTable(polynomial: number): void;
+
+	constructor(param: CRC32R|number|null|undefined);
+
+	getName(): string;
+	clone(): Hash;
+	clear(): void;
+	calc(buff: ArrayBuffer): void;
+	getValue(): ArrayBuffer;
+	getBlockSize(): number;
+
+	calcDirect(buff: ArrayBuffer): number;
 }

package/hash.js

@@ -80,6 +80,9 @@ export class SHA1 extends Hash
 		this.messageBlock = new Array(64);
 	}
 
+	/**
+	 * @param {ArrayBuffer | ArrayLike<number>} buff
+	 */
 	calc(buff)
 	{
 		if (!(buff instanceof ArrayBuffer))
@@ -167,7 +170,7 @@ export class SHA1 extends Hash
 				calBuff[i] = 0;
 				i++;
 			}
-			SHA1.calcBlock(intHash, calBuff);
+			SHA1.calcBlock(intHash, new Uint8Array(calBuff));
 			i = 0;
 			while (i < 56)
 			{
@@ -193,6 +196,10 @@ export class SHA1 extends Hash
 		return 64;
 	}
 
+	/**
+	 * @param {number[]} intermediateHash
+	 * @param {ArrayBuffer} messageBlock
+	 */
 	static calcBlock(intermediateHash, messageBlock)
 	{
 		let w = new Array(80);
@@ -306,6 +313,9 @@ export class MD5 extends Hash
 		this.buffSize = 0;
 	}
 
+	/**
+	 * @param {ArrayBuffer | ArrayLike<number>} buff
+	 */
 	calc(buff)
 	{
 		if (!(buff instanceof ArrayBuffer))
@@ -356,6 +366,7 @@ export class MD5 extends Hash
 
 	getValue()
 	{
+		/** @type {number[]} */
 		let calBuff = new Array(64);
 		let intHash = [
 			this.h[0],
@@ -389,7 +400,7 @@ export class MD5 extends Hash
 				calBuff[i] = 0;
 				i++;
 			}
-			MD5.calcBlock(intHash, calBuff);
+			MD5.calcBlock(intHash, new Uint8Array(calBuff));
 			i = 0;
 			while (i < 56)
 			{
@@ -415,6 +426,15 @@ export class MD5 extends Hash
 		return 64;
 	}
 
+	/**
+	 * @param {number[]} vals
+	 * @param {number} w
+	 * @param {number} x
+	 * @param {number} y
+	 * @param {number} z
+	 * @param {number} dataNum
+	 * @param {number} s
+	 */
 	static step1(vals, w, x, y, z, dataNum, s)
 	{
 		vals[w] += vals[z] ^ (vals[x] & (vals[y] ^ vals[z]));
@@ -423,6 +443,15 @@ export class MD5 extends Hash
 		vals[w] += vals[x];
 	}
 	
+	/**
+	 * @param {number[]} vals
+	 * @param {number} w
+	 * @param {number} x
+	 * @param {number} y
+	 * @param {number} z
+	 * @param {number} dataNum
+	 * @param {number} s
+	 */
 	static step2(vals, w, x, y, z, dataNum, s)
 	{
 		vals[w] += vals[y] ^ (vals[z] & (vals[x] ^ vals[y]));
@@ -431,6 +460,15 @@ export class MD5 extends Hash
 		vals[w] += vals[x];
 	}
 
+	/**
+	 * @param {number[]} vals
+	 * @param {number} w
+	 * @param {number} x
+	 * @param {number} y
+	 * @param {number} z
+	 * @param {number} dataNum
+	 * @param {number} s
+	 */
 	static step3(vals, w, x, y, z, dataNum, s)
 	{
 		vals[w] += vals[z] ^ vals[y] ^ vals[x];
@@ -439,6 +477,15 @@ export class MD5 extends Hash
 		vals[w] += vals[x];
 	}
 	
+	/**
+	 * @param {number[]} vals
+	 * @param {number} w
+	 * @param {number} x
+	 * @param {number} y
+	 * @param {number} z
+	 * @param {number} dataNum
+	 * @param {number} s
+	 */
 	static step4(vals, w, x, y, z, dataNum, s)
 	{
 		vals[w] += vals[y] ^ (vals[x] | ~vals[z]);
@@ -447,6 +494,10 @@ export class MD5 extends Hash
 		vals[w] += vals[x];
 	}
 
+	/**
+	 * @param {number[]} hVals
+	 * @param {ArrayBuffer} block
+	 */
 	static calcBlock(hVals, block)
 	{
 		let view = new DataView(block);
@@ -550,3 +601,207 @@ export class MD5 extends Hash
 		hVals[3] = vals[d];
 	}
 }
+
+/**
+ * @param {number} polynomial
+ */
+function crc32rReverse(polynomial)
+{
+	let v = polynomial;
+	let v2 = 0;
+	let i = 32;
+	while (i-- > 0)
+	{
+		v2 = (v2 >>> 1) | (v & 0x80000000);
+		v <<= 1;
+	}
+	return v2;
+}
+
+/**
+ * @param {number[]} tab
+ * @param {number} rpn
+ */
+function crc32rInitTable(tab, rpn)
+{
+	let i = 256;
+	let j;
+	let v;
+	while (i-- > 0)
+	{
+		v = i;
+		j = 8;
+		while (j-- > 0)
+		{
+			if (v & 1)
+			{
+				v = (v >>> 1) ^ rpn;
+			}
+			else
+			{
+				v = (v >>> 1);
+			}
+		}
+		tab[i] = v;
+	}
+
+	i = 256;
+	while (i-- > 0)
+	{
+		tab[256  + i] = (tab[0    + i] >>> 8) ^ tab[tab[0    + i] & 0xff];
+		tab[512  + i] = (tab[256  + i] >>> 8) ^ tab[tab[256  + i] & 0xff];
+		tab[768  + i] = (tab[512  + i] >>> 8) ^ tab[tab[512  + i] & 0xff];
+		tab[1024 + i] = (tab[768  + i] >>> 8) ^ tab[tab[768  + i] & 0xff];
+		tab[1280 + i] = (tab[1024 + i] >>> 8) ^ tab[tab[1024 + i] & 0xff];
+		tab[1536 + i] = (tab[1280 + i] >>> 8) ^ tab[tab[1280 + i] & 0xff];
+		tab[1792 + i] = (tab[1536 + i] >>> 8) ^ tab[tab[1536 + i] & 0xff];
+		tab[2048 + i] = (tab[1792 + i] >>> 8) ^ tab[tab[1792 + i] & 0xff];
+		tab[2304 + i] = (tab[2048 + i] >>> 8) ^ tab[tab[2048 + i] & 0xff];
+		tab[2560 + i] = (tab[2304 + i] >>> 8) ^ tab[tab[2304 + i] & 0xff];
+		tab[2816 + i] = (tab[2560 + i] >>> 8) ^ tab[tab[2560 + i] & 0xff];
+		tab[3072 + i] = (tab[2816 + i] >>> 8) ^ tab[tab[2816 + i] & 0xff];
+		tab[3328 + i] = (tab[3072 + i] >>> 8) ^ tab[tab[3072 + i] & 0xff];
+		tab[3584 + i] = (tab[3328 + i] >>> 8) ^ tab[tab[3328 + i] & 0xff];
+		tab[3840 + i] = (tab[3584 + i] >>> 8) ^ tab[tab[3584 + i] & 0xff];
+	}
+}
+
+/**
+ * @param {ArrayBuffer} buff
+ * @param {number[]} tab
+ * @param {number} currVal
+ */
+function crc32rCalc(buff, tab, currVal)
+{
+	let reader = new data.ByteReader(buff);
+	let i = 0;
+	let length = reader.getLength();
+	while ((length - i) >= 16)
+	{
+		let currVal1 = reader.readUInt32(i, true) ^ currVal;
+		let currVal2 = reader.readUInt32(i + 4, true);
+		let currVal3 = reader.readUInt32(i + 8, true);
+		let currVal4 = reader.readUInt32(i + 12, true);
+		i += 16;
+		currVal  = tab[0    +  (currVal4 >>> 24)];
+		currVal ^= tab[256  + ((currVal4 >>> 16) & 0xff)];
+		currVal ^= tab[512  + ((currVal4 >>> 8) & 0xff)];
+		currVal ^= tab[768  +  (currVal4 & 0xff)];
+		currVal ^= tab[1024 +  (currVal3 >>> 24)];
+		currVal ^= tab[1280 + ((currVal3 >>> 16) & 0xff)];
+		currVal ^= tab[1536 + ((currVal3 >>> 8) & 0xff)];
+		currVal ^= tab[1792 +  (currVal3 & 0xff)];
+		currVal ^= tab[2048 +  (currVal2 >>> 24)];
+		currVal ^= tab[2304 + ((currVal2 >>> 16) & 0xff)];
+		currVal ^= tab[2560 + ((currVal2 >>> 8) & 0xff)];
+		currVal ^= tab[2816 +  (currVal2 & 0xff)];
+		currVal ^= tab[3072 +  (currVal1 >>> 24)];
+		currVal ^= tab[3328 + ((currVal1 >>> 16) & 0xff)];
+		currVal ^= tab[3584 + ((currVal1 >>> 8) & 0xff)];
+		currVal ^= tab[3840 +  (currVal1  & 0xff)];
+	}
+	while ((length - i) >= 4)
+	{
+		currVal ^= reader.readUInt32(i, true);
+		i += 4;
+		currVal = tab[768 + (currVal & 0xff)] ^ tab[512 + ((currVal >>> 8) & 0xff)] ^  tab[256 + ((currVal >>> 16) & 0xff)] ^ tab[0 + (currVal >>> 24)];
+	}
+	while ((length - i) > 0)
+	{
+		currVal = tab[(currVal & 0xff) ^ reader.readUInt8(i)] ^ (currVal >>> 8);
+		i++;
+	}
+	return currVal;
+}
+
+export class CRC32
+{
+	static getPolynormialIEEE()
+	{
+		return 0x04C11DB7;
+	}
+
+	static getPolynormialCastagnoli()
+	{
+		return 0x1EDC6F41;
+	}
+}
+
+export class CRC32R extends Hash
+{
+	/**
+	 * @param {number} polynomial
+	 */
+	initTable(polynomial)
+	{
+		this.currVal = 0xffffffff;
+		let rpn = crc32rReverse(polynomial);
+		this.crctab = new Array(256 * 16);
+		crc32rInitTable(this.crctab, rpn);
+	}
+
+	/**
+	 * @param {{ crctab: any; currVal: any; }} param
+	 */
+	constructor(param)
+	{
+		super();
+		if (param instanceof CRC32R)
+		{
+			this.crctab = param.crctab;
+			this.currVal = param.currVal;
+		}
+		else if (typeof param == "number")
+		{
+
+			this.initTable(param);
+		}
+		else
+		{
+			this.initTable(CRC32.getPolynormialIEEE());
+		}
+	}
+
+	getName()
+	{
+		return "CRC (32-bit Reversed)";
+	}
+
+	clone()
+	{
+		return new CRC32R(this);
+	}
+
+	clear()
+	{
+		this.currVal = 0xffffffff;
+	}
+
+	/**
+	 * @param {ArrayBuffer} buff
+	 */
+	calc(buff)
+	{
+		this.currVal = crc32rCalc(buff, this.crctab, this.currVal);
+	}
+
+	getValue()
+	{
+		let builder = new data.ByteBuilder();
+		builder.writeInt32(0, ~this.currVal, false);
+		return builder.build();
+	}
+
+	getBlockSize()
+	{
+		return 1;
+	}
+
+	/**
+	 * @param {ArrayBuffer} buff
+	 */
+	calcDirect(buff)
+	{
+		return ~crc32rCalc(buff, this.crctab, 0xffffffff);
+	}
+}

package/map.d.ts

@@ -1,4 +1,4 @@
-import { Timestamp } from "./data";
+import * as data from "./data";
 import * as geometry from "./geometry";
 import * as kml from "./kml";
 import * as map from "./map";
@@ -82,22 +82,26 @@ export function getLayerData(svcUrl: string, onResultFunc: Function, layerName:
 
 declare class GPSRecord
 {
-	t: number;
+	recTime: number;
 	lat: number;
 	lon: number;
-	a: number;
-	s: number;
-	d: number;
-	v: boolean;
-	sate: number;
+	altitude: number;
+	speed: number;
+	heading: number;
+	valid: boolean;
+	sateUsed: number;
 }
 
-export class GPSTrack
+export class GPSTrack extends data.ParsedObject
 {
 	recs: GPSRecord[];
-	constructor(recs: GPSRecord[]);
+
+	constructor(recs: GPSRecord[], sourceName?: string);
+	addPosition(pos: GeolocationPosition);
+	getTrackCnt(): number;
+	getTrack(index: number): GPSRecord[]|null;
 	createLineString(): geometry.LineString;
-	getPosByTime(ts: Timestamp): math.Vector3;
+	getPosByTime(ts: data.Timestamp): math.Vector3;
 	getPosByTicks(ticks: number): math.Vector3;
 }
 

package/map.js

@@ -1,3 +1,4 @@
+import * as data from "./data.js";
 import * as geometry from "./geometry.js";
 import * as math from "./math.js";
 import * as web from "./web.js";
@@ -46,6 +47,9 @@ export function calcDistance(srid, geom, x, y)
 	return csys.calcSurfaceDistance(x, y, pt.x, pt.y, unit.Distance.Unit.METER);
 }
 
+/**
+ * @param {string} svcUrl
+ */
 export function getLayers(svcUrl, onResultFunc)
 {
 	web.loadJSON(svcUrl + '/getlayers', onResultFunc);
@@ -56,13 +60,49 @@ export function getLayerData(svcUrl, onResultFunc, layerName, dataFormat)
 	web.loadJSON(svcUrl + '/getlayerdata?name='+encodeURIComponent(layerName)+"&fmt="+encodeURIComponent(dataFormat), onResultFunc);
 }
 
-export class GPSTrack
+export class GPSTrack extends data.ParsedObject
 {
-	constructor(recs)
+	/**
+	 * @param {{recTime: number;lat: number;lon: number;altitude: number;speed: number;heading: number;valid: boolean;sateUsed: number;}[]} recs
+	 * @param {string|undefined} sourceName
+	 */
+	constructor(recs, sourceName)
 	{
+		super(sourceName||"Untitled.gpx", "GPSTrack");
 		this.recs = recs;
 	}
 
+	/**
+	 * @param {GeolocationPosition} pos
+	 */
+	addPosition(pos)
+	{
+		this.recs.push({
+			recTime: pos.timestamp,
+			lat: pos.coords.latitude,
+			lon: pos.coords.longitude,
+			altitude: pos.coords.altitude || 0,
+			heading: pos.coords.heading||0,
+			speed: (pos.coords.speed || 0) * 3.6 / 1.852,
+			valid: true,
+			sateUsed: -1});
+	}
+
+	getTrackCnt()
+	{
+		return 1;
+	}
+
+	/**
+	 * @param {number} index
+	 */
+	getTrack(index)
+	{
+		if (index == 0)
+			return this.recs;
+		return null;
+	}
+
 	createLineString()
 	{
 		let coordinates = new Array();
@@ -70,20 +110,26 @@ export class GPSTrack
 		let j = this.recs.length;
 		while (i < j)
 		{
-			coordinates.push([this.recs[i].lon, this.recs[i].lat, this.recs[i].a]);
+			coordinates.push([this.recs[i].lon, this.recs[i].lat, this.recs[i].altitude]);
 			i++;
 		}
 		return new geometry.LineString(4326, coordinates);
 	}
 
+	/**
+	 * @param {data.Timestamp} ts
+	 */
 	getPosByTime(ts)
 	{
 		return this.getPosByTicks(ts.toTicks());
 	}
 
+	/**
+	 * @param {number} ticks
+	 */
 	getPosByTicks(ticks)
 	{
-		if (ticks >= this.recs[0].t && ticks <= this.recs[this.recs.length - 1].t)
+		if (ticks >= this.recs[0].recTime && ticks <= this.recs[this.recs.length - 1].recTime)
 		{
 			let i = 0;
 			let j = this.recs.length - 1;
@@ -92,7 +138,7 @@ export class GPSTrack
 			while (i <= j)
 			{
 				k = (i + j) >> 1;
-				l = this.recs[k].t;
+				l = this.recs[k].recTime;
 				if (ticks > l)
 				{
 					i = k + 1;
@@ -103,17 +149,17 @@ export class GPSTrack
 				}
 				else
 				{
-					return new math.Vector3(this.recs[k].lon, this.recs[k].lat, this.recs[k].a);
+					return new math.Vector3(this.recs[k].lon, this.recs[k].lat, this.recs[k].altitude);
 				}
 			}
 			let tDiff;
 			let rec1 = this.recs[i - 1];
 			let rec2 = this.recs[i];
-			tDiff = rec2.t - rec1.t;
+			tDiff = rec2.recTime - rec1.recTime;
 			return new math.Vector3(
-				(rec1.lon * (rec2.t - ticks) + rec2.lon * (ticks - rec1.t)) / tDiff,
-				(rec1.lat * (rec2.t - ticks) + rec2.lat * (ticks - rec1.t)) / tDiff,
-				(rec1.a * (rec2.t - ticks) + rec2.a * (ticks - rec1.t)) / tDiff);
+				(rec1.lon * (rec2.recTime - ticks) + rec2.lon * (ticks - rec1.recTime)) / tDiff,
+				(rec1.lat * (rec2.recTime - ticks) + rec2.lat * (ticks - rec1.recTime)) / tDiff,
+				(rec1.altitude * (rec2.recTime - ticks) + rec2.altitude * (ticks - rec1.recTime)) / tDiff);
 		}
 		return new math.Vector3(0, 0, 0);
 	}
@@ -181,6 +227,7 @@ export class WMS
 			let node = doc.childNodes[0];
 			if (node.nodeName == "WMS_Capabilities" || node.nodeName == "WMT_MS_Capabilities")
 			{
+				// @ts-ignore
 				let attr = node.attributes.getNamedItem("version");
 				if (attr)
 				{

package/osm.js

@@ -1,24 +1,53 @@
+import * as math from "./math.js";
+
+/**
+ * @param {number} lon
+ * @param {number} level
+ * @param {number} tileSize
+ */
 export function lon2PixelX(lon, level, tileSize)
 {
 	return ((lon + 180.0) / 360.0 * (1 << level)) * tileSize;
 }
 
+/**
+ * @param {number} lat
+ * @param {number} level
+ * @param {number} tileSize
+ */
 export function lat2PixelY(lat, level, tileSize)
 {
 	return ((1.0 - Math.log(Math.tan(lat * Math.PI / 180.0) + 1.0 / Math.cos(lat * Math.PI / 180.0)) / Math.PI) / 2.0 * (1 << level)) * tileSize;
 }
 
+/**
+ * @param {number} x
+ * @param {number} level
+ * @param {number} tileSize
+ */
 export function pixelX2Lon(x, level, tileSize)
 {
 	return x / tileSize * 360.0 / (1 << level) - 180;
 }
 
+/**
+ * @param {number} y
+ * @param {number} level
+ * @param {number} tileSize
+ */
 export function pixelY2Lat(y, level, tileSize)
 {
 	let n = Math.PI - 2.0 * Math.PI * y / tileSize / (1 << level);
 	return 180.0 / Math.PI * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
 }
 
+/**
+ * @param {string} osmUrl
+ * @param {math.Coord2D} minCoord
+ * @param {math.Coord2D} maxCoord
+ * @param {number} minLev
+ * @param {number} maxLev
+ */
 export function tileUrls(osmUrl, minCoord, maxCoord, minLev, maxLev)
 {
 	let tileSize = 256;
@@ -42,7 +71,7 @@ export function tileUrls(osmUrl, minCoord, maxCoord, minLev, maxLev)
 			i = minX;
 			while (i <= maxX)
 			{
-				url = osmUrl.replace("{x}", i).replace("{y}", j).replace("{z}", minLev);
+				url = osmUrl.replace("{x}", ""+i).replace("{y}", ""+j).replace("{z}", ""+minLev);
 				ret.push(url);
 				i++;
 			}
@@ -53,6 +82,13 @@ export function tileUrls(osmUrl, minCoord, maxCoord, minLev, maxLev)
 	return ret;
 }
 
+/**
+ * @param {string[]} urls
+ * @param {string} osmUrl
+ * @param {number} minLev
+ * @param {number} maxLev
+ * @param {math.RectArea[]| null} areaList
+ */
 export function removeTileUrls(urls, osmUrl, minLev, maxLev, areaList)
 {
 	if (areaList == null || areaList.length == 0)
@@ -88,7 +124,7 @@ export function removeTileUrls(urls, osmUrl, minLev, maxLev, areaList)
 				i = minX;
 				while (i <= maxX)
 				{
-					url = osmUrl.replace("{x}", i).replace("{y}", j).replace("{z}", minLev);
+					url = osmUrl.replace("{x}", ""+i).replace("{y}", ""+j).replace("{z}", ""+minLev);
 					delete urlMap[url];
 					i++;
 				}
@@ -104,6 +140,9 @@ export function removeTileUrls(urls, osmUrl, minLev, maxLev, areaList)
 	}
 }
 
+/**
+ * @param {number} scale
+ */
 export function scale2Level(scale)
 {
 	return Math.round(Math.log10(204094080000.0 / scale / 256) / Math.log10(2));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sswroom/sswr",
-  "version": "1.6.13",
+  "version": "1.6.15",
   "description": "Libraries made by sswroom",
   "main": "sswr.js",
   "scripts": {
@@ -11,5 +11,8 @@
   "devDependencies": {
     "cesium": "^1.113.0",
     "leaflet": "^1.9.4"
+  },
+  "dependencies": {
+    "pako": "^2.1.0"
   }
 }