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

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

@@ -0,0 +1,203 @@
+import { Rectangle } from "./rectangle";
+
+export class ShapeUtilties
+{
+
+    /**
+    * Returns an indicator of where the specified point 
+    * {@code (px,py)} lies with respect to the line segment from 
+    * {@code (x1,y1)} to {@code (x2,y2)}.
+    * The return value can be either 1, -1, or 0 and indicates
+    * in which direction the specified line must pivot around its
+    * first end point, {@code (x1,y1)}, in order to point at the
+    * specified point {@code (px,py)}.
+    * <p>A return value of 1 indicates that the line segment must
+    * turn in the direction that takes the positive X axis towards
+    * the negative Y axis.  In the default coordinate system used by
+    * Java 2D, this direction is counterclockwise.  
+    * <p>A return value of -1 indicates that the line segment must
+    * turn in the direction that takes the positive X axis towards
+    * the positive Y axis.  In the default coordinate system, this 
+    * direction is clockwise.
+    * <p>A return value of 0 indicates that the point lies
+    * exactly on the line segment.  Note that an indicator value 
+    * of 0 is rare and not useful for determining colinearity 
+    * because of floating point rounding issues. 
+    * <p>If the point is colinear with the line segment, but 
+    * not between the end points, then the value will be -1 if the point
+    * lies "beyond {@code (x1,y1)}" or 1 if the point lies 
+    * "beyond {@code (x2,y2)}".
+    *
+    * @param x1 the X coordinate of the start point of the
+    *           specified line segment
+    * @param y1 the Y coordinate of the start point of the
+    *           specified line segment
+    * @param x2 the X coordinate of the end point of the
+    *           specified line segment
+    * @param y2 the Y coordinate of the end point of the
+    *           specified line segment
+    * @param px the X coordinate of the specified point to be
+    *           compared with the specified line segment
+    * @param py the Y coordinate of the specified point to be
+    *           compared with the specified line segment
+    * @return an integer that indicates the position of the third specified
+    *			coordinates with respect to the line segment formed
+    *			by the first two specified coordinates.
+    * @since 1.2
+    */
+    public static relativeCCW = function(x1, y1,  x2, y2,  px, py)
+    {
+        x2 -= x1;
+        y2 -= y1;
+        px -= x1;
+        py -= y1;
+        var ccw = px * y2 - py * x2;
+        if (ccw === 0.0) {
+            // The point is colinear, classify based on which side of
+            // the segment the point falls on.  We can calculate a
+            // relative value using the projection of px,py onto the
+            // segment - a negative value indicates the point projects
+            // outside of the segment in the direction of the particular
+            // endpoint used as the origin for the projection.
+            ccw = px * x2 + py * y2;
+            if (ccw > 0.0) {
+                // Reverse the projection to be relative to the original x2,y2
+                // x2 and y2 are simply negated.
+                // px and py need to have (x2 - x1) or (y2 - y1) subtracted
+                //    from them (based on the original values)
+                // Since we really want to get a positive answer when the
+                //    point is "beyond (x2,y2)", then we want to calculate
+                //    the inverse anyway - thus we leave x2 & y2 negated.
+                px -= x2;
+                py -= y2;
+                ccw = px * x2 + py * y2;
+                if (ccw < 0.0) {
+                    ccw = 0.0;
+                }
+            }
+        }
+        return (ccw < 0.0) ? -1 : ((ccw > 0.0) ? 1 : 0);
+    };
+
+    public static linesIntersect = function(x1,y1,x2,y2,x3,y3,x4,y4)   
+    {
+        var rCCW1 = this.relativeCCW(x1,y1,
+                    x2,y2,
+                    x3,y3),
+
+            rCCW2 = this.relativeCCW(x1,y1,
+                    x2,y2,
+                    x4,y4),
+
+            rCCW3 = this.relativeCCW(x3,y3,
+                    x4,y4,
+                    x1,y1),
+
+            rCCW4 = this.relativeCCW(x3,y3,
+                    x4,y4,
+                    x2,y2);
+
+        return (((rCCW1 * rCCW2) <= 0) && ((rCCW3 * rCCW4) <= 0));  
+    };
+
+    /**
+    * Intersects the pair of specified source <code>Rectangle</code>
+    * objects and puts the result into the specified destination
+    * <code>Rectangle</code> object.  One of the source rectangles
+    * can also be the destination to avoid creating a third Rectangle2D
+    * object, but in this case the original points of this source
+    * rectangle will be overwritten by this method. 
+    * @param src1 the first of a pair of <code>Rectangle</code> 
+    * objects to be intersected with each other
+    * @param src2 the second of a pair of <code>Rectangle</code>
+    * objects to be intersected with each other
+    * @return the <code>Rectangle</code> that holds the
+    * results of the intersection of <code>src1</code> and
+    * <code>src2</code>
+    * @since 1.2
+    */    
+     public static intersectRects = function(src1:Rectangle,src2:Rectangle):Rectangle
+    {
+        var x1 = Math.max(src1.getX(), src2.getX()),
+        y1 = Math.max(src1.getY(), src2.getY()),
+        x2 = Math.min(src1.getX() + src1.getWidth(), src2.getX() + src2.getWidth()),
+        y2 = Math.min(src1.getY() + src1.getHeight() , src2.getY() + src2.getHeight());
+        
+        return new Rectangle(x1, y1, x2-x1, y2-y1);
+    };
+
+    /**
+    * Unions the pair of source <code>Rectangle</code> objects 
+    * and puts the result into the specified destination 
+    * <code>Rectangle</code> object.  One of the source rectangles
+    * can also be the destination to avoid creating a third Rectangle
+    * object, but in this case the original points of this source
+    * rectangle will be overwritten by this method.
+    * @param src1 the first of a pair of <code>Rectangle</code>
+    * objects to be combined with each other
+    * @param src2 the second of a pair of <code>Rectangle</code>
+    * objects to be combined with each other
+    * @return the <code>Rectangle</code> that holds the
+    * results of the union of <code>src1</code> and  
+    * <code>src2</code>
+    * @since 1.2
+    */
+    /*public static unionRects = function(src1:Rectangle,src2:Rectangle):Rectangle
+    {
+        var x1 = Math.min(src1.getX(), src2.getX()),
+            y1 = Math.min(src1.getY(), src2.getY()),
+            x2 = Math.max(src1.getX() + src1.getWidth(), src2.getX() + src2.getWidth()),
+            y2 = Math.max(src1.getY() + src1.getHeight(), src2.getY() + src2.getHeight());
+        return new Rectangle(x1, y1, x2, y2);
+    };//*/
+}
+
+/*
+if(typeof CanvasRenderingContext2D !== 'undefined' && CanvasRenderingContext2D.prototype.dashedLineTo !== 'undefined')
+{	//public function from:
+	//https://davidowens.wordpress.com/2010/09/07/html-5-canvas-dashed-lines/
+	CanvasRenderingContext2D.prototype.dashedLineTo = function (fromX, fromY, toX, toY, pattern) 
+	{
+		// Our growth rate for our line can be one of the following:
+		//   (+,+), (+,-), (-,+), (-,-)
+		// Because of this, our algorithm needs to understand if the x-coord and
+		// y-coord should be getting smaller or larger and properly cap the values
+		// based on (x,y).
+		var lt = function (a, b) { return a <= b; };
+		var gt = function (a, b) { return a >= b; };
+		var capmin = function (a, b) { return Math.min(a, b); };
+		var capmax = function (a, b) { return Math.max(a, b); };
+
+		var checkX = { thereYet: gt, cap: capmin };
+		var checkY = { thereYet: gt, cap: capmin };
+
+		if (fromY - toY > 0) {
+			checkY.thereYet = lt;
+			checkY.cap = capmax;
+		}
+		if (fromX - toX > 0) 
+		{
+			checkX.thereYet = lt;
+			checkX.cap = capmax;
+		}
+
+		this.moveTo(fromX, fromY);
+		var offsetX = fromX;
+		var offsetY = fromY;
+		var idx = 0, dash = true;
+		while (!(checkX.thereYet(offsetX, toX) && checkY.thereYet(offsetY, toY))) 
+		{
+			var ang = Math.atan2(toY - fromY, toX - fromX);
+			var len = pattern[idx];
+
+			offsetX = checkX.cap(toX, offsetX + (Math.cos(ang) * len));
+			offsetY = checkY.cap(toY, offsetY + (Math.sin(ang) * len));
+
+			if (dash) this.lineTo(offsetX, offsetY);
+			else this.moveTo(offsetX, offsetY);
+
+			idx = (idx + 1) % pattern.length;
+			dash = !dash;
+		}
+	};
+}*/

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

@@ -0,0 +1,104 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+
+import { Color } from "../../renderer/utilities/Color"
+
+/**
+ * Default Affiliation Colors for the symbols
+ *
+ */
+export class AffiliationColors {
+
+	//public static colorexists: boolean = (typeof Color === 'function');
+	/// <summary>
+	/// Friendly Unit Fill Color.
+	/// </summary>
+	public static FriendlyUnitFillColor: Color = new Color(128, 224, 255);
+	/// <summary>
+	/// Hostile Unit Fill Color.
+	/// </summary>
+	public static HostileUnitFillColor: Color = new Color(255, 128, 128);//new Color(255,130,132);//Color.RED;
+	/// <summary>
+	/// Neutral Unit Fill Color.
+	/// </summary>
+	public static NeutralUnitFillColor: Color = new Color(170, 255, 170);//new Color(144,238,144);//Color.GREEN;//new Color(0,255,0);//new Color(144,238,144);//light green//Color.GREEN;new Color(0,226,0);
+	/// <summary>
+	/// Unknown Unit Fill Color.
+	/// </summary>
+	public static UnknownUnitFillColor: Color = new Color(255, 255, 128);// new Color(255,255,128);//Color.YELLOW;
+
+	public static SuspectUnitFillColor: Color = new Color(255, 229, 153);
+
+	/// <summary>
+	/// Friendly Graphic Fill Color.
+	/// </summary>
+	public static FriendlyGraphicFillColor: Color = new Color(128, 224, 255);//Crystal Blue //Color.CYAN;
+	/// <summary>
+	/// Hostile Graphic Fill Color.
+	/// </summary>
+	public static HostileGraphicFillColor: Color = new Color(255, 128, 128);//salmon
+	/// <summary>
+	/// Neutral Graphic Fill Color.
+	/// </summary>
+	public static NeutralGraphicFillColor: Color = new Color(170, 255, 170);//Bamboo Green //new Color(144,238,144);//light green
+	/// <summary>
+	/// Unknown Graphic Fill Color.
+	/// </summary>
+	public static UnknownGraphicFillColor: Color = new Color(255, 255, 128);//light yellow  new Color(255,255,224);//light yellow
+
+	public static SuspectGraphicFillColor: Color = new Color(255, 229, 153);
+
+	/// <summary>
+	/// Friendly Unit Line Color.
+	/// </summary>
+	public static FriendlyUnitLineColor: Color = Color.BLACK;
+	/// <summary>
+	/// Hostile Unit Line Color.
+	/// </summary>
+	public static HostileUnitLineColor: Color = Color.BLACK;
+	/// <summary>
+	/// Neutral Unit Line Color.
+	/// </summary>
+	public static NeutralUnitLineColor: Color = Color.BLACK;
+	/// <summary>
+	/// Unknown Unit Line Color.
+	/// </summary>
+	public static UnknownUnitLineColor: Color = Color.BLACK;
+
+	public static SuspectUnitLineColor: Color = Color.BLACK;
+
+	/// <summary>
+	/// Friendly Graphic Line Color.
+	/// </summary>
+	public static FriendlyGraphicLineColor: Color = Color.BLACK;
+	/// <summary>
+	/// Hostile Graphic Line Color.
+	/// </summary>
+	public static HostileGraphicLineColor: Color = Color.RED;
+	/// <summary>
+	/// Neutral Graphic Line Color.
+	/// </summary>
+	public static NeutralGraphicLineColor: Color = Color.GREEN;
+	/// <summary>
+	/// Unknown Graphic Line Color.
+	/// </summary>
+	public static UnknownGraphicLineColor: Color = Color.YELLOW;
+
+	public static SuspectGraphicLineColor: Color = new Color(255, 188, 1);
+
+	public static ObstacleGreenDark: Color = new Color(0,166,81);
+	public static ObstacleGreen: Color = new Color(0,255,0);
+
+	public static WeatherRed: Color = new Color(198, 16, 33);//0xC61021;// 198,16,33
+	public static WeatherBlue: Color = new Color(0, 0, 255);//0x0000FF;// 0,0,255
+
+	public static WeatherPurpleDark: Color = new Color(128, 0, 128);//0x800080;// 128,0,128 Plum Red
+	public static WeatherPurpleLight: Color = new Color(226, 159, 255);//0xE29FFF;// 226,159,255 Light Orchid
+
+	public static WeatherBrownDark: Color = new Color(128, 98, 16);//0x806210;// 128,98,16 Safari
+	public static WeatherBrownLight: Color = new Color(210, 176, 106);//0xD2B06A;// 210,176,106 Khaki
+
+}