@armyc2.c5isr.renderer/mil-sym-ts-web 2.2.0

package/src/main/ts/armyc2/c5isr/renderer/utilities/GENCLookup.ts

@@ -0,0 +1,106 @@
+import { ErrorLogger } from './ErrorLogger';
+import { RendererUtilities } from './RendererUtilities';
+
+import json from '../../data/genc.json';
+
+/**
+ * Utility class that takes the 3 digit country code from the symbol ID and returns the 3 character string representation
+ * of that country. For example, 840 turns into "USA" for the United States.
+ */
+export class GENCLookup {
+    private static gencJSON:string = "/genc.json";
+    private static _instance: GENCLookup;
+    private static _initCalled: boolean = false;
+    private static _isReady: boolean = false;
+
+    private static _GENCLookup: Map<string, string>;
+    //private TAG: string = "GENCLookup";
+    //private _IDList: Array<string> = new Array<string>();
+    private static genc:any;
+
+
+    /*public static async loadData(location?:string)
+    {
+        let path:string = GENCLookup.gencJSON;//String(genc);
+        if(location)
+        {
+            path = location + path.substring(path.lastIndexOf('/')+1,path.length);
+        }
+        RendererUtilities.getData(path).then(result => {this.genc = result;}).catch((err) => {ErrorLogger.LogException("GENCLookup","loadData",err)});
+        //RendererUtilities.getData(String(genc)).then(result => {this.genc = result;});
+    }//*/
+
+    /**
+     * 
+     * @param url 
+     * @deprecated
+     */
+    public static async setData(url:string)
+    {
+        //RendererUtilities.getData(url).then(result => {this.genc = result;}).catch((err) => {ErrorLogger.LogException("GENCLookup","loadData",err)});
+    }
+
+    /*public static setDataObject()
+    {
+        this.genc = json;
+    }//*/
+
+    private constructor() 
+    {
+        this.init();
+    }
+
+    public static getInstance(): GENCLookup {
+        if (!GENCLookup._instance) {
+            GENCLookup._instance = new GENCLookup();
+        }
+        return GENCLookup._instance;
+    }
+
+    public isReady():boolean
+    {
+        return GENCLookup._isReady;
+    }
+
+    private init(): void {
+        
+        if(typeof json === 'object')
+        {
+            GENCLookup.genc = json;
+        }
+        
+        type gencIn = 
+        {
+            "3char": string;
+            "numeric": string;
+            "name": string;
+        }
+
+        if (GENCLookup._initCalled === false) {
+            GENCLookup._initCalled = true;
+            GENCLookup._GENCLookup = new Map();
+            try {
+                
+                let gencJSON: gencIn[] = GENCLookup.genc["genc"]["countries"]
+                for (let countryJSON of gencJSON) {
+                    GENCLookup._GENCLookup.set(countryJSON["numeric"], countryJSON["3char"]);
+                }
+                
+            } catch (e) {
+                if(console)
+                    console.log(e.message);
+                else
+                    throw e;
+            }
+        }
+        if(GENCLookup._GENCLookup &&GENCLookup._GENCLookup.size > 0)
+            GENCLookup._isReady = true;
+    }
+
+    public get3CharCode(id: number): string {
+        if (GENCLookup._GENCLookup && GENCLookup._GENCLookup.has(String(id))) {
+            return GENCLookup._GENCLookup.get(String(id));
+        }
+        return "";
+    }
+}

package/src/main/ts/armyc2/c5isr/renderer/utilities/GeoPixelConversion3D.ts

@@ -0,0 +1,84 @@
+import {type double } from "../../graphics2d/BasicTypes";
+
+import { GeoPixelConversion } from "../../web/render/GeoPixelConversion"
+
+/**
+ *
+ * 
+ */
+export class GeoPixelConversion3D {
+    public static metersPerPixel(scale: double): double {
+        return GeoPixelConversion.metersPerPixel(scale);
+    }
+
+    public static lat2y(latitude: double, scale: double, latOrigin: double, metPerPix: double): double {
+
+        let latRem: double = Math.abs(latitude - latOrigin);
+        let pixDis: double = 0;
+        if (latRem > 0) {
+            pixDis = (latRem * GeoPixelConversion.METERS_PER_DEG) / metPerPix;
+            if (latitude > latOrigin)//was < M. Deutch 6-20-11
+            {
+                pixDis = -pixDis;
+            }
+        }
+        return pixDis;
+    }
+
+    public static y2lat(yPosition: double, scale: double, latOrigin: double, metPerPix: double): double {
+
+        let latitude: double = latOrigin;
+        if (yPosition !== 0) {
+            latitude = latOrigin - ((yPosition * metPerPix) / GeoPixelConversion.METERS_PER_DEG);//was + M. Deutch 6-18-11
+        }
+        return latitude;
+    }
+
+    public static long2x(longitude: double, scale: double, longOrigin: double, latitude: double, metPerPix: double): double {
+
+        let longRem: double = Math.abs(longitude - longOrigin);
+        let metersPerDeg: double = GeoPixelConversion3D.GetMetersPerDegAtLat(latitude);
+        let pixDis: double = 0;
+        if (longRem > 0) {
+            pixDis = (longRem * metersPerDeg) / metPerPix;
+            if (longitude < longOrigin) {
+                pixDis = -pixDis;
+            }
+        }
+        return pixDis;
+    }
+
+    public static x2long(xPosition: double, scale: double, longOrigin: double, latitude: double, metPerPix: double): double {
+
+        let metersPerDeg: double = GeoPixelConversion3D.GetMetersPerDegAtLat(latitude);
+        let longitude: double = longOrigin;
+        if (xPosition !== 0) {
+            longitude = longOrigin + ((xPosition * metPerPix) / metersPerDeg);
+        }
+        return longitude;
+    }
+
+
+    public static Deg2Rad(deg: double): double {
+        let conv_factor: double = (2.0 * Math.PI) / 360.0;
+        return (deg * conv_factor);
+    }
+
+    public static GetMetersPerDegAtLat(lat: double): double {
+        // Convert latitude to radians
+        lat = GeoPixelConversion3D.Deg2Rad(lat);
+        // Set up "Constants"
+        let p1: double = 111412.84;		// longitude calculation term 1
+
+        let p2: double = -93.5;			// longitude calculation term 2
+
+        let p3: double = 0.118;			// longitude calculation term 3
+
+        // Calculate the length of a degree of longitude in meters at given latitude
+        let longlen: double = (p1 * Math.cos(lat)) + (p2 * Math.cos(3 * lat)) + (p3 * Math.cos(5 * lat));
+
+        return longlen;
+    }
+
+
+}

package/src/main/ts/armyc2/c5isr/renderer/utilities/IMultiPointRenderer.ts

@@ -0,0 +1,87 @@
+/**
+ * @deprecated
+ */
+interface IMultiPointRenderer {
+
+      /**
+       * Renders all multi-point symbols, creating KML that can be used to draw
+       * it on a Google map.  Multipoint symbols cannot be draw the same 
+       * at different scales. For instance, graphics with arrow heads will need to 
+       * redraw arrowheads when you zoom in on it.  Similarly, graphics like a 
+       * Forward Line of Troops drawn with half circles can improve performance if 
+       * clipped when the parts of the graphic that aren't on the screen.  To help 
+       * readjust graphics and increase performance, this function requires the 
+       * scale and bounding box to help calculate the new locations.
+       * @param id A unique identifier used to identify the symbol by Google map. 
+       * The id will be the folder name that contains the graphic.
+       * @param name a string used to display to the user as the name of the 
+       * graphic being created.
+       * @param description a brief description about the graphic being made and 
+       * what it represents.
+       * @param symbolCode A 15 character symbolID corresponding to one of the
+       * graphics in the MIL-STD-2525C
+       * @param controlPoints The vertices of the graphics that make up the
+       * graphic.  Passed in the format of a string, using decimal degrees 
+       * separating lat and lon by a comma, separating coordinates by a space.  
+       * The following format shall be used "x1,y1[,z1] [xn,yn[,zn]]..."
+       * @param altitudeMode Indicates whether the symbol should interpret 
+       * altitudes as above sea level or above ground level. Options are 
+       * "clampToGround", "relativeToGround" (from surface of earth), "absolute" 
+       * (sea level), "relativeToSeaFloor" (from the bottom of major bodies of 
+       * water).
+       * @param scale A number corresponding to how many meters one meter of our 
+       * map represents. A value "50000" would mean 1:50K which means for every 
+       * meter of our map it represents 50000 meters of real world distance.
+       * @param bbox The viewable area of the map.  Passed in the format of a
+       * string "lowerLeftX,lowerLeftY,upperRightX,upperRightY." Not required
+       * but can speed up rendering in some cases.
+       * example: "-50.4,23.6,-42.2,24.2"
+       * @param modifiers A JSON string representing all the possible symbol 
+       * modifiers represented in the MIL-STD-2525C.  Format of the string will be
+       * {"modifiers": {"attributeName":"value"[,"attributeNamen":"valuen"]...}}
+       * The quotes are literal in the above notation.  Example: 
+       * {"modifiers": {"quantity":"4","speed":"300","azimuth":[100,200]}}
+       * @param format An enumeration: 0 for KML, 1 for JSON.
+       * @param symStd An enumeration: 0 for 2525Bch2, 1 for 2525C.
+       * @return A JSON string representation of the graphic.
+       */
+      RenderSymbol(id: string, name: string, description: string,
+            symbolCode: string, controlPoints: string, altitudeMode: string,
+            scale: number, bbox: string, modifiers: string, format: number, symStd: number): string;
+
+
+      /**
+       * Renders all multi-point symbols, creating KML or JSON for the user to
+       * parse and render as they like.
+       * This function requires the bounding box to help calculate the new
+       * locations.
+       * @param id A unique identifier used to identify the symbol by Google map.
+       * The id will be the folder name that contains the graphic.
+       * @param name a string used to display to the user as the name of the 
+       * graphic being created.
+       * @param description a brief description about the graphic being made and 
+       * what it represents.
+       * @param symbolCode A 15 character symbolID corresponding to one of the
+       * graphics in the MIL-STD-2525C
+       * @param controlPoints The vertices of the graphics that make up the
+       * graphic.  Passed in the format of a string, using decimal degrees
+       * separating lat and lon by a comma, separating coordinates by a space.
+       * The following format shall be used "x1,y1 [xn,yn]..."
+       * @param pixelWidth pixel dimensions of the viewable map area
+       * @param pixelHeight pixel dimensions of the viewable map area
+       * @param bbox The viewable area of the map.  Passed in the format of a
+       * string "lowerLeftX,lowerLeftY,upperRightX,upperRightY."
+       * example: "-50.4,23.6,-42.2,24.2"
+       * @param modifiers A JSON string representing all the possible symbol
+       * modifiers represented in the MIL-STD-2525C.  Format of the string will be
+       * {"modifiers": {"attributeName":"value"[,"attributeNamen":"valuen"]...}}
+       * The quotes are literal in the above notation.  Example:
+       * {"modifiers": {"quantity":"4","speed":"300","azimuth":[100,200]}}
+       * @param format An enumeration: 0 for KML, 1 for JSON.
+       * @param symStd An enumeration: 0 for 2525Bch2, 1 for 2525C.
+       * @return A JSON (1) or KML (0) string representation of the graphic.
+       */
+      RenderSymbol2D(id: string, name: string, description: string, symbolCode: string, controlPoints: string,
+            pixelWidth: number, pixelHeight: number, bbox: string, modifiers: string, format: number, symStd: number): string;
+
+}

package/src/main/ts/armyc2/c5isr/renderer/utilities/IPointConversion.ts

@@ -0,0 +1,34 @@
+import { Point2D } from "../../graphics2d/Point2D";
+
+/**
+ * Interface for Point Conversion objects.  Recommend using the functions
+ * that take and return Point2D objects.
+ *
+ */
+export interface IPointConversion {
+
+      //        public void UpdateExtents(int pixelWidth, int pixelHeight,
+      //                            double geoTop, double geoLeft,
+      //                            double geoBottom, double geoRight);
+
+      //    public Point2D PixelsToGeo(Point pixel);
+
+      //    public Point GeoToPixels(Point2D coord);
+
+      PixelsToGeo(pixel: Point2D): Point2D;
+
+      GeoToPixels(coord: Point2D): Point2D;
+
+      //    public int getPixelWidth();
+      //
+      //    public int getPixelHeight();
+      //    public double getUpperLat();
+      //
+      //    public double getLowerLat();
+      //
+      //    public double getLeftLon();
+      //
+      //    public double getRightLon();
+
+
+}

package/src/main/ts/armyc2/c5isr/renderer/utilities/ImageInfo.ts

@@ -0,0 +1,324 @@
+import { type int, type double } from "../../graphics2d/BasicTypes";
+
+import { BufferedImage } from "../../graphics2d/BufferedImage"
+import { Point } from "../../graphics2d/Point"
+import { Point2D } from "../../graphics2d/Point2D"
+import { Rectangle2D } from "../../graphics2d/Rectangle2D"
+import { ErrorLogger } from "../../renderer/utilities/ErrorLogger"
+import { RectUtilities } from "../../renderer/utilities/RectUtilities"
+import { SymbolDimensionInfo } from "../../renderer/utilities/SymbolDimensionInfo"
+
+
+/**
+ * Object that holds an image of the symbol and all the information
+ * needed to place the symbol on the screen.
+ *
+ */
+export class ImageInfo implements SymbolDimensionInfo {
+
+	public static readonly FormatPNG: string = "png";
+	public static readonly FormatJPG: string = "jpg";
+
+	private _Image: ImageBitmap;
+	private _X: int = 0;
+	private _Y: int = 0;
+	private _symbolCenterX: int = 0;
+	private _symbolCenterY: int = 0;
+	protected _symbolBounds: Rectangle2D;
+
+
+	/**
+	 *
+	 */
+	public constructor();
+
+	/**
+	 * ImageInfo holds and image and holds the position at which the image
+	 * should be drawn.  Use for Multipoint and single point graphics.
+	 * @param image {@link BufferedImage}
+	 * @param x position of where the image should be drawn
+	 * @param y position of where the image should be drawn
+	 */
+	public constructor(image: ImageBitmap, x: int, y: int);
+
+	/**
+	 * Creates a new ImageInfo object
+	 * @param bi {@link BufferedImage}
+	 * @param centerPoint can also be the anchor point of the symbol if it isn't the center of the image (action point)
+	 * @param symbolBounds {@link Rectangle2D}
+	 */
+	public constructor(bi: ImageBitmap, centerPoint: Point2D, symbolBounds: Rectangle2D);
+
+	/**
+	 * ImageInfo holds and image and holds the position at which the image
+	 * should be drawn.  Use this if the image is a single point graphic.
+	 * @param image {@link BufferedImage}
+	 * @param x position of where the image should be drawn
+	 * @param y position of where the image should be drawn
+	 * @param symbolCenterX center point of image may be different from the center
+	 * point of the symbol within the image. (single point graphics)
+	 * @param symbolCenterY center point of image may be different from the center
+	 * point of the symbol within the image.  (single point graphics)
+	 * @deprecated
+	 */
+	public constructor(image: ImageBitmap, x: int, y: int, symbolCenterX: int, symbolCenterY: int);
+
+	/**
+	 *
+	 * ImageInfo holds and image and holds the position at which the image
+	 * should be drawn.  Use this if the image is a single point graphic.
+	 * @param image {@link BufferedImage}
+	 * @param x position of where the image should be drawn
+	 * @param y position of where the image should be drawn
+	 * @param symbolCenterX center point of image may be different center
+	 * point of the symbol within the image. (single point graphics)
+	 * @param symbolCenterY center point of image may be different center
+	 * point of the symbol within the image.  (single point graphics)
+	 * @param symbolBounds minimum bounding rectangle for the core symbol. Does
+	 * not include modifiers, display or otherwise.
+	 */
+	public constructor(image: ImageBitmap, x: int, y: int, symbolCenterX: int, symbolCenterY: int, symbolBounds: Rectangle2D);
+	public constructor(...args: unknown[]) {
+		switch (args.length) {
+			case 0: {
+				break;
+			}
+
+			case 3: 
+			{
+				if(typeof args[1] === 'number')
+				{
+					const [image, x, y] = args as [ImageBitmap, int, int];
+					this._Image = image;
+					this._X = x;
+					this._Y = y;
+					this._symbolCenterX = image.width / 2;
+					this._symbolCenterY = image.height / 2;
+				}
+				else if(args[1] instanceof Point2D)
+				{
+					const [bi, centerPoint, symbolBounds] = args as [ImageBitmap, Point2D, Rectangle2D];
+
+					this._Image = bi;
+					this._symbolCenterX = centerPoint.getX() as int;
+					this._symbolCenterY = centerPoint.getY() as int;
+					this._symbolBounds = symbolBounds;
+				}
+				break;
+			}
+
+			case 5: {
+				const [image, x, y, symbolCenterX, symbolCenterY] = args as [ImageBitmap, int, int, int, int];
+
+				this._Image = image;
+				this._X = x;
+				this._Y = y;
+				this._symbolCenterX = symbolCenterX;
+				this._symbolCenterY = symbolCenterY;
+
+				break;
+			}
+
+			case 6: {
+				const [image, x, y, symbolCenterX, symbolCenterY, symbolBounds] = args as [ImageBitmap, int, int, int, int, Rectangle2D];
+
+				this._Image = image;
+				this._X = x;
+				this._Y = y;
+				this._symbolCenterX = symbolCenterX;
+				this._symbolCenterY = symbolCenterY;
+				this._symbolBounds = symbolBounds;
+
+				break;
+			}
+
+			default: {
+				throw Error(`Invalid number of arguments`);
+			}
+		}
+	}
+
+
+	/**
+	 * The BufferedImage
+	 * @return the actual image
+	 */
+	public getImage(): ImageBitmap {
+		return this._Image;
+	}
+
+	/**
+	 * X position of where the image should be drawn
+	 * @return {@link Integer}
+	 */
+	public getX(): int {
+		return this._X;
+	}
+
+
+	/**
+	 * Y position of where the image should be drawn
+	 * @return {@link Integer}
+	 */
+	public getY(): int {
+		return this._Y;
+	}
+
+	/**
+	 * position of where the image should be drawn
+	 * @return {@link Point}
+	 */
+	public getPoint(): Point {
+		return new Point(this._X, this._Y);
+	}
+
+	/**
+	 * The x value the image should be centered on or the "anchor point".
+	 * @return {@link Integer}
+	 */
+	public getSymbolCenterX(): int {
+		return this._symbolCenterX;
+	}
+
+	/**
+	 * The y value the image should be centered on or the "anchor point".
+	 * @return {@link Integer}
+	 */
+	public getSymbolCenterY(): int {
+		return this._symbolCenterY;
+	}
+
+	/**
+	 * The point the image should be centered on or the "anchor point".
+	 * @return {@link Point}
+	 */
+	public getSymbolCenterPoint(): Point2D {
+		return new Point2D(this._symbolCenterX, this._symbolCenterY);
+	}
+
+	/**
+	 * minimum bounding rectangle for the core symbol. Does
+	 * not include modifiers, display or otherwise.
+	 * @return {@link Rectangle2D}
+	 */
+	public getSymbolBounds(): Rectangle2D {
+		return this._symbolBounds;
+	}
+
+	/**
+	 * Dimension of the entire image.
+	 * @return {@link Rectangle2D}
+	 */
+
+	public getImageBounds(): Rectangle2D {
+		return new Rectangle2D(0, 0, this._Image.width, this._Image.height);
+	}
+
+	/**
+	 * Takes an image and a center point and generates a new, bigger image
+	 * that has the symbol centered in it
+	 * @param image {@link BufferedImage}
+	 * @param point {@link Point2D}
+	 * @return {@link BufferedImage}
+	 */
+	public static CenterImageOnPoint(image: ImageBitmap, point: Point2D): ImageBitmap {
+		let bi:ImageBitmap;
+		let osc: OffscreenCanvas | any;
+		let x: int = 0;
+		let y: int = 0;
+		let height: int = 0;
+		let width: int = 0;
+		height = image.height;
+		width = image.width;
+
+		try {
+			if (point.getY() > height - point.getY()) {
+				height = (point.getY() * 2.0) as int;
+				y = 0;
+			}
+			else {
+				height = ((height - point.getY()) * 2) as int;
+				y = ((height / 2) - point.getY()) as int;
+			}
+
+			if (point.getX() > width - point.getX()) {
+				width = (point.getX() * 2.0) as int;
+				x = 0;
+			}
+			else {
+				width = ((width - point.getX()) * 2) as int;
+				x = ((width / 2) - point.getX()) as int;
+			}
+
+
+			osc = new OffscreenCanvas(width, height);
+			let ctx:OffscreenCanvasRenderingContext2D = osc.getContext("2d");
+			ctx.drawImage(image,x,y);
+			bi = osc.transferToImageBitmap();
+		} catch (exc) {
+			if (exc instanceof Error) {
+				ErrorLogger.LogException("ImageInfo", "CenterImageOnPoint", exc);
+			} else {
+				throw exc;
+			}
+		}
+		return bi;
+	}
+
+
+	/**
+	 * Adds padding as needed to make the image a nice square.
+	 * @return {@link ImageInfo}
+	 */
+	public getSquareImageInfo(): ImageInfo {
+		let ii: ImageInfo;
+		let iwidth: int = 0;
+		let iheight: int = 0;
+		let x: int = 0;
+		let y: int = 0;
+		let width: int = this._Image.width;
+		let height: int = this._Image.height;
+
+		if (width > height) {
+			iwidth = width;
+			iheight = width;
+			x = 0;
+			y = (iheight - height) / 2;
+		}
+		else {
+			if (width < height) {
+				iwidth = height;
+				iheight = height;
+				x = (iwidth - width) / 2;
+				y = 0;
+			}
+			else {
+				iwidth = width;
+				iheight = height;
+				x = 0;
+				y = 0;
+			}
+		}
+
+
+		//Draw glyphs to bitmap
+		let bmp: OffscreenCanvas = new OffscreenCanvas(iwidth, iheight);
+
+		let g2d: OffscreenCanvasRenderingContext2D = bmp.getContext("2d");
+
+		g2d.drawImage(this._Image, x, y);
+
+
+		//create new ImageInfo
+		let center: Point2D = new Point2D(this._symbolCenterX, this._symbolCenterY);
+		center.setLocation(this._symbolCenterX + x, this._symbolCenterY + y);
+		let symbolBounds: Rectangle2D = RectUtilities.copyRect(this._symbolBounds);
+		RectUtilities.shift(this._symbolBounds, x, y);
+
+		ii = new ImageInfo(bmp.transferToImageBitmap(), center, symbolBounds);
+
+
+		return ii;
+	}
+
+}