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

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

@@ -0,0 +1,178 @@
+import { type int, type double } from "../../graphics2d/BasicTypes";
+
+import { Point } from "../../graphics2d/Point"
+import { Point2D } from "../../graphics2d/Point2D"
+import { IPointConversion } from "../../renderer/utilities/IPointConversion"
+
+/**
+ *
+ *
+ */
+export class PointConversion implements IPointConversion {
+    protected _pixelWidth: int = 0;
+    protected _PixelHeight: int = 0;
+    protected _geoTop: double = 0;
+    protected _geoLeft: double = 0;
+    protected _geoBottom: double = 0;
+    protected _geoRight: double = 0;
+    protected _normalize: boolean = true;
+    //pixels to geo
+    //double _geoMultiplierX = 0;
+    //double _geoMultiplierY = 0;
+    //geo to pixels
+    protected _pixelMultiplierX: double = 0;
+    protected _pixelMultiplierY: double = 0;
+    public set_normalize(value: boolean): void {
+        this._normalize = value;
+    }
+
+    public constructor(pixelWidth: int, pixelHeight: int,
+        geoTop: double, geoLeft: double,
+        geoBottom: double, geoRight: double) {/*
+            _pixelWidth = pixelWidth;
+            _PixelHeight = pixelHeight;
+            _geoTop = geoTop;
+            _geoLeft = geoLeft;
+            _geoBottom = geoBottom;
+            _geoRight = geoRight;*/
+
+        this.UpdateExtents(pixelWidth, pixelHeight, geoTop, geoLeft, geoBottom, geoRight);
+    }
+
+    public UpdateExtents(pixelWidth: int, pixelHeight: int,
+        geoTop: double, geoLeft: double,
+        geoBottom: double, geoRight: double): void {
+        this._pixelWidth = pixelWidth;
+        this._PixelHeight = pixelHeight;
+        this._geoTop = geoTop;
+        this._geoLeft = geoLeft;
+        this._geoBottom = geoBottom;
+        this._geoRight = geoRight;
+
+        //_geoMultiplierX = ((double)_pixelWidth) / (_geoRight - _geoLeft) ;
+        //_geoMultiplierY = ((double)_PixelHeight) / (_geoTop - _geoBottom) ;
+
+        this._pixelMultiplierX = (this._geoRight - this._geoLeft) / (this._pixelWidth as double);
+        this._pixelMultiplierY = (this._geoTop - this._geoBottom) / (this._PixelHeight as double);
+
+        //diagnostic 12-18-12
+        if (this._geoRight - this._geoLeft < -180) {
+            this._pixelMultiplierX = (this._geoRight - this._geoLeft + 360) / (this._pixelWidth as double);
+        }
+        if (this._geoRight - this._geoLeft > 180) {
+            this._pixelMultiplierX = (360 - (this._geoRight - this._geoLeft)) / (this._pixelWidth as double);
+        }
+        //end section
+        if (this._geoTop < this._geoBottom) {
+
+            this._pixelMultiplierY = -Math.abs(this._pixelMultiplierY);
+        }
+
+        else {
+
+            this._pixelMultiplierY = Math.abs(this._pixelMultiplierY);
+        }
+
+
+        //            if(_geoRight < _geoLeft)
+        //                _pixelMultiplierX = -Math.abs(_pixelMultiplierX);
+        //            else
+        //                _pixelMultiplierX = Math.abs(_pixelMultiplierX);
+        //end section
+    }
+
+    public PixelsToGeo(pixel: Point): Point;
+
+    public PixelsToGeo(pixel: Point2D): Point2D;
+    public PixelsToGeo(...args: unknown[]): Point | Point2D {
+        const [pixel] = args as [Point | Point2D];
+
+        let coords: Point | Point2D
+        if (pixel instanceof Point)
+            coords = new Point()
+        else
+            coords = new Point2D();
+
+        coords.x = pixel.getX() * this._pixelMultiplierX + this._geoLeft; //xMultiplier;
+        coords.y = this._geoTop - (pixel.getY() * this._pixelMultiplierY);
+
+        //diagnostic 12-18-12
+        if (coords.x < -180) {
+
+            coords.x += 360;
+        }
+
+        if (coords.x > 180) {
+
+            coords.x -= 360;
+        }
+
+        //end section
+
+        return coords;
+    }
+
+
+    public GeoToPixels(coord: Point): Point;
+
+    public GeoToPixels(coord: Point2D): Point2D;
+    public GeoToPixels(...args: unknown[]): Point | Point2D {
+        const [coord] = args as [Point | Point2D];
+
+        let pixel: Point | Point2D;
+        if (coord instanceof Point)
+            pixel = new Point();
+        else
+            pixel = new Point2D();
+        //double xMultiplier = _pixelMultiplierX;//(_geoRight - _geoLeft) / ((double)_pixelWidth) ;
+        //double yMultiplier = _pixelMultiplierY;//(_geoTop - _geoBottom) / ((double)_PixelHeight) ;
+        let temp: double = 0;
+        //temp = ((coord.getX()  - _geoLeft) / _pixelMultiplierX);//xMultiplier);
+        let calcValue: double = coord.getX() - this._geoLeft;
+        if (this._normalize) {
+            if (calcValue < -180) {
+
+                calcValue += 360;
+            }
+
+            else if (calcValue > 180) {
+
+                calcValue -= 360;
+            }
+        }
+        temp = (calcValue / this._pixelMultiplierX);
+
+        pixel.x = temp;
+
+        temp = ((this._geoTop - coord.getY()) / this._pixelMultiplierY);//yMultiplier);
+        pixel.y = temp;
+
+        return pixel;
+    }
+
+
+    public getPixelWidth(): int {
+        return this._pixelWidth;
+    }
+
+    public getPixelHeight(): int {
+        return this._PixelHeight;
+    }
+
+    public getUpperLat(): double {
+        return this._geoTop;
+    }
+
+    public getLowerLat(): double {
+        return this._geoBottom;
+    }
+
+    public getLeftLon(): double {
+        return this._geoLeft;
+    }
+
+    public getRightLon(): double {
+        return this._geoRight;
+    }
+
+}

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

@@ -0,0 +1,45 @@
+import { Point } from "../../graphics2d/Point"
+import { Point2D } from "../../graphics2d/Point2D"
+import { IPointConversion } from "../../renderer/utilities/IPointConversion"
+
+/**
+ * Makes no change to the passed points.  Useful for when the points
+ * are already in pixels.
+ *
+ */
+export class PointConversionDummy implements IPointConversion {
+	public constructor() {
+	}
+
+	public PixelsToGeo(pixel: Point): Point;
+
+	public PixelsToGeo(pixel: Point2D): Point2D;
+	public PixelsToGeo(...args: unknown[]): Point | Point2D {
+		const [pixel] = args as [Point | Point2D];
+
+		let coords: Point | Point2D;
+		if (pixel instanceof Point)
+			coords = new Point()
+		else
+			coords = new Point2D();
+		coords.x = pixel.getX();
+		coords.y = pixel.getY();
+
+		return coords;
+	}
+
+
+	public GeoToPixels(coord: Point): Point;
+
+	public GeoToPixels(coord: Point2D): Point2D;
+	public GeoToPixels(...args: unknown[]): Point | Point2D {
+		const [coord] = args as [Point2D];
+		let pixel: Point | Point2D;
+		if (coord instanceof Point)
+			pixel = new Point(coord.getX(), coord.getY())
+		else
+			pixel = new Point2D(coord.getX(), coord.getY())
+
+		return pixel;
+	}
+}

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

@@ -0,0 +1,126 @@
+import { type double } from "../../graphics2d/BasicTypes";
+
+import { Point } from "../../graphics2d/Point"
+import { Point2D } from "../../graphics2d/Point2D"
+import { GeoPixelConversion3D } from "../../renderer/utilities/GeoPixelConversion3D"
+import { IPointConversion } from "../../renderer/utilities/IPointConversion"
+import { POINT2 } from "../../JavaLineArray/POINT2";
+
+
+/**
+ *
+ *
+ */
+export class PointConverter3D implements IPointConversion {
+    private _controlLat: double = 0;
+    private _controlLong: double = 0;
+    private _scale: double = 0;
+    private _metersPerPixel: double = 0;
+    public constructor(controlLong: double, controlLat: double, scale: double) {
+        try {
+            this._controlLat = controlLat;
+            this._controlLong = controlLong;
+            this._scale = scale;
+            this._metersPerPixel = GeoPixelConversion3D.metersPerPixel(scale);
+        } catch (e) {
+            if (e instanceof Error) {
+                throw e;
+            } else {
+                throw e;
+            }
+        }
+    }
+    public PixelsToGeo(pixel: Point): Point2D;
+
+    public PixelsToGeo(pixel: Point2D): Point2D;
+    public PixelsToGeo(...args: unknown[]): Point2D | Point2D {
+        if (args[0] instanceof Point) {
+            const [pixel] = args as [Point];
+
+
+            let pt2dGeo: Point2D;
+            try {
+                let y: double = GeoPixelConversion3D.y2lat(pixel.getY(), this._scale, this._controlLat, this._metersPerPixel);
+                let x: double = GeoPixelConversion3D.x2long(pixel.getX(), this._scale, this._controlLong, y, this._metersPerPixel);
+                pt2dGeo = new Point2D(x, y);
+            } catch (e) {
+                if (e instanceof Error) {
+                    throw e;
+                } else {
+                    throw e;
+                }
+            }
+            return pt2dGeo;
+
+        } else {
+            const [pixel] = args as [Point2D];
+
+
+            let pt2dGeo: Point2D;
+            try {
+                let y: double = GeoPixelConversion3D.y2lat(pixel.getY(), this._scale, this._controlLat, this._metersPerPixel);
+                let x: double = GeoPixelConversion3D.x2long(pixel.getX(), this._scale, this._controlLong, y, this._metersPerPixel);
+                pt2dGeo = new Point2D(x, y);
+            } catch (e) {
+                if (e instanceof Error) {
+                    throw e;
+                } else {
+                    throw e;
+                }
+            }
+            return pt2dGeo;
+
+        }
+    }
+
+
+
+    public GeoToPixels(coord: Point2D): Point;
+
+    public GeoToPixels(coord: Point2D): Point2D;
+    public GeoToPixels(...args: unknown[]): Point | Point2D {
+
+        if (args[0] instanceof Point2D) {
+            const [coord] = args as [Point2D];
+
+
+            let ptPixels: Point;
+            try {
+                let y: double = GeoPixelConversion3D.lat2y(coord.getY(), this._scale, this._controlLat, this._metersPerPixel);
+                let x: double = GeoPixelConversion3D.long2x(coord.getX(), this._scale, this._controlLong, coord.getY(), this._metersPerPixel);
+                ptPixels = new Point();
+                ptPixels.setLocation(x, y);
+            } catch (e) {
+                if (e instanceof Error) {
+                    throw e;
+                } else {
+                    throw e;
+                }
+            }
+            return ptPixels;
+
+        } else {
+
+            const [coord] = args as [Point2D];
+
+
+            let pt2DPixels: Point2D;
+            try {
+                let y: double = GeoPixelConversion3D.lat2y(coord.getY(), this._scale, this._controlLat, this._metersPerPixel);
+                let x: double = GeoPixelConversion3D.long2x(coord.getX(), this._scale, this._controlLong, coord.getY(), this._metersPerPixel);
+                pt2DPixels = new Point2D(x, y);
+            } catch (e) {
+                if (e instanceof Error) {
+                    throw e;
+                } else {
+                    throw e;
+                }
+            }
+            return pt2DPixels;
+
+
+
+        }
+    }
+
+}

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

@@ -0,0 +1,118 @@
+import { type int, type double } from "../../graphics2d/BasicTypes";
+
+import { Rectangle } from "../../graphics2d/Rectangle"
+import { Rectangle2D } from "../../graphics2d/Rectangle2D"
+import { Rectangle as Rect } from "../shapes/rectangle";
+
+export class RectUtilities {
+
+	public static makeRectangleFromRect(x1: int, y1: int, x2: int, y2: int): Rectangle {
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	}
+
+	public static makeRectangle2DFromRect(x1: double, y1: double, x2: double, y2: double): Rectangle2D {
+		return new Rectangle2D(x1, y1, x2 - x1, y2 - y1);
+	}
+
+
+
+	/**
+	 * Copies a Rectangle
+	 * @param rect {@link Rectangle2D}
+	 * @return {@link Rectangle2D}
+	 */
+	public static copyRect(rect: Rectangle2D): Rectangle2D {
+		return new Rectangle2D(rect.getX() as int, rect.getY() as int, (rect.getWidth() + 0.5) as int, (rect.getHeight() + 0.5) as int);
+	}
+
+	/**
+	 * copies and rounds the points.  x,y round down & width,height round up
+	 * @param rect {@link Rectangle2D}
+	 * @return {@link Rectangle2D}
+	 */
+	public static roundRect(rect: Rectangle2D): Rectangle2D {
+		let offsetX: double = rect.getX() - (rect.getX()) as int;
+		let offsetY: double = rect.getY() - (rect.getY()) as int;
+
+		return new Rectangle2D(rect.getX() as int, rect.getY() as int, (Math.round(rect.getWidth() + offsetX + 0.5)) as int, Math.round(rect.getHeight() + offsetY + 0.5) as int);
+	}
+
+	public static grow(rect: Rectangle2D, size: int): void {
+		rect.setRect(rect.getX() - size, rect.getY() - size, rect.getWidth() + (size * 2), rect.getHeight() + (size * 2));
+		//return new Rectangle2D(rect.left - size, rect.top - size, rect.right + size, rect.bottom + size);
+	}
+
+
+	public static shift(rect: Rectangle2D, x: int, y: int): void {
+		rect.setRect(rect.getX() + x, rect.getY() + y, rect.getWidth(), rect.getHeight());
+	}
+
+
+	public static shiftBR(rect: Rectangle2D, x: int, y: int): void {
+		rect.setRect(rect.getX(), rect.getY(), rect.getWidth() + x, rect.getHeight() + y);
+	}
+
+	public static toRectangle(b: Rectangle2D): Rectangle;
+
+	public static toRectangle(x: double, y: double, w: double, h: double): Rectangle;
+	public static toRectangle(...args: unknown[]): Rectangle | null {
+		switch (args.length) {
+			case 1: {
+				const [b] = args as [Rectangle2D];
+
+
+				if (b == null) {
+					return null;
+				}/*from w ww . j a  va 2s . c o  m*/
+				if (b instanceof Rectangle) {
+					return b as Rectangle;
+				} else {
+					return new Rectangle(b.getX() as int, b.getY() as int,
+						b.getWidth() as int, b.getHeight() as int);
+				}
+				
+			}
+
+			case 4: {
+				const [x, y, w, h] = args as [double, double, double, double];
+
+				return new Rectangle(x as int, y as int,w as int, h as int);
+			}
+
+			default: {
+				throw Error(`Invalid number of arguments`);
+			}
+		}
+	}
+
+	public static toRectangle2D(b: Rectangle): Rectangle2D;
+	public static toRectangle2D(x: double, y: double, w: double, h: double): Rectangle2D;
+	public static toRectangle2D(...args: unknown[]): Rectangle2D | null {
+		switch (args.length) {
+			case 1: {
+				const [b] = args as [Rectangle];
+
+
+				if (b == null) {
+					return null;
+				}/*from w ww . j a  va 2s . c o  m*/
+				else 
+				{
+					return new Rectangle2D(b.getX(), b.getY(),b.getWidth(), b.getHeight());
+				}
+				
+			}
+
+			case 4: {
+				const [x, y, w, h] = args as [double, double, double, double];
+
+				return new Rectangle2D(x as int, y as int,w as int, h as int);
+			}
+
+			default: {
+				throw Error(`Invalid number of arguments`);
+			}
+		}
+	}
+
+}

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

@@ -0,0 +1,11 @@
+/**
+ *
+ *
+ */
+export class RendererException extends Error {
+
+    public constructor(message: string, cause: Error | null) {
+        super(message);
+    }
+
+}