@sswroom/sswr 1.6.15 → 1.6.17

package/Changelog

@@ -1,3 +1,13 @@
+1.6.17
+-Fixed olayer2 types
+-Added vector2D.hasArea
+-Added Vector2D.calcHIntersacts
+-Added Vector2D.getDisplayCenter
+-Enhance math.GeoJSON.parseGeometry
+
+1.6.16
+-Fixed leaflet point icon
+
 1.6.15
 -shreadsheet Support Chart
 -Added web.getCanvasElement, web.getImgElement

package/geometry.d.ts

@@ -42,6 +42,9 @@ export abstract class Vector2D {
 	abstract calBoundaryPoint(coord: math.Coord2D): BoundaryPointResult;
 	insideOrTouch(coord: math.Coord2D): boolean;
 	getBounds(): math.RectArea;
+	abstract hasArea(): boolean;
+	abstract calcHIntersacts(y: double): number[];
+	abstract getDisplayCenter(): math.Coord2D;
 }
 
 export class Point extends Vector2D
@@ -51,6 +54,9 @@ export class Point extends Vector2D
 	calBoundaryPoint(coord: math.Coord2D): BoundaryPointResult;
 	insideOrTouch(coord: math.Coord2D): boolean;
 	getBounds(): math.RectArea;
+	hasArea(): boolean;
+	calcHIntersacts(y: double): number[];
+	getDisplayCenter(): math.Coord2D;
 }
 
 
@@ -61,6 +67,9 @@ export class LineString extends Vector2D
 	calBoundaryPoint(coord: math.Coord2D): BoundaryPointResult;
 	insideOrTouch(coord: math.Coord2D): boolean;
 	getBounds(): math.RectArea;
+	hasArea(): boolean;
+	calcHIntersacts(y: double): number[];
+	getDisplayCenter(): math.Coord2D;
 }
 
 export class LinearRing extends LineString
@@ -70,7 +79,10 @@ export class LinearRing extends LineString
 	isOpen(): boolean;
 	isClose(): boolean;
 	toPolygon(): Polygon;
+	hasArea(): boolean;
+	getDisplayCenter(): math.Coord2D;
 
+	static getHIntersactsCenter(xList: number[]): number;
 	static createFromCircle(srid: number, center: math.Coord2D, radiusX: number, radiusY: number, nPoints: number): LinearRing;
 }
 
@@ -82,6 +94,8 @@ export class MultiGeometry<VecType> extends Vector2D
 	calBoundaryPoint(coord: math.Coord2D): BoundaryPointResult;
 	insideOrTouch(coord: math.Coord2D): boolean;
 	getBounds(): math.RectArea;
+	hasArea(): boolean;
+	getDisplayCenter(): math.Coord2D;
 }
 
 export class Polygon extends MultiGeometry<LinearRing>

package/geometry.js

@@ -35,6 +35,58 @@ export class Vector2D {
 	{
 		this.srid = srid;
 	}
+
+	/**
+	 * @param {math.Coord2D} coord
+	 * @returns {{x: number;y: number;dist: number;}}
+	 */
+	calBoundaryPoint(coord)
+	{
+		throw new Error("Calling abstract function calBoundaryPoint is not allowed");
+	}
+
+	/**
+	 * @param {math.Coord2D} coord
+	 * @returns {boolean}
+	 */
+	insideOrTouch(coord)
+	{
+		throw new Error("Calling abstract function insideOrTouch is not allowed");
+	}
+
+	/**
+	 * @returns {math.RectArea}
+	 */
+	getBounds()
+	{
+		throw new Error("Calling abstract function getBounds is not allowed");
+	}
+
+	/**
+	 * @returns {boolean}
+	 */
+	hasArea()
+	{
+		throw new Error("Calling abstract function hasArea is not allowed");
+	}
+
+	/**
+	 * @param {number} y
+	 * @returns {number[]}
+	 */
+	calcHIntersacts(y)
+	{
+		throw new Error("Calling abstract function calcHIntersacts is not allowed");
+	}
+
+	/**
+	 * @returns {math.Coord2D}
+	 */
+	getDisplayCenter()
+	{
+		throw new Error("Calling abstract function getDisplayCenter is not allowed");
+	}
+
 }
 
 export class Point extends Vector2D
@@ -79,6 +131,24 @@ export class Point extends Vector2D
 	{
 		return new math.RectArea(this.coordinates[0], this.coordinates[1], this.coordinates[0], this.coordinates[1]);
 	}
+
+	hasArea()
+	{
+		return false;
+	}
+
+	/**
+	 * @param {number} y
+	 */
+	calcHIntersacts(y)
+	{
+		return [];
+	}
+
+	getDisplayCenter()
+	{
+		return new math.Coord2D(this.coordinates[0], this.coordinates[1]);
+	}
 }
 
 export class LineString extends Vector2D
@@ -274,6 +344,59 @@ export class LineString extends Vector2D
 		}
 		return bounds;
 	}
+
+	hasArea()
+	{
+		return false;
+	}
+
+	/**
+	 * @param {number} y
+	 */
+	calcHIntersacts(y)
+	{
+		if (this.coordinates.length < 2)
+			throw new Error("coordinates length < 2");
+		/** @type {number[]} */
+		let ret = [];
+		let i = 1;
+		let lastPt = this.coordinates[0];
+		let thisPt;
+		let thisX;
+		while (i < this.coordinates.length)
+		{
+			thisPt = this.coordinates[i];
+			if ((lastPt[1] >= y && thisPt[1] < y) || (thisPt[1] >= y && lastPt[1] < y))
+			{
+				thisX = lastPt[0] + (y - lastPt[1]) / (thisPt[1] - lastPt[1]) * (thisPt[0] - lastPt[0]);
+				ret.push(thisX);
+			}
+			lastPt = thisPt;
+			i++;
+		}
+		if (this.hasArea())
+		{
+			thisPt = this.coordinates[0];
+			if ((lastPt[1] >= y && thisPt[1] < y) || (thisPt[1] >= y && lastPt[1] < y))
+			{
+				thisX = lastPt[0] + (y - lastPt[1]) / (thisPt[1] - lastPt[1]) * (thisPt[0] - lastPt[0]);
+				ret.push(thisX);
+			}
+		}
+		return ret;
+	}
+
+	getDisplayCenter()
+	{
+		let bounds = this.getBounds();
+		let pt = bounds.getCenter();
+		let xList = this.calcHIntersacts(pt.y);
+		if (xList.length == 0)
+		{
+			throw new Error("No intersact point in middle y");
+		}
+		return new math.Coord2D(xList[xList.length >> 1], pt.y);
+	}
 }
 
 export class LinearRing extends LineString
@@ -366,6 +489,59 @@ export class LinearRing extends LineString
 		return new Polygon(this.srid, [this.coordinates]);
 	}
 
+	hasArea()
+	{
+		return true;
+	}
+
+	getDisplayCenter()
+	{
+		let bounds = this.getBounds();
+		let pt = bounds.getCenter();
+		let xList = this.calcHIntersacts(pt.y);
+		if (xList.length == 0)
+		{
+			throw new Error("No intersact point in middle y");
+		}
+		xList.sort();
+		let x = LinearRing.getHIntersactsCenter(xList);
+		return new math.Coord2D(xList[xList.length >> 1], pt.y);
+	}
+
+	/**
+	 * @param {number[]} xList
+	 */
+	static getHIntersactsCenter(xList)
+	{
+		if (xList.length == 0)
+		{
+			throw new Error("xList is empty");
+		}
+		if ((xList.length & 1) != 0)
+		{
+			throw new Error("xList length must be even number");
+		}
+		let totalLength = 0;
+		let leng;
+		let i = xList.length;
+		while (i > 0)
+		{
+			i -= 2;
+			totalLength += xList[i + 1] - xList[i];
+		}
+		totalLength = totalLength * 0.5;
+		i = xList.length;
+		while (i > 0)
+		{
+			i -= 2;
+			leng = xList[i + 1] - xList[i];
+			if (totalLength <= leng)
+				return xList[i + 1] - totalLength;
+			totalLength -= leng;
+		}
+		return xList[0];
+	}
+	
 	/**
 	 * @param {number} srid
 	 * @param {math.Coord2D} center
@@ -398,7 +574,8 @@ export class MultiGeometry extends Vector2D
 	constructor(srid)
 	{
 		super(srid);
-		this.geometries = new Array();
+		/** @type {Vector2D[]} */
+		this.geometries = [];
 	}
 
 	/**
@@ -417,6 +594,8 @@ export class MultiGeometry extends Vector2D
 				minObj = thisObj;
 			}
 		}
+		if (minObj == null)
+			return {x: coord.x, y: coord.y, dist:0};
 		return minObj;
 	}
 
@@ -440,23 +619,71 @@ export class MultiGeometry extends Vector2D
 	{
 		if (this.geometries.length == 0)
 		{
-			return null;
+			throw new Error("No geometries");
 		}
-		let bounds;
+		let bounds = this.geometries[0].getBounds();
 		let thisBounds;
-		let i;
-		for (i in this.geometries)
+		let i = 1;
+		while (i < this.geometries.length)
 		{
 			thisBounds = this.geometries[i].getBounds();
-			if (thisBounds)
+			if (bounds)
+				bounds.unionInPlace(thisBounds);
+			else
+				bounds = thisBounds;
+			i++;
+		}
+		return bounds;
+	}
+
+	hasArea()
+	{
+		if (this.geometries.length == 0)
+			return false;
+		return this.geometries[0].hasArea();
+	}
+
+	/**
+	 * @param {number} y
+	 */
+	calcHIntersacts(y)
+	{
+		/** @type {number[]} */
+		let xList = [];
+		let i = 0;
+		while (i < this.geometries.length)
+		{
+			xList = xList.concat(this.geometries[i].calcHIntersacts(y));
+			i++;
+		}
+		return xList;
+	}
+
+	getDisplayCenter()
+	{
+		let bounds = this.getBounds();
+		let pt = bounds.getCenter();
+		let xList = this.calcHIntersacts(pt.y);
+		if (xList.length == 0)
+		{
+			bounds = this.geometries[0].getBounds();
+			pt = bounds.getCenter();
+			xList = this.calcHIntersacts(pt.y);
+			if (xList.length == 0)
 			{
-				if (bounds)
-					bounds.unionInPlace(thisBounds);
-				else
-					bounds = thisBounds;
+				throw new Error("Error in finding display center");
 			}
 		}
-		return bounds;
+		xList.sort();
+		if (this.hasArea())
+		{
+			let x = LinearRing.getHIntersactsCenter(xList);
+			return new math.Coord2D(x, pt.y);	
+		}
+		else
+		{
+			return new math.Coord2D(xList[xList.length >> 1], pt.y);
+		}
 	}
 }
 

package/leaflet.js

@@ -179,7 +179,7 @@ export function createFromGeometry(geom, options)
 		{
 			if (options.name)
 				opt.title = options.name;
-			if (options.icon && options.icon.iconUrl)
+			if (options.icon && options.icon.options.iconUrl)
 				opt.icon = options.icon;
 		}
 		return L.marker(L.latLng(geom.coordinates[1], geom.coordinates[0]), opt);

package/math.d.ts

@@ -1,11 +1,12 @@
 import * as geometry from "./geometry";
+import * as map from "./map";
 import * as unit from "./unit";
 
 export function roundToFloat(n: number, decimalPoints: number): number;
 export function roundToStr(n: number, decimalPoints: number): string;
 export class GeoJSON
 {
-	static parseGeometry(srid: number, geom: object): geometry.Vector2D | null;
+	static parseGeometry(srid: number, geom: map.Geometry): geometry.Vector2D | null;
 }
 
 export class Coord2D

package/olayer2.d.ts

@@ -29,9 +29,9 @@ export class Olayer2Map extends map.MapControl
 	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;
+	createLayer(layer: map.LayerInfo, options?: map.LayerOptions): any;
+	createMarkerLayer(name: string, options?: map.LayerOptions): any;
+	createGeometryLayer(name: string, options?: map.LayerOptions): any;
 	addLayer(layer: any): void;
 	addKML(feature: kml.Feature | kml.KMLFile): void;
 	uninit(): void;
@@ -47,13 +47,13 @@ export class Olayer2Map extends map.MapControl
 	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;
+	createMarker(mapPos: math.Coord2D, imgURL: string, imgWidth: number, imgHeight: number, options?: map.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;
+	createGeometry(geom: geometry.Vector2D, options: map.GeometryOptions): any;
 	layerAddGeometry(geometryLayer: any, geom: any): void;
 	layerRemoveGeometry(geometryLayer: any, geom: any): void;
 	layerClearGeometries(goemetryLayer: any): void;

package/olayer2.js

@@ -333,7 +333,7 @@ export class Olayer2Map extends map.MapControl
 					new OpenLayers.LonLat(this.initX, this.initY).transform(
 						this.mapProjection,
 						this.map.getProjectionObject()
-					), this.initLev);
+					), this.initLev, false, false);
 			}
 		}
 		else if (data.isArray(layer))
@@ -507,6 +507,10 @@ export class Olayer2Map extends map.MapControl
 		return true;
 	}
 
+	/**
+	 * @param {geometry.Vector2D} geom
+	 * @param {map.GeometryOptions} options
+	 */
 	createGeometry(geom, options)
 	{
 		let opt = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sswroom/sswr",
-  "version": "1.6.15",
+  "version": "1.6.17",
   "description": "Libraries made by sswroom",
   "main": "sswr.js",
   "scripts": {