@sswroom/sswr 1.6.16 → 1.6.18

package/Changelog

@@ -1,3 +1,17 @@
+1.6.18
+-Change geometry.LinearRing.getHIntersactsCenter to getIntersactsCenter
+-web.buildTable support StaticImage item
+-Added media.genVector2DPreview
+-Added media.DrawImage
+-Added math.calcDir
+
+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
 

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 getIntersactsCenter(vals: 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.getIntersactsCenter(xList);
+		return new math.Coord2D(xList[xList.length >> 1], pt.y);
+	}
+
+	/**
+	 * @param {number[]} vals
+	 */
+	static getIntersactsCenter(vals)
+	{
+		if (vals.length == 0)
+		{
+			throw new Error("vals is empty");
+		}
+		if ((vals.length & 1) != 0)
+		{
+			throw new Error("vals length must be even number");
+		}
+		let totalLength = 0;
+		let leng;
+		let i = vals.length;
+		while (i > 0)
+		{
+			i -= 2;
+			totalLength += vals[i + 1] - vals[i];
+		}
+		totalLength = totalLength * 0.5;
+		i = vals.length;
+		while (i > 0)
+		{
+			i -= 2;
+			leng = vals[i + 1] - vals[i];
+			if (totalLength <= leng)
+				return vals[i + 1] - totalLength;
+			totalLength -= leng;
+		}
+		return vals[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.getIntersactsCenter(xList);
+			return new math.Coord2D(x, pt.y);	
+		}
+		else
+		{
+			return new math.Coord2D(xList[xList.length >> 1], pt.y);
+		}
 	}
 }
 

package/math.d.ts

@@ -1,11 +1,14 @@
 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 function calcDir(startPt: Coord2D, endPt: Coord2D, ang: unit.Angle.Unit): number;
+
 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/math.js

@@ -1,4 +1,5 @@
 import * as geometry from "./geometry.js";
+import * as map from "./map.js";
 import * as unit from "./unit.js";
 
 /**
@@ -43,23 +44,43 @@ export function roundToStr(n, decimalPoints)
 	}
 }
 
+/**
+ * @param {Coord2D} startPt
+ * @param {Coord2D} endPt
+ * @param {unit.Angle.Unit} ang
+ */
+export function calcDir(startPt, endPt, ang)
+{
+	let a = Math.atan2(endPt.x - startPt.x, endPt.y - startPt.y);
+	if (a < 0)
+	{
+		a = a + Math.PI * 2;
+	}
+	return unit.Angle.convert(unit.Angle.Unit.RADIAN, ang, a);
+}
+
 export class GeoJSON {
 	/**
 	 * @param {number} srid
-	 * @param {{ type: string; coordinates: number[][][] | number[][][][] | undefined; }} geom
+	 * @param {map.Geometry} geom
 	 */
 	static parseGeometry(srid, geom)
 	{
-		if (geom.type == "Polygon")
+		if (geom.type == map.GeometryType.Polygon)
 		{
 			// @ts-ignore
 			return new geometry.Polygon(srid, geom.coordinates);
 		}
-		else if (geom.type == "MultiPolygon")
+		else if (geom.type == map.GeometryType.MultiPolygon)
 		{
 			// @ts-ignore
 			return new geometry.MultiPolygon(srid, geom.coordinates);
 		}
+		else if (geom.type == map.GeometryType.LineString)
+		{
+			// @ts-ignore
+			return new geometry.LineString(srid, geom.coordinates);
+		}
 		else
 		{
 			console.log("GeoJSON.parseGeometry: unknown type "+geom.type);

package/media.d.ts

@@ -1,4 +1,6 @@
 import * as data from "./data";
+import * as geometry from "./geometry";
+import * as math from "./math";
 
 export enum EXIFMaker
 {
@@ -41,6 +43,22 @@ declare class GPSInfo
 }
 
 export function loadImageFromBlob(blob: Blob): Promise<HTMLImageElement>;
+export function genVector2DPreview(vec: geometry.Vector2D, width: number, height: number): DrawImage;
+
+export class DrawImage
+{
+	canvas: HTMLCanvasElement;
+	ctx: CanvasRenderingContext2D | null;
+
+	constructor(width: number, height: number);
+	drawLine(startPt: math.Coord2D, endPt: math.Coord2D, lineWidth?: number, lineStyle?: string | CanvasGradient | CanvasPattern): void;
+	drawPolyline(pts: math.Coord2D[], lineWidth?: number, lineStyle?: string | CanvasGradient | CanvasPattern): void;
+	get width(): number;
+	get height(): number;
+
+	toPNGURL(): string;
+	createStaticImage(): StaticImage;
+}
 
 export class EXIFItem
 {

package/media.js

@@ -1,4 +1,6 @@
 import * as data from "./data.js";
+import * as geometry from "./geometry.js";
+import * as math from "./math.js";
 import * as text from "./text.js";
 
 export const EXIFMaker = {
@@ -47,6 +49,167 @@ export function loadImageFromBlob(blob)
     });
 }
 
+
+/**
+ * @param {geometry.Vector2D} vec
+ * @param {number} width
+ * @param {number} height
+ */
+export function genVector2DPreview(vec, width, height)
+{
+	let img = new DrawImage(width, height);
+	let bounds = vec.getBounds();
+	drawVector2DPreview(img, vec, bounds);
+	return img;
+}
+
+/**
+ * @param {DrawImage} img
+ * @param {geometry.Vector2D} vec
+ * @param {math.RectArea} bounds
+ */
+function drawVector2DPreview(img, vec, bounds)
+{
+	let w = img.width;
+	let h = img.height;
+	let vecX = 0;
+	let vecY = 0;
+	let vecW = bounds.getWidth();
+	let vecH = bounds.getHeight();
+	if (vecW > vecH)
+	{
+		vecY = (vecW - vecH) * 0.5;
+		vecH = vecW;
+	}
+	else
+	{
+		vecX = (vecH - vecW) * 0.5;
+		vecW = vecH;
+	}
+	let pl = [];
+	let i;
+	if (vec instanceof geometry.LinearRing)
+	{
+		i = 0;
+		while (i < vec.coordinates.length)
+		{
+			pl.push(new math.Coord2D((vec.coordinates[i][0] - bounds.minX + vecX) * w / vecW, (bounds.maxY - vec.coordinates[i][1] + vecY) * h / vecH));
+			i++;
+		}
+		img.drawPolyline(pl, 1, "black");
+	}
+	else if (vec instanceof geometry.LineString)
+	{
+		i = 0;
+		while (i < vec.coordinates.length)
+		{
+			pl.push(new math.Coord2D((vec.coordinates[i][0] - bounds.minX + vecX) * w / vecW, (bounds.maxY - vec.coordinates[i][1] + vecY) * h / vecH));
+			i++;
+		}
+		img.drawPolyline(pl, 1, "black");
+	}
+}
+
+export class DrawImage
+{
+	/**
+	 * @param {number} width
+	 * @param {number} height
+	 */
+	constructor(width, height)
+	{
+		this.canvas = document.createElement("canvas");
+		this.canvas.width = width;
+		this.canvas.height = height;
+		this.ctx = this.canvas.getContext("2d");
+	}
+
+	/**
+	 * @param {math.Coord2D} startPt
+	 * @param {math.Coord2D} endPt
+	 * @param {undefined | null | number} lineWidth
+	 * @param {undefined | string | CanvasGradient | CanvasPattern} lineStyle
+	 */
+	drawLine(startPt, endPt, lineWidth, lineStyle)
+	{
+		let ctx = this.ctx;
+		if (ctx)
+		{
+			ctx.beginPath();
+			ctx.moveTo(startPt.x, startPt.y);
+			ctx.lineTo(endPt.x, endPt.y);
+			if (lineWidth)
+			{
+				ctx.lineWidth = lineWidth;
+			}
+			if (lineStyle)
+			{
+				ctx.strokeStyle = lineStyle;
+			}
+			ctx.stroke();
+		}
+	}
+
+	/**
+	 * @param {math.Coord2D[]} pts
+	 * @param {undefined | null | number} lineWidth
+	 * @param {undefined | string | CanvasGradient | CanvasPattern} lineStyle
+	 */
+	drawPolyline(pts, lineWidth, lineStyle)
+	{
+		let ctx = this.ctx;
+		if (ctx && pts.length > 0)
+		{
+			let i;
+			ctx.beginPath();
+			ctx.moveTo(pts[0].x, pts[0].y);
+			i = 1;
+			while (i < pts.length)
+			{
+				ctx.lineTo(pts[i].x, pts[i].y);
+				i++;
+			}
+			if (lineWidth)
+			{
+				ctx.lineWidth = lineWidth;
+			}
+			if (lineStyle)
+			{
+				ctx.strokeStyle = lineStyle;
+			}
+			ctx.stroke();
+		}
+		else
+		{
+			console.log("ctx not found or pts is empty")
+		}
+	}
+
+	get width()
+	{
+		return this.canvas.width;
+	}
+
+	get height()
+	{
+		return this.canvas.height;
+	}
+
+	toPNGURL()
+	{
+		return this.canvas.toDataURL("image/png");
+	}
+
+	createStaticImage()
+	{
+		let url = this.canvas.toDataURL("image/png");
+		let img = document.createElement("img");
+		img.src = url;
+		return new StaticImage(img, "DrawImage.png", "image/png");
+	}
+}
+
+
 export class EXIFItem
 {
 	constructor(id, type, data)
@@ -4039,6 +4202,11 @@ export class EXIFData
 
 export class StaticImage extends data.ParsedObject
 {
+	/**
+	 * @param {HTMLImageElement} img
+	 * @param {string} sourceName
+	 * @param {string} objType MIME
+	 */
 	constructor(img, sourceName, objType)
 	{
 		super(sourceName, objType);

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.16",
+  "version": "1.6.18",
   "description": "Libraries made by sswroom",
   "main": "sswr.js",
   "scripts": {

package/web.js

@@ -1,4 +1,5 @@
 import * as data from "./data.js";
+import * as media from "./media.js";
 import * as text from "./text.js";
 
 export const OSType = {
@@ -149,13 +150,18 @@ export function buildTable(o)
 			ret.push("<tr>");
 			for (name in o[0])
 			{
-				if (typeof obj[name] == "object")
+				let thisObj = obj[name];
+				if (thisObj instanceof media.StaticImage)
 				{
-					ret.push("<td>"+text.toHTMLText(JSON.stringify(obj[name]))+"</td>");
+					ret.push("<td><img src="+text.toAttrText(thisObj.img.src)+"/></td>");
+				}
+				else if (typeof thisObj == "object")
+				{
+					ret.push("<td>"+text.toHTMLText(JSON.stringify(thisObj))+"</td>");
 				}
 				else
 				{
-					ret.push("<td>"+text.toHTMLText(""+obj[name])+"</td>");
+					ret.push("<td>"+text.toHTMLText(""+thisObj)+"</td>");
 				}
 			}
 			ret.push("</tr>");