@sswroom/sswr 1.5.0 → 1.5.2

package/Changelog

@@ -1,3 +1,40 @@
+1.5.2
+-Support leaflet icon without adding to map
+-Added web.mimeFromExt
+-Added cesium.createFromKMLFeature
+-Added web.getImageInfo
+-Enhance KML parsing
+-Added olayer2.createFromKMLFeature
+-Added olayer2.createFromGeometry
+-Added olayer2.toPointArray
+-Added geometry.GeometryCollection
+-geometry.MultiPolygon support dynamic adding
+-kml.PolyStyle support outline
+-cesium support Polygon/MultiPolygon
+-Added text.toHex8, toHex16, toHex32
+-Added text.getEncList
+-Added text.TextBinEnc
+-Added text.UTF8TextBinEnc
+-Added text.UTF8LCaseTextBinEnc
+-Added text.UTF8UCaseTextBinEnc
+-Added text.HexTextBinEnc
+-Added text.Base64Enc
+-Added text.UTF16LETextBinEnc
+-Added text.UTF16BETextBinEnc
+-Added text.CPPByteArrBinEnc
+-Added text.CPPTextBinEnc
+-Added text.QuotedPrintableEnc
+-Added text.ASN1OIDBinEnc
+-Added text.URIEncoding
+-Added text.FormEncoding
+-Added text.ASCII85Enc
+-Added data.readUInt/readMUInt
+-Added net.oidText2PDU
+-Added net.oidToString
+
+1.5.1
+-Fixed AngleUnit problem
+
 1.5.0
 -Change unit.AngleUnit and unit.DistanceUnit to unit.Angle.Unit and unit.Distance.Unit
 -Added unit.Acceleration

package/cesium.d.ts

@@ -1,16 +1,23 @@
 import { Cartesian3, Ellipsoid, Viewer } from "cesium";
-import { Polygon } from "./geometry";
+import * as geometry from "./geometry";
 import * as kml from "./kml";
 import * as map from "./map";
 import { Coord2D } from "./math";
 
+declare class KMLFeatureOptions
+{
+	noPopup: boolean;
+}
+
 export function screenToLatLon(viewer: Viewer, x: number, y: number, ellipsoid: Ellipsoid) : Coord2D;
 export function fromCXYZArray(arr: any[]): Cartesian3[];
 export function toCartesian3Arr(coords: number[][]) : Cartesian3[];	
 export function newObjFromGeoJSON(geoJSON: object) : object;
 export function addGeoJSON(viewer: Viewer, geoJSON: object, color: any, extSize: number): void;
 export function fromCartesian3Array(viewer: Viewer, arr: Cartesian3[]): object[];
-export function fromPolygonGraphics(viewer: Viewer, pg: any): Polygon;
+export function fromPolygonGraphics(viewer: Viewer, pg: any): geometry.Polygon;
+export function createFromKMLFeature(feature: kml.Feature, options: KMLFeatureOptions): any;
+export function createFromGeometry(geom: geometry.Vector2D, options: GeometryOptions)
 
 export class CesiumMap extends map.MapControl
 {

package/cesium.js

@@ -1,29 +1,31 @@
+import * as data from "./data.js";
+import * as kml from "./kml.js";
 import * as map from "./map.js";
-import { Coord2D } from "./math.js";
-import { Polygon } from "./geometry.js";
+import * as math from "./math.js";
+import * as geometry from "./geometry.js";
 
 export function screenToLatLon(viewer, x, y, ellipsoid)
 {
-	var pos = new Cesium.Cartesian2(x, y);
+	let pos = new Cesium.Cartesian2(x, y);
 	if (ellipsoid == null)
 		ellipsoid = viewer.scene.globe.ellipsoid;
-	var cartesian = viewer.camera.pickEllipsoid(pos, ellipsoid);
+	let cartesian = viewer.camera.pickEllipsoid(pos, ellipsoid);
 	if (cartesian)
 	{
-		var cartographic = ellipsoid.cartesianToCartographic(cartesian);
-		return new Coord2D(cartographic.longitude * 180 / Math.PI, cartographic.latitude * 180 / Math.PI);
+		let cartographic = ellipsoid.cartesianToCartographic(cartesian);
+		return new math.Coord2D(cartographic.longitude * 180 / Math.PI, cartographic.latitude * 180 / Math.PI);
 	}
 	else
 	{
-		return new Coord2D(0, 0);
+		return new math.Coord2D(0, 0);
 	}
 }
 	
 export function fromCXYZArray(arr)
 {
-	var ret = new Array();
-	var i = 0;
-	var j = arr.length;
+	let ret = new Array();
+	let i = 0;
+	let j = arr.length;
 	while (i < j)
 	{
 		ret.push(Cesium.Cartesian3.fromArray(arr[i]));
@@ -34,9 +36,9 @@ export function fromCXYZArray(arr)
 	
 export function toCartesian3Arr(coords)
 {
-	var arr = new Array();
-	var i = 0;
-	var j = coords.length;
+	let arr = new Array();
+	let i = 0;
+	let j = coords.length;
 	if (coords[0].length == 3)
 	{
 		while (i < j)
@@ -58,11 +60,11 @@ export function toCartesian3Arr(coords)
 	
 export function newObjFromGeoJSON(geoJSON)
 {
-	var o = new Object();
+	let o = new Object();
 	o.id = geoJSON.id;
 	o.name = geoJSON.id;
-	var n;
-	var props = new Array();
+	let n;
+	let props = new Array();
 	for (n in geoJSON.properties)
 	{
 		props.push(text.toHTMLText(n)+": "+text.toHTMLText(geoJSON.properties[n]));
@@ -73,11 +75,11 @@ export function newObjFromGeoJSON(geoJSON)
 
 export function addGeoJSON(viewer, geoJSON, color, extSize)
 {
-	var oColor = color.darken(0.5, new Cesium.Color());
+	let oColor = color.darken(0.5, new Cesium.Color());
 	if (geoJSON.type == "FeatureCollection")
 	{
-		var i = 0;
-		var j = geoJSON.features.length;
+		let i = 0;
+		let j = geoJSON.features.length;
 		while (i < j)
 		{
 			addGeoJSON(viewer, geoJSON.features[i], color, extSize);			
@@ -86,14 +88,14 @@ export function addGeoJSON(viewer, geoJSON, color, extSize)
 	}
 	else if (geoJSON.type == "Feature")
 	{
-		var o;
+		let o;
 		if (geoJSON.geometry != null)
 		{
 			if (geoJSON.geometry.type == "Polygon")
 			{
-				var coordinates = geoJSON.geometry.coordinates;
-				var i = 0;
-				var j = coordinates.length;
+				let coordinates = geoJSON.geometry.coordinates;
+				let i = 0;
+				let j = coordinates.length;
 				while (i < j)
 				{
 					o = newObjFromGeoJSON(geoJSON);
@@ -119,12 +121,12 @@ export function addGeoJSON(viewer, geoJSON, color, extSize)
 
 export function fromCartesian3Array(viewer, arr)
 {
-	var coordinates = new Array();
-	var points;
-	var ellipsoid = viewer.scene.globe.ellipsoid;
-	var cartoArr = ellipsoid.cartesianArrayToCartographicArray(arr);
-	var i = 0;
-	var j = cartoArr.length;
+	let coordinates = new Array();
+	let points;
+	let ellipsoid = viewer.scene.globe.ellipsoid;
+	let cartoArr = ellipsoid.cartesianArrayToCartographicArray(arr);
+	let i = 0;
+	let j = cartoArr.length;
 	while (i < j)
 	{
 		points = new Array();
@@ -139,17 +141,213 @@ export function fromCartesian3Array(viewer, arr)
 	
 export function fromPolygonGraphics(viewer, pg)
 {
-	var coordinates = new Array();
-	var hierarchy = pg.hierarchy.getValue();
+	let coordinates = new Array();
+	let hierarchy = pg.hierarchy.getValue();
 	coordinates.push(fromCartesian3Array(viewer, hierarchy.positions));
-	var i = 0;
-	var j =hierarchy.holes.length;
+	let i = 0;
+	let j =hierarchy.holes.length;
 	while (i < j)
 	{
 		coordinates.push(fromCartesian3Array(viewer, hierarchy.holes[i].positions));
 		i++;
 	}
-	return new Polygon(4326, coordinates);
+	return new geometry.Polygon(4326, coordinates);
+}
+
+export function createFromKMLFeature(feature, options)
+{
+	options = data.mergeOptions(options, {noPopup: false});
+	if (feature instanceof kml.Container)
+	{
+		let i;
+		let layers = [];
+		let layer;
+		for (i in feature.features)
+		{
+			layer = createFromKMLFeature(feature.features[i], options);
+			if (layer instanceof Cesium.Entity)
+			{
+				layers.push(layer);
+			}
+			else if (layer != null)
+			{
+				let j;
+				for (j in layer)
+				{
+					layers.push(layer[j]);
+				}
+			}
+		}
+		return layers;
+	}
+	else if (feature instanceof kml.Placemark)
+	{
+		let opt = {};
+		if (feature.name)
+			opt.name = feature.name;
+		if (feature.style)
+		{
+			let style = feature.style;
+			if (style instanceof kml.StyleMap)
+			{
+				style = style.normalStyle;
+			}
+			if (style instanceof kml.Style)
+			{
+				if (style.iconStyle)
+				{
+					let s = style.iconStyle;
+					if (s.iconUrl)
+					{
+						opt.iconUrl = s.iconUrl;
+					}
+					if (s.hotSpotX && s.hotSpotY)
+					{
+						if (s.hotSpotX == 0)
+							opt.horizontalOrigin = Cesium.HorizontalOrigin.LEFT;
+						else if (s.hotSpotUnitX == kml.HotSpotUnit.Fraction && s.hotSpotX == 1)
+							opt.horizontalOrigin = Cesium.HorizontalOrigin.RIGHT;
+						if (s.hotSpotY == 0)
+							opt.verticalOrigin = Cesium.VerticalOrigin.TOP;
+						else if (s.hotSpotUnitY == kml.HotSpotUnit.Fraction && s.hotSpotY == 1)
+							opt.verticalOrigin = Cesium.VerticalOrigin.BOTTOM;
+						else
+						{
+							if (s.hotSpotX * 2 == s.hotSpotY)
+							{
+								opt.verticalOrigin = Cesium.VerticalOrigin.CENTER;
+							}
+						}
+					}
+				}
+				if (style.lineStyle)
+				{
+					let ls = style.lineStyle;
+					if (ls.color)
+						opt.lineColor = ls.color;
+					if (ls.width)
+						opt.lineWidth = ls.width;
+				}
+				if (style.polyStyle)
+				{
+					let ps = style.polyStyle;
+					if (ps.color)
+						opt.fillColor = ps.color;
+				}
+			}
+		}
+		let layer = createFromGeometry(feature.vec, opt);
+		if (layer)
+		{
+			if (feature.name)
+				layer.name = feature.name;
+			if (feature.description)
+				layer.description = feature.description;
+		}
+		return layer;
+	}
+	else
+	{
+		console.log("Unknown KML feature type", feature);
+		return null;
+	}
+}
+
+export function createFromGeometry(geom, options)
+{
+	if (geom instanceof geometry.Point)
+	{
+		let opt = {};
+		if (options)
+		{
+			if (options.name)
+				opt.title = options.name;
+			if (options.iconUrl)
+				opt.image = options.iconUrl;
+			if (options.horizontalOrigin)
+				opt.horizontalOrigin = options.horizontalOrigin;
+			if (options.verticalOrigin)
+				opt.verticalOrigin = options.verticalOrigin;
+		}
+		return new Cesium.Entity({
+			position: Cesium.Cartesian3.fromDegrees(geom.coordinates[0], geom.coordinates[1]),
+			billboard: new Cesium.BillboardGraphics(opt)});
+	}
+	else if (geom instanceof geometry.LineString)
+	{
+		let opt = {};
+		if (options.lineColor)
+		{
+			let c = kml.toColor(options.lineColor);
+			opt.material = new Cesium.Color(c.r, c.g, c.b, c.a);
+		}
+		if (options.lineWidth)
+			opt.width = options.lineWidth;
+		opt.positions = toCartesian3Arr(geom.coordinates);
+		return new Cesium.Entity({polyline: new Cesium.PolylineGraphics(opt)});
+	}
+	else if (geom instanceof geometry.Polygon)
+	{
+		let opt = {};
+		opt.heightReference = Cesium.HeightReference.CLAMP_TO_GROUND;
+		opt.height = 0;
+		if (options.lineColor)
+		{
+			let c = kml.toColor(options.lineColor);
+			opt.outlineColor = new Cesium.Color(c.r, c.g, c.b, c.a);
+			opt.outline = true;
+		}
+		if (options.lineWidth)
+		{
+			opt.outlineWidth = options.lineWidth;
+			opt.outline = true;
+		}
+		if (options.fillColor)
+		{
+			let c = kml.toColor(options.fillColor);
+			opt.material = new Cesium.Color(c.r, c.g, c.b, c.a);
+		}
+		opt.hierarchy = {positions: toCartesian3Arr(geom.geometries[0].coordinates), holes: []};
+		let i = 1;
+		let j = geom.geometries.length;
+		while (i < j)
+		{
+			opt.hierarchy.holes.push({positions: toCartesian3Arr(geom.geometries[i].coordinates)});
+			i++;
+		}
+		return new Cesium.Entity({polygon: new Cesium.PolygonGraphics(opt)});
+	}
+	else if (geom instanceof geometry.MultiPolygon)
+	{
+		if (geom.geometries.length == 1)
+		{
+			return createFromGeometry(geom.geometries[0], options);
+		}
+		let opt = {};
+		if (options.lineColor)
+		{
+			let c = kml.toColor(options.lineColor);
+			opt.outlineColor = new Cesium.Color(c.r, c.g, c.b, c.a);
+			opt.outline = true;
+		}
+		if (options.lineWidth)
+		{
+			opt.outlineWidth = options.lineWidth;
+			opt.outline = true;
+		}
+		if (options.fillColor)
+		{
+			let c = kml.toColor(options.fillColor);
+			opt.material = new Cesium.Color(c.r, c.g, c.b, c.a);
+		}
+		console.log("MultiPolygon not supported", geom);
+		return null;
+	}
+	else
+	{
+		console.log("Unknown geometry type", geom);
+		return null;
+	}
 }
 
 /*export function createPolygon(viewer, lats, lons, height)
@@ -162,11 +360,11 @@ export function fromPolygonGraphics(viewer, pg)
 	{
 		height = 0;
 	}
-	var ellipsoid = viewer.scene.globe.ellipsoid;
-	var o = new Object();
+	let ellipsoid = viewer.scene.globe.ellipsoid;
+	let o = new Object();
 	o.positions = new Array();
-	var i = 0;
-	var j = lats.length;
+	let i = 0;
+	let j = lats.length;
 	while (i < j)
 	{
 		o.positions.push(ellipsoid.cartographicToCartesian(new Cesium.Cartographic(lons[i] * Math.PI / 180, lats[i] * Math.PI / 180, height)));
@@ -174,7 +372,7 @@ export function fromPolygonGraphics(viewer, pg)
 	}
 	o.positions.push(ellipsoid.cartographicToCartesian(new Cesium.Cartographic(lons[0] * Math.PI / 180, lats[0] * Math.PI / 180, height)));
 	
-	var pg = new Cesium.PolygonGraphics(o);
+	let pg = new Cesium.PolygonGraphics(o);
 	return pg;
 }*/
 
@@ -198,13 +396,13 @@ export class CesiumMap extends map.MapControl
 	{
 		if (layer.type == map.WebMapType.OSMTile)
 		{
-			var opt = {};
-			if (options && options.maxZoom)
+			let opt = {};
+			if (layer.maxZoom)
 			{
-				opt.maximumLevel = options.maxZoom;
+				opt.maximumLevel = layer.maxZoom;
 			}
-			return new Cesium.ImageryLayer(new Cesium.UrlTemplateImageryProvider({
-				url: layer.url}, opt));
+			opt.url = layer.url;
+			return new Cesium.ImageryLayer(new Cesium.UrlTemplateImageryProvider(opt));
 		}
 	}
 
@@ -216,6 +414,27 @@ export class CesiumMap extends map.MapControl
 		{
 			this.viewer.imageryLayers.add(layer);
 		}
+		else if (layer instanceof Cesium.Entity)
+		{
+			this.viewer.entities.add(layer);
+		}
+		else if (data.isArray(layer))
+		{
+			let i;
+			for (i in layer)
+			{
+				this.addLayer(layer[i]);
+			}
+		}
+		else
+		{
+			console.log("Unknown type to add", layer);
+		}
+	}
+
+	addKMLFeature(feature)
+	{
+		this.addLayer(createFromKMLFeature(feature));
 	}
 
 //	uninit(): void;

package/data.d.ts

@@ -5,6 +5,12 @@ export function arrayBuffer2Base64(buff: any): string;
 export function compare(a: any, b: any): number;
 export function sort(arr: object[], compareFunc?: (val1: object, val2: object) => number, firstIndex?: number, lastIndex?: number): void;
 export function mergeOptions(options: object | null, defOptions: object): object;
+export function readUInt16(arr: Uint8Array, index: number): number;
+export function readMUInt16(arr: Uint8Array, index: number): number;
+export function readUInt24(arr: Uint8Array, index: number): number;
+export function readMUInt24(arr: Uint8Array, index: number): number;
+export function readUInt32(arr: Uint8Array, index: number): number;
+export function readMUInt32(arr: Uint8Array, index: number): number;
 
 export class DateValue
 {