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

package/src/main/ts/armyc2/c5isr/RenderMultipoints/clsUtility.ts

@@ -0,0 +1,1089 @@
+import { Area } from "../graphics2d/Area"
+import { BasicStroke } from "../graphics2d/BasicStroke"
+import { Point } from "../graphics2d/Point"
+import { Point2D } from "../graphics2d/Point2D"
+import { Rectangle } from "../graphics2d/Rectangle"
+import { Rectangle2D } from "../graphics2d/Rectangle2D"
+import { TexturePaint } from "../graphics2d/TexturePaint"
+import { lineutility } from "../JavaLineArray/lineutility"
+import { POINT2 } from "../JavaLineArray/POINT2"
+import { Shape2 } from "../JavaLineArray/Shape2"
+import { TacticalLines } from "../JavaLineArray/TacticalLines"
+import { TGLight } from "../JavaTacticalRenderer/TGLight"
+import { PatternFillRenderer } from "../renderer/PatternFillRenderer"
+import { Color } from "../renderer/utilities/Color"
+import { ErrorLogger } from "../renderer/utilities/ErrorLogger"
+import { IPointConversion } from "../renderer/utilities/IPointConversion"
+import { RendererException } from "../renderer/utilities/RendererException"
+import { ShapeInfo } from "../renderer/utilities/ShapeInfo"
+import { clsUtility as clsUtilityJTR } from "../JavaTacticalRenderer/clsUtility";
+
+import { type int, type double } from "../../c5isr/graphics2d/BasicTypes";
+
+/**
+ * Server general utility class
+ *
+ */
+export class clsUtility {
+    private static readonly _className: string = "clsUtility";
+    public static readonly Hatch_ForwardDiagonal: int = 2;
+    public static readonly Hatch_BackwardDiagonal: int = 3;
+    public static readonly Hatch_Vertical: int = 4;
+    public static readonly Hatch_Horizontal: int = 5;
+    public static readonly Hatch_Cross: int = 8;
+
+    /**
+     * Adds hatch fill to shapes via PatternFillRendererD.MakeHatchPatternFill() or buildHatchFill()
+     * @param tg
+     * @param shapes
+     */
+    static addHatchFills(tg: TGLight, shapes: Array<ShapeInfo>): void {
+        try {
+            if (shapes == null || shapes.length === 0) {
+
+                return;
+            }
+
+
+            let lineType: int = tg.get_LineType();
+            let hatchStyle: int = tg.get_FillStyle();
+            let j: int = 0;
+            let hatch2: int = 0;
+            let shape2: Shape2;
+            let index: int = 0;
+            let hatchLineThickness: double = 1.5 + ((tg.get_LineThickness() / 2) - 1.5) * tg.get_patternScale();
+            let hatchColor: Color = tg.get_LineColor();
+            let hatchSpacing: int = Math.trunc(hatchLineThickness * 10);
+
+            //            if(armyc2.c5isr.JavaTacticalRenderer.clsUtility.isClosedPolygon(lineType)==false)
+            //                if(armyc2.c5isr.JavaTacticalRenderer.clsUtility.IsChange1Area(lineType, null)==false)
+            //                    return;
+            if (clsUtilityJTR.isClosedPolygon(lineType) === false) {
+                if (clsUtilityJTR.IsChange1Area(lineType) === false) {
+                    switch(lineType)
+                    {
+                        case TacticalLines.BBS_AREA:
+                        case TacticalLines.BBS_LINE:
+                        case TacticalLines.BBS_RECTANGLE:
+                            break;
+                        default:
+                            return;
+                    }
+                }
+            }
+
+            switch (lineType) {
+                case TacticalLines.NFA:
+                case TacticalLines.NFA_CIRCULAR:
+                case TacticalLines.NFA_RECTANGULAR:
+                case TacticalLines.LAA: {
+                    hatchStyle = clsUtility.Hatch_BackwardDiagonal;
+                    break;
+                }
+
+                case TacticalLines.BIO:
+                case TacticalLines.NUC:
+                case TacticalLines.CHEM:
+                case TacticalLines.RAD: {
+                    hatchStyle = clsUtility.Hatch_BackwardDiagonal;
+                    hatchColor = Color.yellow;
+                    hatchLineThickness = 3 + (tg.get_LineThickness() - 3) * tg.get_patternScale();
+                    break;
+                }
+
+                case TacticalLines.WFZ: {
+                    hatchStyle = clsUtility.Hatch_BackwardDiagonal;
+                    if (tg.get_LineColor() === Color.BLACK) {
+
+                        hatchColor = Color.GRAY;
+                    }
+
+                    hatchSpacing = Math.trunc(hatchSpacing / 2);
+                    break;
+                }
+
+                case TacticalLines.OBSAREA: {
+                    //CPOF client required adding a simple shape for
+                    //setting texturepaint which WebRenderer does not use
+                    for (j = 0; j < shapes.length; j++) {
+                        let shape: ShapeInfo = shapes[j];
+                        let color: Color = shape.getLineColor();
+                        if (color == null) {
+
+                            continue;
+                        }
+
+                        //if(shape.getLineColor().getRGB()==0)
+                        if (shape.getLineColor().toRGB() === 0) {
+
+                            shapes.splice(j, 1);
+                        }
+
+                    }
+                    hatchStyle = clsUtility.Hatch_BackwardDiagonal;
+                    hatchSpacing = Math.trunc(hatchSpacing * 1.25);
+                    break;
+                }
+
+                default: {
+                    if (hatchStyle <= 0) {
+
+                        return;
+                    }
+
+                    break;
+                }
+
+            }
+            //get the index of the shape with the same fillstyle
+            let n: int = shapes.length;
+            //for(j=0;j<shapes.length;j++)
+            for (j = 0; j < n; j++) {
+                shape2 = shapes[j] as Shape2;
+                hatch2 = shape2.getFillStyle();
+                if (hatch2 === hatchStyle) {
+                    index = j;
+                    break;
+                }
+            }
+            n = shapes.length;
+            //for(int k=0;k<shapes.length;k++)
+            for (let k: int = 0; k < n; k++) {
+                //the outline should always be the 0th shape for areas
+                let shape: ShapeInfo;
+                if (lineType === TacticalLines.RANGE_FAN || lineType === TacticalLines.RANGE_FAN_SECTOR || lineType === TacticalLines.RADAR_SEARCH) {
+                    shape = shapes[k];
+                    shape2 = shapes[k] as Shape2;
+                    hatchStyle = shape2.getFillStyle();
+                }
+                else {
+
+                    shape = shapes[index];
+                }
+
+
+                if (hatchStyle < clsUtility.Hatch_ForwardDiagonal) {
+                    //Hatch_ForwardDiagonal is the 0th hatch element
+                    continue;
+                }
+
+
+                if (tg.get_UseHatchFill()) {
+                    let hatchImg = PatternFillRenderer.MakeHatchPatternFill(hatchStyle, hatchSpacing, hatchLineThickness as int, hatchColor);
+                    shape.setPatternFillImage(hatchImg);
+                }
+                else {
+                    if (hatchStyle !== clsUtility.Hatch_Cross) {
+                        let shape3: Shape2 = clsUtility.buildHatchArea(tg, shape, hatchStyle, hatchSpacing);
+                        //shape.setStroke(new BasicStroke(1));
+                        shape3.setStroke(new BasicStroke(hatchLineThickness));
+                        shape3.setLineColor(hatchColor);
+                        shapes.push(shape3);
+                    }
+                    else    //cross hatch
+                    {
+                        let shapeBk: Shape2 = clsUtility.buildHatchArea(tg, shape, clsUtility.Hatch_BackwardDiagonal, hatchSpacing);
+                        let shapeFwd: Shape2 = clsUtility.buildHatchArea(tg, shape, clsUtility.Hatch_ForwardDiagonal, hatchSpacing);
+                        //shapeBk.setStroke(new BasicStroke(1));
+                        shapeBk.setStroke(new BasicStroke(hatchLineThickness));
+                        shapeBk.setLineColor(hatchColor);
+                        shapes.push(shapeBk);
+                        //shapeFwd.setStroke(new BasicStroke(1));
+                        shapeFwd.setStroke(new BasicStroke(hatchLineThickness));
+                        shapeFwd.setLineColor(hatchColor);
+                        shapes.push(shapeFwd);
+                    }
+                }
+
+                if (lineType !== TacticalLines.RANGE_FAN && lineType !== TacticalLines.RANGE_FAN_SECTOR && lineType !== TacticalLines.RADAR_SEARCH) {
+
+                    break;
+                }
+
+            }
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(clsUtility._className, "addHatchFills",
+                    new RendererException("Failed inside addHatchFills", exc));
+            } else {
+                throw exc;
+            }
+        }
+    }
+
+    /**
+     * Build Hatch fill. Does not use texture paint or shader.
+     * @param tg
+     * @param shape
+     * @param hatchStyle
+     * @return
+     */
+    static buildHatchArea(tg: TGLight, shape: ShapeInfo, hatchStyle: int, spacing: double): Shape2 {
+        let hatchLineShape: Shape2;
+        try {
+            hatchLineShape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE);
+            let hatchLineArea: Area;
+            let rect: Rectangle = shape.getBounds();
+            let x0: double = rect.getX();
+            let y0: double = rect.getY();
+            let width: double = rect.getWidth();
+            let height: double = rect.getHeight();
+            //we need a square
+            if (width > height) {
+
+                height = width;
+            }
+
+            else {
+
+                width = height;
+            }
+
+
+            //diagnostic
+            if (tg.get_UseHatchFill()) {
+                //                hatchLineShape.moveTo(new POINT2(x0,y0));
+                //                hatchLineShape.lineTo(new POINT2(x0+width,y0));
+                //                hatchLineShape.lineTo(new POINT2(x0+width,y0+width));
+                //                hatchLineShape.lineTo(new POINT2(x0,y0+width));
+                hatchLineShape.setFillStyle(hatchStyle);
+                //                hatchLineShape.lineTo(new POINT2(x0,y0));
+                //                Area shapeArea=new Area(shape.getShape());
+                //                hatchLineArea=new Area(hatchLineShape.getShape());
+                //                //intersect the hatch lines with the original shape area to get the fill
+                //                hatchLineArea.intersect(shapeArea);
+                //                hatchLineShape.setShape(hatchLineArea);
+                hatchLineShape.setShape(lineutility.createStrokedShape(shape.getShape()));
+                return hatchLineShape;
+            }
+            //end section
+
+            width *= 2;
+            height *= 2;
+            //the next two values should be equal
+            let horizLimit: int = 0;
+            let vertLimit: int = 0;
+            let j: int = 0;
+            let vertPts: Array<POINT2> = new Array();
+            let horizPts: Array<POINT2> = new Array();
+            let vertPt: POINT2;
+            let horizPt: POINT2;
+            if (hatchStyle === clsUtility.Hatch_BackwardDiagonal) {
+                horizLimit = Math.trunc(width / spacing);
+                vertLimit = Math.trunc(height / spacing);
+                for (j = 0; j < vertLimit; j++) {
+                    vertPt = new POINT2(x0, y0 + spacing * j);
+                    vertPts.push(vertPt);
+                }
+                for (j = 0; j < horizLimit; j++) {
+                    horizPt = new POINT2(x0 + spacing * j, y0);
+                    horizPts.push(horizPt);
+                }
+
+                hatchLineShape.moveTo(new POINT2(x0 - spacing / 2, y0 - spacing / 2));
+                hatchLineShape.lineTo(new POINT2(x0, y0));
+                for (j = 0; j < vertLimit; j++) {
+                    if (j % 2 === 0) {
+                        hatchLineShape.lineTo(vertPts[j]);
+                        hatchLineShape.lineTo(horizPts[j]);
+                    }
+                    else {
+                        hatchLineShape.lineTo(horizPts[j]);
+                        hatchLineShape.lineTo(vertPts[j]);
+                    }
+                }
+                //go outside the bottom right corner to complete a valid area
+                hatchLineShape.lineTo(new POINT2(x0 + width + spacing / 2, y0 + height + spacing / 2));
+                hatchLineShape.lineTo(new POINT2(x0 + width + spacing, y0 + height + spacing / 2));
+                hatchLineShape.lineTo(new POINT2(x0 + width + spacing, y0 - spacing / 2));
+                hatchLineShape.lineTo(new POINT2(x0 - spacing / 2, y0 - spacing / 2));
+            }
+            if (hatchStyle === clsUtility.Hatch_ForwardDiagonal) {
+                horizLimit = Math.trunc(width / spacing);
+                vertLimit = Math.trunc(height / spacing);
+                width /= 2;
+                for (j = 0; j < vertLimit; j++) {
+                    vertPt = new POINT2(x0 + width, y0 + spacing * j);
+                    vertPts.push(vertPt);
+                }
+                for (j = 0; j < horizLimit; j++) {
+                    horizPt = new POINT2(x0 + width - spacing * j, y0);
+                    horizPts.push(horizPt);
+                }
+
+                hatchLineShape.moveTo(new POINT2(x0 + width + spacing / 2, y0 - spacing / 2));
+                hatchLineShape.lineTo(new POINT2(x0, y0));
+                for (j = 0; j < vertLimit; j++) {
+                    if (j % 2 === 0) {
+                        hatchLineShape.lineTo(vertPts[j]);
+                        hatchLineShape.lineTo(horizPts[j]);
+                    }
+                    else {
+                        hatchLineShape.lineTo(horizPts[j]);
+                        hatchLineShape.lineTo(vertPts[j]);
+                    }
+                }
+                //go outside the bottom left corner to complete a valid area
+                hatchLineShape.lineTo(new POINT2(x0 - spacing / 2, y0 + height + spacing / 2));
+                hatchLineShape.lineTo(new POINT2(x0 - spacing, y0 + height + spacing / 2));
+                hatchLineShape.lineTo(new POINT2(x0 - spacing, y0 - spacing / 2));
+                hatchLineShape.lineTo(new POINT2(x0 + width + spacing / 2, y0 - spacing / 2));
+            }
+            if (hatchStyle === clsUtility.Hatch_Vertical) {
+                horizLimit = Math.trunc(width / (spacing / 2));
+                vertLimit = Math.trunc(height / (spacing / 2));
+                for (j = 0; j < horizLimit; j++) {
+                    if (j % 2 === 0) {
+                        vertPt = new POINT2(x0 + spacing / 2 * j, y0);
+                        vertPts.push(vertPt);
+                        vertPt = new POINT2(x0 + spacing / 2 * j, y0 + height);
+                        vertPts.push(vertPt);
+                    }
+                    else {
+                        vertPt = new POINT2(x0 + spacing / 2 * j, y0 + height);
+                        vertPts.push(vertPt);
+                        vertPt = new POINT2(x0 + spacing / 2 * j, y0);
+                        vertPts.push(vertPt);
+                    }
+                }
+                hatchLineShape.moveTo(new POINT2(x0 - spacing / 2, y0 - spacing / 2));
+                hatchLineShape.lineTo(new POINT2(x0, y0));
+                for (j = 0; j < vertLimit - 1; j++) {
+                    hatchLineShape.lineTo(vertPts[j]);
+                }
+                //go outside the bottom right corner to complete a valid area
+                hatchLineShape.lineTo(new POINT2(x0 + width + spacing / 2, y0 + height + spacing / 2));
+                hatchLineShape.lineTo(new POINT2(x0 + width + spacing, y0 + height + spacing / 2));
+                hatchLineShape.lineTo(new POINT2(x0 + width + spacing, y0 - spacing / 2));
+                hatchLineShape.lineTo(new POINT2(x0 - spacing / 2, y0 - spacing / 2));
+            }
+            if (hatchStyle === clsUtility.Hatch_Horizontal) {
+                horizLimit = Math.trunc(width / (spacing / 2));
+                vertLimit = Math.trunc(height / (spacing / 2));
+                for (j = 0; j < vertLimit; j++) {
+                    if (j % 2 === 0) {
+                        horizPt = new POINT2(x0, y0 + spacing / 2 * j);
+                        horizPts.push(horizPt);
+                        horizPt = new POINT2(x0 + width, y0 + spacing / 2 * j);
+                        horizPts.push(horizPt);
+                    }
+                    else {
+                        horizPt = new POINT2(x0 + width, y0 + spacing / 2 * j);
+                        horizPts.push(horizPt);
+                        horizPt = new POINT2(x0, y0 + spacing / 2 * j);
+                        horizPts.push(horizPt);
+                    }
+                }
+                hatchLineShape.moveTo(new POINT2(x0 - spacing / 2, y0 - spacing / 2));
+                hatchLineShape.lineTo(new POINT2(x0, y0));
+                for (j = 0; j < vertLimit - 1; j++) {
+                    hatchLineShape.lineTo(horizPts[j]);
+                }
+                //go outside the bottom left corner to complete a valid area
+                hatchLineShape.lineTo(new POINT2(x0 - spacing / 2, y0 + height + spacing / 2));
+                hatchLineShape.lineTo(new POINT2(x0 - spacing, y0 + height + spacing / 2));
+                hatchLineShape.lineTo(new POINT2(x0 - spacing, y0 - spacing / 2));
+                hatchLineShape.lineTo(new POINT2(x0 + width + spacing / 2, y0 - spacing / 2));
+            }
+
+            let shapeArea: Area = new Area(shape.getShape());
+            hatchLineArea = new Area(hatchLineShape.getShape());
+            //intersect the hatch lines with the original shape area to get the fill
+            hatchLineArea.intersect(shapeArea);
+            hatchLineShape.setShape(hatchLineArea);
+            //return null;
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(clsUtility._className, "buildHatchArea",
+                    new RendererException("Failed inside buildHatchArea", exc));
+            } else {
+                throw exc;
+            }
+        }
+        return hatchLineShape;
+    }
+
+    protected static POINT2ToPoint(pt2: POINT2): Point {
+        let pt: Point = new Point();
+        pt.x = pt2.x as int;
+        pt.y = pt2.y as int;
+        return pt;
+    }
+    protected static PointToPOINT2(pt: Point): POINT2 {
+        let pt2: POINT2 = new POINT2(pt.x, pt.y);
+        return pt2;
+    }
+    protected static POINT2ToPoint2D(pt2: POINT2): Point2D {
+        let pt2d: Point2D = new Point2D(pt2.x, pt2.y);
+        return pt2d;
+    }
+    static Points2DToPOINT2(pts2d: Array<Point2D>): Array<POINT2> {
+        let pts: Array<POINT2> = new Array();
+        let pt: POINT2;
+        let n: int = pts2d.length;
+        //for(int j=0;j<pts2d.length;j++)        
+        for (let j: int = 0; j < n; j++) {
+            pt = new POINT2(pts2d[j].getX(), pts2d[j].getY());
+            pts.push(pt);
+        }
+        return pts;
+    }
+    static Point2DToPOINT2(pt2d: Point2D): POINT2 {
+        let pt2: POINT2 = new POINT2(pt2d.getX(), pt2d.getY());
+        return pt2;
+    }
+    /**
+     * @deprecated   
+     * @param tg
+     * @return 
+     */
+    protected static addModifiersBeforeClipping(tg: TGLight): boolean {
+        let result: boolean = false;
+        let linetype: int = tg.get_LineType();
+        switch (linetype) {
+            case TacticalLines.TORPEDO:
+            case TacticalLines.OPTICAL:
+            case TacticalLines.ELECTRO:
+            case TacticalLines.BEARING_EW:
+            case TacticalLines.ACOUSTIC:
+            case TacticalLines.ACOUSTIC_AMB:
+            case TacticalLines.BEARING:
+            case TacticalLines.BEARING_J:
+            case TacticalLines.BEARING_RDF:
+            case TacticalLines.MSR:
+            case TacticalLines.MSR_ONEWAY:
+            case TacticalLines.MSR_TWOWAY:
+            case TacticalLines.MSR_ALT:
+            case TacticalLines.ASR:
+            case TacticalLines.ASR_ONEWAY:
+            case TacticalLines.ASR_TWOWAY:
+            case TacticalLines.ASR_ALT:
+            case TacticalLines.ROUTE:
+            case TacticalLines.ROUTE_ONEWAY:
+            case TacticalLines.ROUTE_ALT:
+            case TacticalLines.HCONVOY:
+            case TacticalLines.CONVOY:
+            case TacticalLines.MFP:
+            case TacticalLines.RFL:
+            case TacticalLines.NFL:
+            case TacticalLines.CFL:
+            case TacticalLines.TRIP:
+            case TacticalLines.FSCL:
+            case TacticalLines.BCL_REVD:
+            case TacticalLines.BCL:
+            case TacticalLines.ICL:
+            case TacticalLines.IFF_OFF:
+            case TacticalLines.IFF_ON:
+            case TacticalLines.GENERIC_LINE:
+            case TacticalLines.FPF:
+            case TacticalLines.LINTGT:
+            case TacticalLines.LINTGTS:
+            case TacticalLines.MSDZ:
+            case TacticalLines.GAP:
+            case TacticalLines.IL:
+            case TacticalLines.DIRATKAIR:
+            case TacticalLines.PDF:
+            case TacticalLines.AC:
+            case TacticalLines.SAAFR:
+            case TacticalLines.LLTR:
+            case TacticalLines.SC:
+            case TacticalLines.MRR:
+            case TacticalLines.SL:
+            case TacticalLines.TC:
+            case TacticalLines.BOUNDARY:
+            case TacticalLines.WDRAWUP:
+            case TacticalLines.WITHDRAW:
+            case TacticalLines.RETIRE:
+            case TacticalLines.FPOL:
+            case TacticalLines.RPOL:
+            case TacticalLines.RIP:
+            case TacticalLines.DELAY:
+            case TacticalLines.CATK:
+            case TacticalLines.CATKBYFIRE:
+            case TacticalLines.SCREEN:
+            case TacticalLines.COVER:
+            case TacticalLines.GUARD:
+            case TacticalLines.FLOT:
+            case TacticalLines.LC:
+            case TacticalLines.PL:
+            case TacticalLines.FEBA:
+            case TacticalLines.LL:
+            case TacticalLines.EWL:
+            case TacticalLines.FCL:
+            case TacticalLines.HOLD:
+            case TacticalLines.BRDGHD:
+            case TacticalLines.HOLD_GE:
+            case TacticalLines.BRDGHD_GE:
+            case TacticalLines.LOA:
+            case TacticalLines.LOD:
+            case TacticalLines.LDLC:
+            case TacticalLines.PLD:
+            case TacticalLines.RELEASE:
+            case TacticalLines.HOL:
+            case TacticalLines.BHL: {
+                result = true;
+                break;
+            }
+
+            default: {
+                break;
+            }
+
+        }
+        if (clsUtilityJTR.isClosedPolygon(linetype) === true) {
+
+            result = true;
+        }
+
+        return result;
+    }
+
+    /**
+     * @deprecated
+     */
+    protected static FilterPoints(tg: TGLight): void {
+        try {
+            let lineType: int = tg.get_LineType();
+            let minSpikeDistance: double = 0;
+            switch (lineType) {
+                //case TacticalLines.LC:
+                case TacticalLines.ATDITCH:
+                case TacticalLines.ATDITCHC:
+                case TacticalLines.ATDITCHM:
+                case TacticalLines.FLOT:
+                case TacticalLines.FORT_REVD:
+                case TacticalLines.FORT:
+                case TacticalLines.FORTL:
+                case TacticalLines.STRONG: {
+                    minSpikeDistance = 25;
+                    break;
+                }
+
+                case TacticalLines.LC:
+                case TacticalLines.OBSAREA:
+                case TacticalLines.OBSFAREA:
+                case TacticalLines.ENCIRCLE:
+                case TacticalLines.ZONE:
+                case TacticalLines.LINE:
+                case TacticalLines.ATWALL:
+                case TacticalLines.UNSP:
+                case TacticalLines.SFENCE:
+                case TacticalLines.DFENCE:
+                case TacticalLines.DOUBLEA:
+                case TacticalLines.LWFENCE:
+                case TacticalLines.HWFENCE:
+                case TacticalLines.SINGLEC:
+                case TacticalLines.DOUBLEC:
+                case TacticalLines.TRIPLE: {
+                    minSpikeDistance = 35;
+                    break;
+                }
+
+                case TacticalLines.UCF:
+                case TacticalLines.CF:
+                case TacticalLines.CFG:
+                case TacticalLines.CFY: {
+                    minSpikeDistance = 60;
+                    break;
+                }
+
+                case TacticalLines.SF:
+                case TacticalLines.USF:
+                case TacticalLines.OCCLUDED:
+                case TacticalLines.UOF: {
+                    minSpikeDistance = 60;//was 120
+                    break;
+                }
+
+                case TacticalLines.SFG:
+                case TacticalLines.SFY: {
+                    minSpikeDistance = 60;//was 180
+                    break;
+                }
+
+                case TacticalLines.WFY:
+                case TacticalLines.WFG:
+                case TacticalLines.OFY: {
+                    minSpikeDistance = 60;//was 120
+                    break;
+                }
+
+                case TacticalLines.WF:
+                case TacticalLines.UWF: {
+                    minSpikeDistance = 40;
+                    break;
+                }
+
+
+                case TacticalLines.RIDGE:
+                case TacticalLines.ICE_EDGE_RADAR:  //METOCs
+                case TacticalLines.ICE_OPENINGS_FROZEN:
+                case TacticalLines.CRACKS_SPECIFIC_LOCATION: {
+                    minSpikeDistance = 35;
+                    break;
+                }
+
+                default: {
+                    return;
+                }
+
+            }
+            let j: int = 0;
+            let dist: double = 0;
+            let pts: Array<POINT2> = new Array();
+            let ptsGeo: Array<POINT2> = new Array();
+            pts.push(tg.Pixels[0]);
+            ptsGeo.push(tg.LatLongs[0]);
+            let lastGoodPt: POINT2 = tg.Pixels[0];
+            let currentPt: POINT2;
+            let currentPtGeo: POINT2;
+            let foundGoodPt: boolean = false;
+            let n: int = tg.Pixels.length;
+            //for(j=1;j<tg.Pixels.length;j++)
+            for (j = 1; j < n; j++) {
+                //we can not filter out the original end points
+                currentPt = tg.Pixels[j];
+                currentPtGeo = tg.LatLongs[j];
+                if (currentPt.style === -1) {
+                    lastGoodPt = currentPt;
+                    pts.push(currentPt);
+                    ptsGeo.push(currentPtGeo);
+                    foundGoodPt = true;
+                    currentPt.style = 0;
+                    continue;
+                }
+                dist = lineutility.CalcDistanceDouble(lastGoodPt, currentPt);
+                switch (lineType) {
+                    case TacticalLines.LC: {
+                        if (dist > minSpikeDistance) {
+                            lastGoodPt = currentPt;
+                            pts.push(currentPt);
+                            ptsGeo.push(currentPtGeo);
+                            foundGoodPt = true;
+                        }
+                        else {   //the last point is no good
+                            //replace the last good point with the last point
+                            if (j === tg.Pixels.length - 1) {
+                                pts[pts.length - 1] = currentPt;
+                                ptsGeo[ptsGeo.length - 1] = currentPtGeo;
+                            }
+                        }
+                        break;
+                    }
+
+                    default: {
+                        if (dist > minSpikeDistance || j === tg.Pixels.length - 1) {
+                            lastGoodPt = currentPt;
+                            pts.push(currentPt);
+                            ptsGeo.push(currentPtGeo);
+                            foundGoodPt = true;
+                        }
+                        break;
+                    }
+
+                }
+            }
+            if (foundGoodPt === true) {
+                tg.Pixels = pts;
+                tg.LatLongs = ptsGeo;
+            }
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException("clsUtility", "FilterPoints",
+                    new RendererException("Failed inside FilterPoints", exc));
+
+            } else {
+                throw exc;
+            }
+        }
+    }
+
+    public static PixelsToLatLong(pts: Array<POINT2>, converter: IPointConversion): Array<POINT2> {
+        let j: int = 0;
+        let pt: POINT2;
+        let ptGeo: POINT2;
+        let ptsGeo: Array<POINT2> = new Array();
+        let n: int = pts.length;
+        //for(j=0;j<pts.length;j++)
+        for (j = 0; j < n; j++) {
+            pt = pts[j];
+            ptGeo = clsUtility.PointPixelsToLatLong(pt, converter);
+            ptsGeo.push(ptGeo);
+        }
+        return ptsGeo;
+    }
+
+    static LatLongToPixels(pts: Array<POINT2>, converter: IPointConversion): Array<POINT2> {
+        let j: int = 0;
+        let pt: POINT2;
+        let ptPixels: POINT2;
+        let ptsPixels: Array<POINT2> = new Array();
+        let n: int = pts.length;
+        //for(j=0;j<pts.length;j++)
+        for (j = 0; j < n; j++) {
+            pt = pts[j];
+            ptPixels = clsUtility.PointLatLongToPixels(pt, converter);
+            ptsPixels.push(ptPixels);
+        }
+        return ptsPixels;
+    }
+
+    private static PointLatLongToPixels(ptLatLong: POINT2, converter: IPointConversion): POINT2 {
+        let pt2: POINT2 = new POINT2();
+        let pt2d: Point2D = clsUtility.POINT2ToPoint2D(ptLatLong);
+        pt2d = converter.GeoToPixels(pt2d);
+        pt2 = clsUtility.Point2DToPOINT2(pt2d);
+        pt2.style = ptLatLong.style;
+        return pt2;
+    }
+
+    static FilterAXADPoints(tg: TGLight, converter: IPointConversion): void {
+        try {
+            let lineType: int = tg.get_LineType();
+            switch (lineType) {
+                case TacticalLines.CATK:
+                case TacticalLines.CATKBYFIRE:
+                case TacticalLines.AIRAOA:
+                case TacticalLines.AAAAA:
+                case TacticalLines.SPT:
+                case TacticalLines.MAIN: {
+                    break;
+                }
+
+                default: {
+                    return;
+                }
+
+            }
+            let j: int = 0;
+            let pts: Array<POINT2> = new Array();
+            let ptsGeo: Array<POINT2> = new Array();
+            let pt0: POINT2 = tg.Pixels[0];
+            let pt1: POINT2 = tg.Pixels[1];
+
+            let pt: Point2D = new Point2D(pt1.x, pt1.y);
+            let pt1Geo2d: Point2D = converter.PixelsToGeo(pt);
+
+            let pt1geo: POINT2 = new POINT2(pt1Geo2d.getX(), pt1Geo2d.getY());
+            let ptj: POINT2;
+            let ptjGeo: POINT2;
+            let controlPt: POINT2 = tg.Pixels[tg.Pixels.length - 1]; //the control point
+            let pt0Relative: POINT2 = lineutility.PointRelativeToLine(pt0, pt1, pt0, controlPt);
+            let relativeDist: double = lineutility.CalcDistanceDouble(pt0Relative, controlPt);
+            relativeDist += 5;
+            let pt0pt1dist: double = lineutility.CalcDistanceDouble(pt0, pt1);
+            let foundGoodPoint: boolean = false;
+            if (relativeDist > pt0pt1dist) {
+                //first point is too close, begin rebuilding the arrays
+                pts.push(pt0);
+                pt = new Point2D(pt0.x, pt0.y);
+                pt1Geo2d = converter.PixelsToGeo(pt);
+
+                pt1geo = new POINT2(pt1Geo2d.getX(), pt1Geo2d.getY());
+                ptsGeo.push(pt1geo);
+                //create a good first point and add it to the array
+                pt1 = lineutility.ExtendAlongLineDouble(pt0, pt1, relativeDist);
+                pts.push(pt1);
+
+                pt = new Point2D(pt1.x, pt1.y);
+                pt1Geo2d = converter.PixelsToGeo(pt);
+                pt1geo = new POINT2(pt1Geo2d.getX(), pt1Geo2d.getY());
+                ptsGeo.push(pt1geo);
+            }
+            else {
+                //the first point is good, there is no need to do anything
+                foundGoodPoint = true;
+                pts = tg.Pixels;
+                ptsGeo = tg.LatLongs;
+            }
+
+            //do not add mores points to the array until we find at least one good point
+            let n: int = tg.Pixels.length;
+            if (foundGoodPoint === false) {
+                //for(j=2;j<tg.Pixels.length-1;j++)
+                for (j = 2; j < n - 1; j++) {
+                    ptj = tg.Pixels[j];
+                    ptjGeo = tg.LatLongs[j];
+                    if (foundGoodPoint) {
+                        //then stuff the remainder of the arrays with the original points
+                        pts.push(ptj);
+                        ptsGeo.push(ptjGeo);
+                    }
+                    else    //no good points yet
+                    {
+                        //calculate the distance and continue if it is no good
+                        pt0pt1dist = lineutility.CalcDistanceDouble(pt0, ptj);
+                        if (relativeDist > pt0pt1dist) {
+
+                            continue;
+                        }
+
+                        else {
+                            //found a good point
+                            pts.push(ptj);
+                            ptsGeo.push(ptjGeo);
+                            //set the boolean so that it will stuff the array with the rest of the points
+                            foundGoodPoint = true;
+                        }
+                    }
+                }
+                //finally add the control point to the arrays and set the arrays
+                pts.push(controlPt);
+                //pt1Geo2d=converter.convertPixelsToLonLat(controlPt.x, controlPt.y);
+                pt = new Point2D(controlPt.x, controlPt.y);
+                pt1Geo2d = converter.PixelsToGeo(pt);
+
+                pt1geo = new POINT2(pt1Geo2d.getX(), pt1Geo2d.getY());
+                ptsGeo.push(pt1geo);
+            }   //end if foundGoodPoint is false
+
+            //add all the successive points which are far enough apart
+            let lastGoodPt: POINT2 = pts[1];
+            let currentPt: POINT2;
+            let currentPtGeo: POINT2;
+            let dist: double = 0;
+            tg.Pixels = new Array();
+            tg.LatLongs = new Array();
+            for (j = 0; j < 2; j++) {
+                tg.Pixels.push(pts[j]);
+                tg.LatLongs.push(ptsGeo[j]);
+            }
+            n = pts.length;
+            //for(j=2;j<pts.length-1;j++)
+            for (j = 2; j < n - 1; j++) {
+                currentPt = pts[j];
+                currentPtGeo = ptsGeo[j];
+                dist = lineutility.CalcDistanceDouble(currentPt, lastGoodPt);
+                if (dist > 5) {
+                    lastGoodPt = currentPt;
+                    tg.Pixels.push(currentPt);
+                    tg.LatLongs.push(currentPtGeo);
+                }
+            }
+            //add the control point
+            tg.Pixels.push(pts[pts.length - 1]);
+            tg.LatLongs.push(ptsGeo[ptsGeo.length - 1]);
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException("clsUtility", "FilterAXADPoints",
+                    new RendererException("Failed inside FilterAXADPoints", exc));
+
+            } else {
+                throw exc;
+            }
+        }
+    }
+    /**
+     *
+     * @param tg
+     */
+    static RemoveDuplicatePoints(tg: TGLight): void {
+        try {
+            //do not remove autoshape duplicate points
+            //            if(isAutoshape(tg))
+            //                return;
+            switch (tg.get_LineType()) {
+                case TacticalLines.SC:
+                case TacticalLines.MRR:
+                case TacticalLines.SL:
+                case TacticalLines.TC:
+                case TacticalLines.LLTR:
+                case TacticalLines.AC:
+                case TacticalLines.SAAFR: {
+                    break;
+                }
+
+                default: {
+                    if (clsUtilityJTR.isAutoshape(tg)) {
+                        return;
+                    }
+
+                }
+
+            }
+
+            //we assume tg.H to have colors if it is comma delimited.
+            //only exit if colors are not set
+            switch (tg.get_LineType())   //preserve segment data
+            {
+                case TacticalLines.CATK:
+                case TacticalLines.AIRAOA:
+                case TacticalLines.AAAAA:
+                case TacticalLines.SPT:
+                case TacticalLines.MAIN:
+                case TacticalLines.CATKBYFIRE: {	//80
+                    return;
+                }
+
+                case TacticalLines.BOUNDARY:
+                case TacticalLines.MSR:
+                case TacticalLines.ASR:
+                case TacticalLines.ROUTE: {
+                    let strH: string = tg.get_H();
+                    if (strH != null && strH.length > 0) {
+                        let strs: string[] = strH.split(",");
+                        if (strs.length > 1) {
+
+                            return;
+                        }
+
+                    }
+                    break;
+                }
+
+                default: {
+                    break;
+                }
+
+            }
+            let linetype: int = tg.get_LineType();
+            if (clsUtilityJTR.IsChange1Area(linetype)) {
+                return;
+            }
+
+
+            let ptCurrent: POINT2;
+            let ptLast: POINT2;
+            let isClosedPolygon: boolean = clsUtilityJTR.isClosedPolygon(tg.get_LineType());
+            let minSize: int = 2;
+            if (isClosedPolygon) {
+                minSize = 3;
+            }
+
+            for (let j: int = 1; j < tg.Pixels.length; j++) {
+                ptLast = new POINT2(tg.Pixels[j - 1]);
+                ptCurrent = new POINT2(tg.Pixels[j]);
+                //if(ptCurrent.x==ptLast.x && ptCurrent.y==ptLast.y)
+                if (Math.abs(ptCurrent.x - ptLast.x) < 0.5 && Math.abs(ptCurrent.y - ptLast.y) < 0.5) {
+                    if (tg.Pixels.length > minSize) {
+                        tg.Pixels.splice(j, 1);
+                        tg.LatLongs.splice(j, 1);
+                        j = 1;
+                    }
+                }
+            }
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException("clsUtility", "RemoveDuplicatePoints",
+                    new RendererException("Failed inside RemoveDuplicatePoints", exc));
+
+            } else {
+                throw exc;
+            }
+        }
+    }
+    static PointPixelsToLatLong(ptPixels: POINT2, converter: IPointConversion): POINT2 {
+        let pt2: POINT2 = new POINT2();
+        try {
+            //Point pt=POINT2ToPoint(ptPixels);
+            let pt: Point2D = new Point2D(ptPixels.x, ptPixels.y);
+            let pt2d: Point2D = converter.PixelsToGeo(pt);
+            pt2 = clsUtility.Point2DToPOINT2(pt2d);
+            pt2.style = ptPixels.style;
+
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException("clsUtility", "PointPixelsToLatLong",
+                    new RendererException("Could not convert point to geo", exc));
+            } else {
+                throw exc;
+            }
+        }
+        return pt2;
+    }
+
+    static getMBR(clipBounds: Array<Point2D>): Rectangle2D {
+        let rect: Rectangle2D;
+        try {
+            let j: int = 0;
+            let pt: Point2D;
+            let xmax: double = clipBounds[0].getX();
+            let xmin: double = xmax;
+            let ymax: double = clipBounds[0].getY();
+            let ymin: double = ymax;
+            let n: int = clipBounds.length;
+            //for(j=0;j<clipBounds.length;j++)
+            for (j = 0; j < n; j++) {
+                pt = clipBounds[j];
+                if (pt.getX() < xmin) {
+
+                    xmin = pt.getX();
+                }
+
+                if (pt.getX() > xmax) {
+
+                    xmax = pt.getX();
+                }
+
+                if (pt.getY() <= ymin) {
+
+                    ymin = pt.getY();
+                }
+
+                if (pt.getY() > ymax) {
+
+                    ymax = pt.getY();
+                }
+
+            }
+            rect = new Rectangle2D(xmin, ymin, xmax - xmin, ymax - ymin);
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(clsUtility._className, "AddBoundaryPointsForLines",
+                    new RendererException("Failed inside AddBoundaryPointsForLines", exc));
+            } else {
+                throw exc;
+            }
+        }
+        return rect;
+    }
+
+    static GetMBR(shapes: Array<Shape2>,
+        ptUl: POINT2,
+        ptUr: POINT2,
+        ptLr: POINT2,
+        ptLl: POINT2): void {
+        try {
+            let firstPoint: POINT2 = shapes[0].getPoints()[0];
+            ptUl.x = firstPoint.x;
+            ptUl.y = firstPoint.y;
+            ptUr.x = firstPoint.x;
+            ptUr.y = firstPoint.y;
+            ptLl.x = firstPoint.x;
+            ptLl.y = firstPoint.y;
+            ptLr.x = firstPoint.x;
+            ptLr.y = firstPoint.y;
+            for (let shape of shapes) {
+                let points: Array<POINT2> = shape.getPoints();
+                for (let j: int = 0; j < points.length; j++) {
+                    let x: double = points[j].x;
+                    let y: double = points[j].y;
+                    if (x < ptLl.x) {
+                        ptLl.x = x;
+                        ptUl.x = x;
+                    }
+                    if (x > ptLr.x) {
+                        ptLr.x = x;
+                        ptUr.x = x;
+                    }
+                    if (y > ptLl.y) {
+                        ptLl.y = y;
+                        ptLr.y = y;
+                    }
+                    if (y < ptUl.y) {
+                        ptUl.y = y;
+                        ptUr.y = y;
+                    }
+                }
+            }
+
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(clsUtility._className, "GetMBR",
+                    new RendererException("Failed inside GetMBR", exc));
+            } else {
+                throw exc;
+            }
+        }
+    }
+}