@sswroom/sswr 1.3.1 → 1.4.1

package/Changelog

@@ -1,3 +1,16 @@
+1.4.1
+-Fixed problems in Chrome
+
+1.4.0
+-Added LinearRing.createFromCircle
+-Full support kml.IconStyle
+-Added LinearRing.toPolygon
+-Added map.MapControl
+-Added OpenLayers2 supporting (olayer2.js)
+-Added web.handleFileDrop
+-Added map.WMS
+-Added leaflet.fromLatLngBounds
+
 1.3.1
 -Added leaflet.createLayer
 -Added web.buildTable

package/geometry.d.ts

@@ -36,6 +36,7 @@ export enum VectorType
 }
 
 export class Vector2D {
+	srid: number;
 	type: VectorType;
 	constructor(srid: number);
 	insideOrTouch(coord: math.Coord2D): boolean;
@@ -63,6 +64,9 @@ export class LinearRing extends LineString
 	insideOrTouch(coord: math.Coord2D): boolean;
 	isOpen(): boolean;
 	isClose(): boolean;
+	toPolygon(): Polygon;
+
+	static createFromCircle(srid: number, center: math.Coord2D, radiusX: number, radiusY: number, nPoints: number): LinearRing;
 }
 
 export class MultiGeometry<VecType> extends Vector2D

package/geometry.js

@@ -305,6 +305,27 @@ export class LinearRing extends LineString
 		var lastPoint = this.coordinates[this.coordinates.length - 1];
 		return firstPoint[0] == lastPoint[0] && firstPoint[1] == lastPoint[1];
 	}
+
+	toPolygon()
+	{
+		return new Polygon(this.srid, [this.coordinates]);
+	}
+
+	static createFromCircle(srid, center, radiusX, radiusY, nPoints)
+	{
+		var pos = [];
+		var ratio = 2 * Math.PI / nPoints;
+		var i = 0;
+		var angle;
+		i = 0;
+		while (i <= nPoints)
+		{
+			angle = i * ratio;
+			pos.push([center.x + radiusX * Math.cos(angle), center.y + radiusY * Math.sin(angle)]);
+			i++;
+		}
+		return new LinearRing(srid, pos);
+	}
 }
 
 export class MultiGeometry extends Vector2D

package/kml.d.ts

@@ -86,8 +86,18 @@ export class ColorStyle extends Element
 
 export class IconStyle extends ColorStyle
 {
-	
+	scale: number;
+	heading: number;
+	iconUrl: string;
+	hotSpotX: number;
+	hotSpotY: number;
+
 	constructor();
+	setScale(scale: number);
+	setHeading(heading: number);
+	setIconUrl(iconUrl: string);
+	setHotSpotX(hotSpotX: number);
+	setHotSpotY(hotSpotY: number);
 	appendOuterXML(strs: string[], level: number): void;
 	equals(o: IconStyle): boolean;
 };

package/kml.js

@@ -142,10 +142,47 @@ export class IconStyle extends ColorStyle
 		super();
 	}
 
+	setScale(scale)
+	{
+		this.scale = scale;
+	}
+
+	setHeading(heading)
+	{
+		this.heading = heading;
+	}
+
+	setIconUrl(iconUrl)
+	{
+		this.iconUrl = iconUrl;
+	}
+
+	setHotSpotX(hotSpotX)
+	{
+		this.hotSpotX = hotSpotX;
+	}
+
+	setHotSpotY(hotSpotY)
+	{
+		this.hotSpotY = hotSpotY;
+	}
+
 	appendOuterXML(strs, level)
 	{
 		strs.push("\t".repeat(level)+"<IconStyle>");
 		this.appendInnerXML(strs, level + 1);
+		if (this.scale)
+			strs.push("\t".repeat(level + 1)+"<scale>"+this.scale+"</scale>");
+		if (this.heading != null)
+			strs.push("\t".repeat(level + 1)+"<heading>"+this.heading+"</heading>");
+		if (this.iconUrl)
+		{
+			strs.push("\t".repeat(level + 1)+"<Icon>");
+			strs.push("\t".repeat(level + 2)+"<href>"+text.toXMLText(this.iconUrl)+"</href>");
+			strs.push("\t".repeat(level + 1)+"</Icon>");
+		}
+		if (this.hotSpotX != null && this.hotSpotY != null)
+			strs.push("\t".repeat(level + 1)+"<hotSpot x="+text.toAttrText(""+this.hotSpotX)+" y="+text.toAttrText(""+this.hotSpotY)+" xunits=\"fraction\" yunits=\"fraction\"/>");
 		strs.push("\t".repeat(level)+"</IconStyle>");
 	}
 
@@ -155,6 +192,16 @@ export class IconStyle extends ColorStyle
 			return false;
 		if (!this.sameColor(o))
 			return false;
+		if (this.scale != o.scale)
+			return false;
+		if (this.heading != o.heading)
+			return false;
+		if (this.iconUrl != o.iconUrl)
+			return false;
+		if (this.hotSpotX != o.hotSpotX)
+			return false;
+		if (this.hotSpotY != o.hotSpotY)
+			return false;
 		return true;
 	}
 }
@@ -379,7 +426,6 @@ export class Style extends Element
 		{
 			return false;
 		}
-
 		if (labelStyle == null)
 		{
 			if (this.labelStyle != null)
@@ -393,7 +439,6 @@ export class Style extends Element
 		{
 			return false;
 		}
-
 		if (lineStyle == null)
 		{
 			if (this.lineStyle != null)
@@ -407,7 +452,6 @@ export class Style extends Element
 		{
 			return false;
 		}
-
 		if (polyStyle == null)
 		{
 			if (this.polyStyle != null)
@@ -421,7 +465,6 @@ export class Style extends Element
 		{
 			return false;
 		}
-
 		if (balloonStyle == null)
 		{
 			if (this.balloonStyle != null)
@@ -435,7 +478,6 @@ export class Style extends Element
 		{
 			return false;
 		}
-
 		if (listStyle == null)
 		{
 			if (this.listStyle != null)
@@ -583,7 +625,7 @@ export class Document extends Container
 		var i;
 		for (i in this.styleList)
 		{
-			if (this.styleList[i].isStyle(iconStyle, labelStyle, lineStyle, polyStyle, balloonStyle, lineStyle))
+			if (this.styleList[i].isStyle(iconStyle, labelStyle, lineStyle, polyStyle, balloonStyle, listStyle))
 				return this.styleList[i];
 		}
 		var style = new Style("style"+(this.styleList.length + 1));
@@ -659,38 +701,46 @@ export class Placemark extends Feature
 			}
 			strs.push("\t".repeat(level)+"</Point>");
 		}
-		else if (vec instanceof geometry.LineString)
+		else if (vec instanceof geometry.LinearRing)
 		{
-			var i;
-			strs.push("\t".repeat(level)+"<LineString>");
-			if (vec.coordinates[0].length >= 3)
+			if (subGeom)
 			{
-				if (subGeom != true)
-					strs.push("\t".repeat(level + 1)+"<altitudeMode>absolute</altitudeMode>");
-				strs.push("\t".repeat(level + 1)+"<coordinates>");
-				for (i in vec.coordinates)
+				var i;
+				strs.push("\t".repeat(level)+"<LinearRing>");
+				if (vec.coordinates[0].length >= 3)
 				{
-					strs.push("\t".repeat(level + 2)+vec.coordinates[i][0]+","+vec.coordinates[i][1]+","+vec.coordinates[i][2]+" ");
+					if (subGeom != true)
+						strs.push("\t".repeat(level + 1)+"<altitudeMode>absolute</altitudeMode>");
+					strs.push("\t".repeat(level + 1)+"<coordinates>");
+					for (i in vec.coordinates)
+					{
+						strs.push("\t".repeat(level + 2)+vec.coordinates[i][0]+","+vec.coordinates[i][1]+","+vec.coordinates[i][2]+" ");
+					}
+					strs.push("\t".repeat(level + 1)+"</coordinates>");
 				}
-				strs.push("\t".repeat(level + 1)+"</coordinates>");
+				else
+				{
+					if (subGeom != true)
+						strs.push("\t".repeat(level + 1)+"<tessellate>1</tessellate>");
+					strs.push("\t".repeat(level + 1)+"<coordinates>");
+					for (i in vec.coordinates)
+					{
+						strs.push("\t".repeat(level + 2)+vec.coordinates[i][0]+","+vec.coordinates[i][1]+" ");
+					}
+					strs.push("\t".repeat(level + 1)+"</coordinates>");
+				}
+				strs.push("\t".repeat(level)+"</LinearRing>");
 			}
 			else
 			{
-				if (subGeom != true)
-					strs.push("\t".repeat(level + 1)+"<tessellate>1</tessellate>");
-				strs.push("\t".repeat(level + 1)+"<coordinates>");
-				for (i in vec.coordinates)
-				{
-					strs.push("\t".repeat(level + 2)+vec.coordinates[i][0]+","+vec.coordinates[i][1]+" ");
-				}
-				strs.push("\t".repeat(level + 1)+"</coordinates>");
+				var pg = vec.toPolygon();
+				this.appendGeometry(strs, level, pg, subGeom);
 			}
-			strs.push("\t".repeat(level)+"</LineString>");
 		}
-		else if (vec instanceof geometry.LinearRing)
+		else if (vec instanceof geometry.LineString)
 		{
 			var i;
-			strs.push("\t".repeat(level)+"<LinearRing>");
+			strs.push("\t".repeat(level)+"<LineString>");
 			if (vec.coordinates[0].length >= 3)
 			{
 				if (subGeom != true)
@@ -713,7 +763,7 @@ export class Placemark extends Feature
 				}
 				strs.push("\t".repeat(level + 1)+"</coordinates>");
 			}
-			strs.push("\t".repeat(level)+"</LinearRing>");
+			strs.push("\t".repeat(level)+"</LineString>");
 		}
 		else if (vec instanceof geometry.Polygon)
 		{

package/leaflet.d.ts

@@ -1,9 +1,11 @@
 import * as L from "./node_modules/leaflet/src/Leaflet";
 import * as kml from "./kml";
-import { Coord2D } from "./math";
+import { Coord2D, RectArea } from "./math";
 import { LayerInfo } from "./map";
 
 export function fromLatLon(latLon: L.LatLng): Coord2D;
+export function fromLatLng(latLng: L.LatLng): Coord2D;
+export function fromLatLngBounds(b: L.LatLngBounds): RectArea;
 export function createLayer(layer: LayerInfo, options: object): L.Layer;
 export function createKMLLookAt(map: L.Map): kml.LookAt;
 export function toKMLFeature(layer: L.Layer, doc?: kml.Document): kml.Feature | null;

package/leaflet.js

@@ -1,12 +1,23 @@
 import * as data from "./data.js";
 import * as geometry from "./geometry.js";
 import * as kml from "./kml.js";
-import { Coord2D } from "./math.js";
+import * as math from "./math.js";
 import * as map from "./map.js";
+import * as web from "./web.js";
 
 export function fromLatLon(latLon)
 {
-	return new Coord2D(latLon.lng, latLon.lat);
+	return new math.Coord2D(latLon.lng, latLon.lat);
+}
+
+export function fromLatLng(latLng)
+{
+	return new math.Coord2D(latLng.lng, latLng.lat);
+}
+
+export function fromLatLngBounds(b)
+{
+	return new math.RectArea(b.getWest(), b.getSouth(), b.getEast(), b.getNorth());
 }
 
 export function createLayer(layer, options)
@@ -118,7 +129,14 @@ export function toKMLFeature(layer, doc)
 		{
 			var lineStyle = new kml.LineStyle();
 			if (layer.options.color)
-				lineStyle.fromCSSColor(layer.options.color);
+			{
+				var c = web.parseCSSColor(layer.options.color);
+				if (layer.options.opacity)
+				{
+					c.a = c.a * layer.options.opacity;
+				}
+				lineStyle.fromARGB(c.a, c.r, c.g, c.b);
+			}
 			if (layer.options.weight)
 				lineStyle.setWidth(layer.options.weight);
 			feature.setStyle(doc.getOrNewStyle(null, null, lineStyle, null, null, null));

package/map.d.ts

@@ -1,6 +1,7 @@
-import { CoordinateSystem, Vector3 } from "./math";
-import { LineString, Vector2D } from "./geometry";
 import { Timestamp } from "./data";
+import * as geometry from "./geometry";
+import * as map from "./map";
+import * as math from "./math";
 
 export enum DataFormat
 {
@@ -70,7 +71,7 @@ declare class GeoJSONFeatureCollection extends GeoJSON
 	features: GeoJSONFeature[];
 };
 
-export function calcDistance(srid: number, geom: Vector2D, x: number, y: number): number;
+export function calcDistance(srid: number, geom: geometry.Vector2D, x: number, y: number): number;
 export function getLayers(svcUrl: string, onResultFunc: Function): void;
 export function getLayerData(svcUrl: string, onResultFunc: Function, layerName: string, dataFormat: DataFormat): void;
 
@@ -90,18 +91,103 @@ export class GPSTrack
 {
 	recs: GPSRecord[];
 	constructor(recs: GPSRecord[]);
-	createLineString(): LineString;
-	getPosByTime(ts: Timestamp): Vector3;
-	getPosByTicks(ticks: number): Vector3;
+	createLineString(): geometry.LineString;
+	getPosByTime(ts: Timestamp): math.Vector3;
+	getPosByTicks(ticks: number): math.Vector3;
 };
 
 export class GeolocationFilter
 {
 	lastPos?: GeolocationPosition;
-	csys: CoordinateSystem;
+	csys: math.CoordinateSystem;
 	minSecs: number;
 	minDistMeter: number;
 
 	constructor(minSecs: number, minDistMeter: number);
 	isValid(pos: GeolocationPosition): boolean;
 };
+
+
+declare class LayerOptions
+{
+};
+
+declare class MarkerOptions
+{
+	zIndex?: number;
+}
+
+declare class GeometryOptions
+{
+	lineColor?: string;
+	lineWidth?: number;
+	fillColor?: string;
+	fillOpacity?: number;
+}
+
+export class MapControl
+{
+	constructor();
+	createLayer(layer: map.LayerInfo, options?: LayerOptions): any;
+	createMarkerLayer(name: string, options?: LayerOptions): any;
+	createGeometryLayer(name: string, options?: LayerOptions): any;
+	addLayer(layer: any);
+	uninit(): void;
+	zoomIn(): void;
+	zoomOut(): void;
+	zoomScale(scale: number): void;
+	panTo(pos: math.Coord2D): void;
+	panZoomScale(pos: math.Coord2D, scale: number): void;
+	zoomToExtent(extent: math.RectArea): void;
+	handleMouseLClick(clickFunc: (mapPos: math.Coord2D, scnPos: math.Coord2D)=>void): void;
+	handleMouseMove(moveFunc: (mapPos: math.Coord2D)=>void): void;
+	handlePosChange(posFunc: (mapPos: math.Coord2D)=>void): void;
+	map2ScnPos(mapPos: math.Coord2D): math.Coord2D;
+	scn2MapPos(scnPos: math.Coord2D): math.Coord2D;
+
+	createMarker(mapPos: math.Coord2D, imgURL: string, imgWidth: number, imgHeight: number, options?: MarkerOptions): any;
+	layerAddMarker(markerLayer: any, marker: any): void;
+	layerRemoveMarker(markerLayer: any, marker: any): void;
+	layerClearMarkers(markerLayer: any): void;
+	markerIsOver(marker: any, scnPos: math.Coord2D): boolean;
+
+	createGeometry(geom: geometry.Vector2D, options: GeometryOptions): any;
+	layerAddGeometry(geometryLayer: any, geom: any): void;
+	layerRemoveGeometry(geometryLayer: any, geom: any): void;
+	layerClearGeometries(geometryLayer: any): void;
+};
+
+declare class OWSSpatialReference
+{
+	type: string;
+	properties: string;
+}
+
+declare class OWSFeature
+{
+	type: string;
+	id: string;
+	geometry_name?: string;
+	geometry: Geometry;
+	properties: object;
+}
+
+declare class OWSFeatureCollection
+{
+	crs: OWSSpatialReference;
+	features: OWSFeature[];
+	numberReturned: number;
+	timeStamp: string;
+	totalFeatures: number | string;
+	type: string;
+}
+
+export class WMS
+{
+	url: string;
+	layer: string;
+	version: string;
+
+	constructor(url: string, layer: string, version?: string);
+	queryInfos(mapPos: math.Coord2D, bounds: math.RectArea, width: number, height: number): Promise<OWSFeatureCollection | null>;
+}

package/map.js

@@ -142,3 +142,73 @@ export class GeolocationFilter
 		return true;
 	}
 }
+
+export class MapControl
+{
+	constructor()
+	{
+	}
+}
+
+export class WMS
+{
+	constructor(url, layer, version)
+	{
+		this.url = url;
+		this.layer = layer;
+		this.version = version;
+	}
+
+	async queryInfos(mapPos, bounds, width, height)
+	{
+		if (this.version == null)
+		{
+			var resp = await fetch(this.url + "?SERVICE=WMS&REQUEST=GetCapabilities");
+			var parser = new DOMParser();
+			var contentType = resp.headers.get("Content-Type") || "text/xml";
+			var doc = parser.parseFromString(await resp.text(), contentType);
+			var node = doc.childNodes[0];
+			if (node.nodeName == "WMS_Capabilities" || node.nodeName == "WMT_MS_Capabilities")
+			{
+				var attr = node.attributes.getNamedItem("version");
+				if (attr)
+				{
+					this.version = attr.value;
+				}
+			}
+			if (this.version == null)
+			{
+				return null;
+			}
+		}
+		var x = (mapPos.x - bounds.min.x) * width / bounds.getWidth();
+		var y = (bounds.max.y - mapPos.y) * height / bounds.getHeight();
+		var url;
+	
+		if (this.version == "1.1.1")
+		{
+			url = this.url + "?service=WMS&version=1.1.1&request=GetFeatureInfo&layers="+encodeURIComponent(this.layer);
+			url = url + "&bbox="+bounds.min.y+"%2C"+bounds.min.x+"%2C"+bounds.max.y+"%2C"+bounds.max.x+"&width="+width+"&height="+height;
+			url = url + "&srs=EPSG%3A4326&styles=&format=image%2Fpng&QUERY_LAYERS="+encodeURIComponent(this.layer)+"&INFO_FORMAT=application%2Fjson&FEATURE_COUNT=5";
+			url = url + "&X="+Math.round(x)+"&Y="+Math.round(y);
+		}
+		else if (this.version == "1.3.0")
+		{
+			url = this.url + "?service=WMS&version=1.3.0&request=GetFeatureInfo&layers="+encodeURIComponent(this.layer);
+			url = url + "&bbox="+bounds.min.y+"%2C"+bounds.min.x+"%2C"+bounds.max.y+"%2C"+bounds.max.x+"&width="+width+"&height="+height;
+			url = url + "&CRS=EPSG%3A4326&styles=&format=image%2Fpng&QUERY_LAYERS="+encodeURIComponent(this.layer)+"&INFO_FORMAT=application%2Fjson&FEATURE_COUNT=5";
+			url = url + "&I="+Math.round(x)+"&J="+Math.round(y);
+		}
+		else
+		{
+			console.log("WMS: Unsupported version", this.version);
+			return null;
+		}
+		var resp = await fetch(url);
+		if (resp.ok)
+		{
+			return await resp.json();
+		}
+		return null;
+	}
+}

package/olayer2.d.ts

@@ -0,0 +1,54 @@
+import * as geometry from "./geometry";
+import * as kml from "./kml";
+import * as map from "./map";
+import * as math from "./math";
+
+export class Olayer2Map extends map.MapControl
+{
+	inited: boolean;
+	mapId: string;
+	mapProjection: OpenLayers.Projection;
+	map: OpenLayers.Map;
+	Click: OpenLayers.Control;
+	mouseCtrl: Olayer2Map.Click;
+	currMarkerPopup: any;
+	currMarkerPopupObj: any;
+	lclickFunc: (lat: number, lon: number, scnX: number, scnY: number)=>void;
+	moveFunc: (lat: number, lon: number)=>void;
+	posFunc: (lat: number, lon: number)=>void;
+
+	constructor(mapId: string);
+	createLayer(layer: map.LayerInfo, options?: LayerOptions): any;
+	createMarkerLayer(name: string, options?: LayerOptions): any;
+	createGeometryLayer(name: string, options?: LayerOptions): any;
+	addLayer(layer: any);
+	uninit(): void;
+	zoomIn(): void;
+	zoomOut(): void;
+	zoomScale(scale: number): void;
+	panTo(pos: math.Coord2D): void;
+	panZoomScale(pos: math.Coord2D, scale: number): void;
+	zoomToExtent(extent: math.RectArea): void;
+	handleMouseLClick(clickFunc: (mapPos: math.Coord2D, scnPos: math.Coord2D)=>void): void;
+	handleMouseMove(moveFunc: (mapPos: math.Coord2D)=>void): void;
+	handlePosChange(posFunc: (mapPos: math.Coord2D)=>void): void;
+	map2ScnPos(mapPos: math.Coord2D): math.Coord2D;
+	scn2MapPos(scnPos: math.Coord2D): math.Coord2D;
+
+	createMarker(mapPos: math.Coord2D, imgURL: string, imgWidth: number, imgHeight: number, options?: MarkerOptions): any;
+	layerAddMarker(markerLayer: any, marker: any): void;
+	layerRemoveMarker(markerLayer: any, marker: any): void;
+	layerClearMarkers(markerLayer: any): void;
+	markerIsOver(marker: any, scnPos: math.Coord2D): boolean;
+
+	createGeometry(geom: geometry.Vector2D, lineColor: string, fillColor: string, fillOpacity: string): any;
+	layerAddGeometry(geometryLayer: any, geom: any): void;
+	layerRemoveGeometry(geometryLayer: any, geom: any): void;
+	layerClearGeometries(goemetryLayer: any): void;
+
+	toKMLFeature(layer: any, doc?: kml.Document): kml.Feature | null;
+
+	private eventLClicked(e: any): void;
+	private eventMoved(): void;
+	private eventMouseMoved(event: any): void;
+}