@sswroom/sswr 1.6.17 → 1.6.18

package/Changelog

@@ -1,3 +1,10 @@
+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

package/geometry.d.ts

@@ -82,7 +82,7 @@ export class LinearRing extends LineString
 	hasArea(): boolean;
 	getDisplayCenter(): math.Coord2D;
 
-	static getHIntersactsCenter(xList: number[]): number;
+	static getIntersactsCenter(vals: number[]): number;
 	static createFromCircle(srid: number, center: math.Coord2D, radiusX: number, radiusY: number, nPoints: number): LinearRing;
 }
 

package/geometry.js

@@ -504,42 +504,42 @@ export class LinearRing extends LineString
 			throw new Error("No intersact point in middle y");
 		}
 		xList.sort();
-		let x = LinearRing.getHIntersactsCenter(xList);
+		let x = LinearRing.getIntersactsCenter(xList);
 		return new math.Coord2D(xList[xList.length >> 1], pt.y);
 	}
 
 	/**
-	 * @param {number[]} xList
+	 * @param {number[]} vals
 	 */
-	static getHIntersactsCenter(xList)
+	static getIntersactsCenter(vals)
 	{
-		if (xList.length == 0)
+		if (vals.length == 0)
 		{
-			throw new Error("xList is empty");
+			throw new Error("vals is empty");
 		}
-		if ((xList.length & 1) != 0)
+		if ((vals.length & 1) != 0)
 		{
-			throw new Error("xList length must be even number");
+			throw new Error("vals length must be even number");
 		}
 		let totalLength = 0;
 		let leng;
-		let i = xList.length;
+		let i = vals.length;
 		while (i > 0)
 		{
 			i -= 2;
-			totalLength += xList[i + 1] - xList[i];
+			totalLength += vals[i + 1] - vals[i];
 		}
 		totalLength = totalLength * 0.5;
-		i = xList.length;
+		i = vals.length;
 		while (i > 0)
 		{
 			i -= 2;
-			leng = xList[i + 1] - xList[i];
+			leng = vals[i + 1] - vals[i];
 			if (totalLength <= leng)
-				return xList[i + 1] - totalLength;
+				return vals[i + 1] - totalLength;
 			totalLength -= leng;
 		}
-		return xList[0];
+		return vals[0];
 	}
 	
 	/**
@@ -677,7 +677,7 @@ export class MultiGeometry extends Vector2D
 		xList.sort();
 		if (this.hasArea())
 		{
-			let x = LinearRing.getHIntersactsCenter(xList);
+			let x = LinearRing.getIntersactsCenter(xList);
 			return new math.Coord2D(x, pt.y);	
 		}
 		else

package/math.d.ts

@@ -4,6 +4,8 @@ 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: map.Geometry): geometry.Vector2D | null;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sswroom/sswr",
-  "version": "1.6.17",
+  "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>");