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

package/src/main/ts/armyc2/c5isr/JavaLineArray/countsupport.ts

@@ -0,0 +1,1084 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+
+
+import { type double, type int, type long } from "../graphics2d/BasicTypes";
+
+import { Rectangle2D } from "../graphics2d/Rectangle2D"
+
+import { arraysupport } from "../JavaLineArray/arraysupport"
+import { flot } from "../JavaLineArray/flot"
+import { lineutility } from "../JavaLineArray/lineutility"
+import { POINT2 } from "../JavaLineArray/POINT2"
+import { TacticalLines } from "../JavaLineArray/TacticalLines"
+
+import { TGLight } from "../JavaTacticalRenderer/TGLight"
+
+import { ErrorLogger } from "../renderer/utilities/ErrorLogger"
+import { RendererException } from "../renderer/utilities/RendererException"
+import { RendererSettings } from "../renderer/utilities/RendererSettings"
+
+import { Channels } from "./Channels";
+
+
+/**
+ * A class to calculate the number of pixels based points required for a line
+ *
+ */
+export class countsupport {
+    private static readonly maxLength: double = 100;	//max arrow size
+    private static readonly minLength: double = 2.5;		//min arrow size was 5
+    private static readonly _className: string = "countsupport";
+
+    //    protected static void setMinLength(double mLength)
+    //    {
+    //        minLength=mLength;
+    //    }
+    /**
+     * The main function to return the number of points needed for a symbol
+     * @param vblCounter the number of client points
+     * @param pLinePoints the client point array
+     * @return the number of points required to draw the symbol
+     */
+    static GetCountersDouble(tg: TGLight,
+        vblCounter: int,
+        pLinePoints: POINT2[],
+        clipBounds: Rectangle2D | null): int {
+        let count: int = 0;
+        try {
+            let vbiDrawThis: int = tg.get_LineType();
+            //declaration section
+            let j: int = 0;
+            let vblSaveCounter: int = vblCounter;
+            let pSquarePoints: POINT2[] = new Array<POINT2>(4);
+            let pUpperLinePoints: POINT2[];
+            let
+                pLowerLinePoints: POINT2[]
+            let segments: number[];
+            let pNewLinePoints: POINT2[];
+            let dRadius: double = 0;
+            let pointsCorner: POINT2[] = new Array<POINT2>(2);
+            //double saveMaxPixels = 2000;//CELineArrayGlobals.MaxPixels2;
+
+            pUpperLinePoints = new Array<POINT2>(vblCounter);
+            pLowerLinePoints = new Array<POINT2>(vblCounter);
+
+            for (j = 0; j < vblCounter; j++) {
+                pUpperLinePoints[j] = new POINT2(pLinePoints[j]);
+                pLowerLinePoints[j] = new POINT2(pLinePoints[j]);
+            }
+            lineutility.InitializePOINT2Array(pointsCorner);
+            lineutility.InitializePOINT2Array(pSquarePoints);
+            //end delcarations
+            switch (vbiDrawThis) {
+                case TacticalLines.BS_ELLIPSE: {
+                    count=37;
+                    break;
+                }
+
+                case TacticalLines.BS_CROSS: {
+                    count=4;
+                    break;
+                }
+
+                case TacticalLines.OVERHEAD_WIRE: {
+                    count = vblCounter * 15;    //15 points per segment
+                    break;
+                }
+
+                case TacticalLines.REEF: {
+                    vblCounter = countsupport.GetReefCount(pLinePoints, arraysupport.getScaledSize(40, tg.get_LineThickness(), tg.get_patternScale()), vblSaveCounter);
+                    count = vblCounter;
+                    break;
+                }
+
+                case TacticalLines.RESTRICTED_AREA: {
+                    vblCounter = countsupport.GetRestrictedAreaCount(pLinePoints, arraysupport.getScaledSize(15, tg.get_LineThickness(), tg.get_patternScale()), vblSaveCounter);
+                    count = vblCounter;
+                    break;
+                }
+
+                case TacticalLines.TRAINING_AREA: {
+                    vblCounter += 30;
+                    count = vblCounter;
+                    break;
+                }
+
+                case TacticalLines.PIPE: {
+                    count = countsupport.GetPipeCount(pLinePoints, arraysupport.getScaledSize(20, tg.get_LineThickness(), tg.get_patternScale()), vblSaveCounter);
+                    break;
+                }
+
+                case TacticalLines.ANCHORAGE_AREA:
+                case TacticalLines.ANCHORAGE_LINE: {
+                    count = flot.GetAnchorageCountDouble(pLinePoints, arraysupport.getScaledSize(20, tg.get_LineThickness(), tg.get_patternScale()), vblCounter);
+                    break;
+                }
+
+                case TacticalLines.LRO: {
+                    let xCount: int = countsupport.GetXPointsCount(pLinePoints, arraysupport.getScaledSize(30, tg.get_LineThickness(), tg.get_patternScale()), vblCounter);
+                    let lvoCount: int = countsupport.GetLVOCount(pLinePoints, arraysupport.getScaledSize(30, tg.get_LineThickness(), tg.get_patternScale()), vblCounter);
+                    count = xCount + lvoCount;
+                    break;
+                }
+
+                case TacticalLines.LVO: {
+                    count = countsupport.GetLVOCount(pLinePoints, arraysupport.getScaledSize(20, tg.get_LineThickness(), tg.get_patternScale()), vblCounter);
+                    break;
+                }
+
+                case TacticalLines.ICING: {
+                    vblCounter = countsupport.GetIcingCount(pLinePoints, arraysupport.getScaledSize(15, tg.get_LineThickness(), tg.get_patternScale()), vblCounter);
+                    count = vblCounter;
+                    break;
+                }
+
+                case TacticalLines.FLOT: {
+                    vblSaveCounter = vblCounter;
+                    vblCounter = flot.GetFlotCountDouble(pLinePoints, arraysupport.getScaledSize(20, tg.get_LineThickness(), tg.get_patternScale()), vblCounter);
+                    count = vblCounter;
+                    break;
+                }
+
+                case TacticalLines.MVFR:
+                case TacticalLines.UNDERCAST: {
+                    vblSaveCounter = vblCounter;
+                    vblCounter = flot.GetFlotCountDouble(pLinePoints, arraysupport.getScaledSize(20, tg.get_LineThickness(), tg.get_patternScale()), vblCounter);
+                    count = vblCounter;
+                    break;
+                }
+
+                case TacticalLines.ITD: {
+                    vblCounter = countsupport.GetITDQty(pLinePoints, arraysupport.getScaledSize(15, tg.get_LineThickness(), tg.get_patternScale()), vblCounter) + vblCounter;
+                    count = vblCounter;
+                    break;
+                }
+
+                case TacticalLines.CONVERGENCE: {
+                    vblCounter = countsupport.GetConvergenceQty(pLinePoints, arraysupport.getScaledSize(10, tg.get_LineThickness(), tg.get_patternScale()), vblCounter) + vblCounter;
+                    count = vblCounter;
+                    break;
+                }
+
+                case TacticalLines.RIDGE: {
+                    vblCounter = countsupport.GetFORTLCountDouble(tg, pLinePoints, vblSaveCounter);
+                    count = vblCounter;
+                    break;
+                }
+
+                case TacticalLines.TROUGH:
+                case TacticalLines.UPPER_TROUGH:
+                case TacticalLines.INSTABILITY:
+                case TacticalLines.SHEAR: {
+                    vblCounter = countsupport.GetSquallQty(pLinePoints, 6, arraysupport.getScaledSize(30, tg.get_LineThickness(), tg.get_patternScale()), vblSaveCounter as int);
+                    count = vblCounter;
+                    break;
+                }
+
+                case TacticalLines.CABLE: {
+                    vblCounter = countsupport.GetSquallQty(pLinePoints, 6, arraysupport.getScaledSize(20, tg.get_LineThickness(), tg.get_patternScale()), vblSaveCounter as int);
+                    count = vblCounter;
+                    break;
+                }
+
+                case TacticalLines.SQUALL: {
+                    vblCounter = countsupport.GetSquallQty(pLinePoints, 5, arraysupport.getScaledSize(30, tg.get_LineThickness(), tg.get_patternScale()), vblSaveCounter as int) + 2 * vblSaveCounter;
+                    count = vblCounter;
+                    break;
+                }
+
+                case TacticalLines.USF:
+                case TacticalLines.SFG:
+                case TacticalLines.SFY:
+                case TacticalLines.SF: {
+                    vblCounter = flot.GetSFCountDouble(pLinePoints, vblCounter);
+                    count = vblCounter;
+                    break;
+                }
+
+                case TacticalLines.OFY: {
+                    vblSaveCounter = vblCounter;
+                    vblCounter = flot.GetOFYCountDouble(pLinePoints, arraysupport.getScaledSize(80, tg.get_LineThickness(), tg.get_patternScale()), vblCounter);
+                    count = vblCounter;
+                    break;
+                }
+
+                case TacticalLines.UCF:
+                case TacticalLines.CF:
+                case TacticalLines.CFG:
+                case TacticalLines.CFY: {
+                    count = countsupport.GetFORTLCountDouble(tg, pLinePoints, vblSaveCounter);
+                    count += vblSaveCounter;
+                    break;
+                }
+
+                case TacticalLines.FOLLA:
+                case TacticalLines.FOLSP: {
+                    count = 16;
+                    break;
+                }
+
+                case TacticalLines.ROADBLK:
+                case TacticalLines.FERRY: {
+                    count = 8;
+                    break;
+                }
+
+                case TacticalLines.NAVIGATION:
+                case TacticalLines.IL:
+                case TacticalLines.PLANNED:
+                case TacticalLines.ESR1:
+                case TacticalLines.ESR2:
+                case TacticalLines.FORDSITE:
+                case TacticalLines.FOXHOLE: {
+                    count = 4;
+                    break;
+                }
+
+                case TacticalLines.AMBUSH: {	//extra 3 for open arrow, extra 26 for the tail arc,
+                    //and an extra 22 for the tail line segments
+                    count = 53;//vblCounter+51;
+                    break;
+                }
+
+                case TacticalLines.CLUSTER: {
+                    count = 28;
+                    break;
+                }
+
+                case TacticalLines.CONTAIN: {
+                    count = 40;
+                    break;
+                }
+
+                case TacticalLines.BYIMP: {
+                    count = 18;
+                    break;
+                }
+
+                case TacticalLines.SPTBYFIRE: {
+                    count = 16;
+                    break;
+                }
+
+                case TacticalLines.BLOCK:
+                case TacticalLines.MNFLDBLK: {
+                    count = 4;
+                    break;
+                }
+
+                case TacticalLines.PAA_RECTANGULAR: {
+                    count = 5;
+                    break;
+                }
+
+                case TacticalLines.RECTANGULAR_TARGET: {
+                    count = 9;
+                    break;
+                }
+
+                case TacticalLines.PENETRATE: {
+                    count = 7;
+                    break;
+                }
+
+                case TacticalLines.ASLTXING:	//double for the channel type plus 4 for the hash marks
+                case TacticalLines.GAP:
+                case TacticalLines.BYPASS:
+                case TacticalLines.EASY:
+                case TacticalLines.BREACH:
+                case TacticalLines.CANALIZE: {
+                    count = 12;
+                    break;
+                }
+
+                case TacticalLines.MNFLDDIS: {
+                    count = 22;
+                    break;
+                }
+
+                case TacticalLines.WITHDRAW:
+                case TacticalLines.WDRAWUP:
+                case TacticalLines.DELAY:		//extra four points for hash marks on last segment
+                case TacticalLines.RETIRE:
+                case TacticalLines.FPOL:
+                case TacticalLines.RPOL: {
+                    count = 23;
+                    break;
+                }
+
+                case TacticalLines.SEIZE: {
+                    count = 37;
+                    break;
+                }
+
+                case TacticalLines.RIP: {
+                    count = 29;
+                    break;
+                }
+
+                case TacticalLines.DIRATKSPT: {
+                    count = vblCounter + 3;
+                    break;
+                }
+
+                case TacticalLines.ABATIS: {
+                    count = vblCounter + 3;
+                    break;
+                }
+
+                case TacticalLines.FPF:	//extra two points for blocks at each end
+                case TacticalLines.LINTGT:	//extra two points for blocks at each end
+                case TacticalLines.LINTGTS: {
+                    count = vblCounter + 4;
+                    break;
+                }
+
+                case TacticalLines.CHANNEL:
+                case TacticalLines.CHANNEL_FLARED:
+                case TacticalLines.CHANNEL_DASHED: {
+                    //pvblCounters[0]=2*lElements;
+                    //pvblCounters[1]=lElements;
+                    count = 2 * vblCounter;
+                    break;
+                }
+
+                case TacticalLines.SARA: {
+                    count = 16;	//same for DISM
+                    break;
+                }
+
+                case TacticalLines.COVER:		//vblSaveCounter = vblCounter;
+                case TacticalLines.SCREEN:
+                case TacticalLines.GUARD:
+                case TacticalLines.PDF:
+                case TacticalLines.ATKBYFIRE: {
+                    count = 14;	//same for DISM
+                    break;
+                }
+
+                case TacticalLines.RAFT:
+                case TacticalLines.MFLANE: {	//extra eight points for hash marks at either end
+                    count = 8;
+                    break;
+                }
+
+                case TacticalLines.DIRATKGND: {
+                    count = vblCounter + 10;
+                    break;
+                }
+
+                case TacticalLines.DIRATKAIR: {
+                    count = vblCounter + 9;
+                    break;
+                }
+
+                case TacticalLines.DISRUPT:
+                case TacticalLines.CLEAR: {
+                    count = 20;
+                    break;
+                }
+
+                case TacticalLines.MSDZ: {
+                    count = 300;
+                    break;
+                }
+
+                case TacticalLines.CONVOY:
+                case TacticalLines.HCONVOY: {
+                    count = 10;
+                    break;
+                }
+
+                case TacticalLines.ISOLATE:
+                case TacticalLines.CORDONKNOCK:
+                case TacticalLines.CORDONSEARCH: {
+                    count = 50;
+                    break;
+                }
+
+                case TacticalLines.OCCUPY: {
+                    count = 32;
+                    break;
+                }
+
+                case TacticalLines.SECURE: {
+                    count = 29;
+                    break;
+                }
+
+                case TacticalLines.RETAIN: {
+                    count = 75;
+                    break;
+                }
+
+                case TacticalLines.TURN: {
+                    count = 29;
+                    break;
+                }
+
+                case TacticalLines.AIRFIELD: {
+                    count = vblCounter + 5;
+                    break;
+                }
+
+                case TacticalLines.FENCED: {
+                    count = vblCounter;
+                    break;
+                }
+
+                case TacticalLines.MSR_ALT:
+                case TacticalLines.ASR_ALT:
+                case TacticalLines.ROUTE_ALT: {
+                    count = vblCounter * 9;
+                    break;
+                }
+
+                case TacticalLines.MSR_TWOWAY:
+                case TacticalLines.ASR_TWOWAY: {
+                    count = vblCounter * 11;
+                    break;
+                }
+
+                case TacticalLines.MSR_ONEWAY:
+                case TacticalLines.ASR_ONEWAY:
+                case TacticalLines.ROUTE_ONEWAY: {
+                    count = vblCounter * 6;
+                    break;
+                }
+
+                case TacticalLines.WF:
+                case TacticalLines.UWF: {
+                    vblCounter = flot.GetFlotCount2Double(tg, pLinePoints, vblCounter);
+                    vblCounter += vblSaveCounter;
+                    count = vblCounter;
+                    break;
+                }
+
+                case TacticalLines.WFG:
+                case TacticalLines.WFY: {
+                    vblCounter = flot.GetFlotCount2Double(tg, pLinePoints, vblCounter);
+                    count = vblCounter;
+                    break;
+                }
+
+                case TacticalLines.FORDIF: {
+                    dRadius = lineutility.CalcDistanceToLineDouble(pLinePoints[0], pLinePoints[1], pLinePoints[2]);
+                    let spikeLength: double = arraysupport.getScaledSize(10, tg.get_LineThickness(), tg.get_patternScale());
+                    count = Math.trunc((dRadius / (spikeLength / 2)) * 3) + 6;
+                    if (clipBounds != null) {
+                        let width: double = clipBounds.getWidth();
+                        let height: double = clipBounds.getHeight();
+                        dRadius = Math.sqrt(width * width + height * height);
+                        count = Math.trunc(dRadius / (spikeLength / 2)) + 6;
+                    }
+
+
+                    break;
+                }
+
+                case TacticalLines.ATDITCH:	//call function to determine the array size
+                case TacticalLines.ATDITCHC:	//call function to determine the array size
+                case TacticalLines.ATDITCHM: {
+                    count = countsupport.GetDitchCountDouble(pLinePoints, vblSaveCounter, vbiDrawThis);
+                    break;
+                }
+
+                case TacticalLines.CATK:
+                case TacticalLines.MAIN:
+                case TacticalLines.MAIN_STRAIGHT:
+                case TacticalLines.AIRAOA:
+                case TacticalLines.SPT:
+                case TacticalLines.SPT_STRAIGHT: {
+                    //points for these need not be bounded
+                    //they have an extra 8 points for the arrowhead
+                    count = 2 * vblCounter + 8;
+                    break;
+                }
+
+                case TacticalLines.CATKBYFIRE: {
+                    count = 2 * vblCounter + 17;
+                    break;
+                }
+
+                case TacticalLines.AAAAA: {
+                    count = 2 * vblCounter + 19;
+                    break;
+                }
+
+                case TacticalLines.LLTR:  //added 5-4-07
+                case TacticalLines.SAAFR:
+                case TacticalLines.AC:
+                case TacticalLines.SC:
+                case TacticalLines.MRR:
+                case TacticalLines.SL:
+                case TacticalLines.TC: {
+                    vblCounter = 6 * (vblSaveCounter - 1);	//6 per segment
+                    count = vblCounter + 26 * vblSaveCounter * 2;	//26 for each circle and potentially two circles at each endpoint
+                    break;
+                }
+
+                case TacticalLines.ATWALL:
+                case TacticalLines.LINE:
+                case TacticalLines.OBSAREA:
+                case TacticalLines.OBSFAREA:
+                case TacticalLines.STRONG:
+                case TacticalLines.ZONE:
+                case TacticalLines.ENCIRCLE:
+                case TacticalLines.FORT_REVD:
+                case TacticalLines.FORT:
+                case TacticalLines.FORTL: {
+                    count = countsupport.GetFORTLCountDouble(tg, pLinePoints, vblSaveCounter);
+                    break;
+                }
+
+                case TacticalLines.TRIPLE:
+                case TacticalLines.DOUBLEC:
+                case TacticalLines.SINGLEC:
+                case TacticalLines.HWFENCE:
+                case TacticalLines.LWFENCE:
+                case TacticalLines.UNSP:
+                case TacticalLines.DOUBLEA:
+                case TacticalLines.SFENCE:
+                case TacticalLines.DFENCE: {
+                    count = Channels.GetTripleCountDouble(pLinePoints, vblCounter, vbiDrawThis);
+                    break;
+                }
+
+                case TacticalLines.BBS_LINE: {
+                    count = 2 * vblCounter;
+                    break;
+                }
+
+                case TacticalLines.LC: {
+                    pUpperLinePoints = Channels.GetChannelArray2Double(1, pUpperLinePoints, 1, vblCounter, vbiDrawThis, Math.trunc(arraysupport.getScaledSize(20, tg.get_LineThickness(), tg.get_patternScale())));
+                    pLowerLinePoints = Channels.GetChannelArray2Double(1, pLowerLinePoints, 0, vblCounter, vbiDrawThis, Math.trunc(arraysupport.getScaledSize(20, tg.get_LineThickness(), tg.get_patternScale())));
+                    let lUpperFlotCount: int = flot.GetFlotCountDouble(pUpperLinePoints, arraysupport.getScaledSize(20, tg.get_LineThickness(), tg.get_patternScale()), vblCounter);
+                    let lLowerFlotCount: int = flot.GetFlotCountDouble(pLowerLinePoints, arraysupport.getScaledSize(20, tg.get_LineThickness(), tg.get_patternScale()), vblCounter);
+                    count = lUpperFlotCount + lLowerFlotCount;
+                    break;
+                }
+
+                case TacticalLines.OCCLUDED:
+                case TacticalLines.UOF: {
+                    vblSaveCounter = vblCounter;
+                    vblCounter = flot.GetOccludedCountDouble(pLinePoints, vblCounter);
+                    vblCounter += vblSaveCounter;
+                    count = vblCounter;
+                    break;
+                }
+
+                case TacticalLines.FIX:
+                case TacticalLines.MNFLDFIX: {
+                    if (pLinePoints.length > 1) {
+
+                        count = countsupport.GetDISMFixCountDouble(pLinePoints[0], pLinePoints[1], clipBounds);
+                    }
+
+                    else {
+                        count = 0;
+                    }
+
+                    break;
+                }
+
+                case TacticalLines.BYDIF: {
+                    if (clipBounds != null) {
+                        countsupport.GetByDifSegment(pLinePoints, pointsCorner);
+                        let ul: POINT2 = new POINT2(clipBounds.getMinX(), clipBounds.getMinY());    //-100,1000
+                        let lr: POINT2 = new POINT2(clipBounds.getMaxX(), clipBounds.getMaxY());  //-100,1000
+                        let ptsCorner: POINT2[] = lineutility.BoundOneSegment(pointsCorner[0], pointsCorner[1], ul, lr);
+
+                        if (ptsCorner != null) {
+
+                            count = countsupport.GetDISMFixCountDouble(ptsCorner[0], ptsCorner[1], clipBounds);
+                        }
+
+                        else {
+
+                            count = 20;
+                        }
+
+                    }
+                    else {
+
+                        count = countsupport.GetDISMFixCountDouble(pLinePoints[0], pLinePoints[1], clipBounds);
+                    }
+
+
+                    break;
+                }
+
+                default: {
+                    count = vblCounter;
+                    break;
+                }
+
+            }
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(countsupport._className, "GetCountersDouble",
+                    new RendererException("Failed inside GetCountersDouble " + tg.get_LineType().toString(), exc));
+            } else {
+                throw exc;
+            }
+        }
+        return Math.trunc(count);
+    }
+    private static GetReefCount(pLinePoints: POINT2[],
+        length: double,
+        vblCounter: int): int {
+        let count: int = 0;
+        try {
+            let d: double = 0;
+            for (let j: int = 0; j < vblCounter - 1; j++) {
+                d = lineutility.CalcDistanceDouble(pLinePoints[j], pLinePoints[j + 1]);
+                count += 5 * Math.trunc(d / length);
+            }
+            count += 2 * vblCounter as int;
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(countsupport._className, "GetReefCount",
+                    new RendererException("Failed inside GetReefCount", exc));
+            } else {
+                throw exc;
+            }
+        }
+        return count;
+    }
+    private static GetRestrictedAreaCount(pLinePoints: POINT2[],
+        length: double,
+        vblCounter: int): int {
+        let count: int = 0;
+        try {
+            let d: double = 0;
+            for (let j: int = 0; j < vblCounter - 1; j++) {
+                d = lineutility.CalcDistanceDouble(pLinePoints[j], pLinePoints[j + 1]);
+                count += 4 * Math.trunc(d / length);
+            }
+            count += 2 * vblCounter as int;
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(countsupport._className, "GetRestrictedAreaCount",
+                    new RendererException("Failed inside GetRestrictedAreaCount", exc));
+            } else {
+                throw exc;
+            }
+        }
+        return count;
+    }
+
+    private static GetPipeCount(pLinePoints: POINT2[],
+        length: double,
+        vblCounter: int): int {
+        let count: int = 0;
+        try {
+            let d: double = 0;
+            for (let j: int = 0; j < vblCounter - 1; j++) {
+                d = lineutility.CalcDistanceDouble(pLinePoints[j], pLinePoints[j + 1]);
+                count += 3 * Math.trunc(d / length);
+            }
+            count += 2 * vblCounter as int;
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(countsupport._className, "GetPipeCount",
+                    new RendererException("Failed inside GetPipeCount", exc));
+            } else {
+                throw exc;
+            }
+        }
+        return count;
+    }
+
+    static GetXPointsCount(pOriginalLinePoints: POINT2[], segmentLength: double, vblCounter: int): int {
+        let xCounter: int = 0;
+        try {
+            let j: int = 0;
+            let d: double = 0;
+            //POINT2 pt0,pt1,pt2,pt3=new POINT2(),pt4=new POINT2(),pt5=new POINT2(),pt6=new POINT2();
+            let numThisSegment: int = 0;
+            for (j = 0; j < vblCounter - 1; j++) {
+                d = lineutility.CalcDistanceDouble(pOriginalLinePoints[j], pOriginalLinePoints[j + 1]);
+                numThisSegment = Math.trunc((d - segmentLength / 2) / segmentLength);
+                xCounter += 4 * numThisSegment;
+            }
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(countsupport._className, "GetXPointsCount",
+                    new RendererException("Failed inside GetXPointsCount", exc));
+            } else {
+                throw exc;
+            }
+        }
+        return xCounter;
+    }
+
+    static GetLVOCount(pOriginalLinePoints: POINT2[], segmentLength: double, vblCounter: int): int {
+        let lEllipseCounter: int = 0;
+        try {
+            let d: double = 0;
+            let lHowManyThisSegment: int = 0;
+            let j: int = 0;
+            //end declarations
+            for (j = 0; j < vblCounter - 1; j++) {
+                d = lineutility.CalcDistanceDouble(pOriginalLinePoints[j], pOriginalLinePoints[j + 1]);
+                //lHowManyThisSegment = (int) ((d - 20) / 20);
+                lHowManyThisSegment = Math.trunc((d - segmentLength) / segmentLength) + 1;
+                lEllipseCounter += lHowManyThisSegment * 37;
+            }
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(countsupport._className, "GetLVOCount",
+                    new RendererException("Failed inside GetLVOCount", exc));
+            } else {
+                throw exc;
+            }
+        }
+        return lEllipseCounter;
+    }
+
+    private static GetIcingCount(points: POINT2[], length: double, vblCounter: int): int {
+        let total: int = 2 * vblCounter;
+        try {
+            let d: double = 0;
+            for (let j: int = 0; j < vblCounter - 1; j++) {
+                d = lineutility.CalcDistanceDouble(points[j], points[j + 1]);
+                d = (d / length) * 4;
+                total += d;
+            }
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(countsupport._className, "GetIcingCount",
+                    new RendererException("Failed inside GetIcingCount", exc));
+            } else {
+                throw exc;
+            }
+        }
+        return total;
+    }
+
+    protected static GetITDQty(pLinePoints: POINT2[], length: double, vblCounter: int): int {
+        let total: int = 0;
+        try {
+            let j: int = 0;
+            let d: double = 0;
+            let n: int = 0;
+            for (j = 0; j < vblCounter - 1; j++) {
+                d = lineutility.CalcDistanceDouble(pLinePoints[j], pLinePoints[j + 1]);
+                n = 2 * Math.trunc(d / length);
+                if (n < 2) {
+
+                    n = 2;
+                }
+
+                total += n;
+            }
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(countsupport._className, "GetITDQty",
+                    new RendererException("Failed inside GetITDQty", exc));
+            } else {
+                throw exc;
+            }
+        }
+        return total;
+    }
+
+    protected static GetConvergenceQty(pLinePoints: POINT2[], length: double, vblCounter: int): int {
+        let total: int = vblCounter;
+        try {
+            let j: int = 0;
+            let d: double = 0;
+            for (j = 0; j < vblCounter - 1; j++) {
+                d = lineutility.CalcDistanceDouble(pLinePoints[j], pLinePoints[j + 1]);
+                total += 4 * Math.trunc(d / length);
+            }
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(countsupport._className, "GetConvergenceQty",
+                    new RendererException("Failed inside GetConvergenceQty", exc));
+            } else {
+                throw exc;
+            }
+        }
+        return total;
+    }
+
+    /**
+     * Calculates the points for ATDITCH, ATDITCHC, ATDITCHM
+     * @param pLinePoints the client point array
+     * @param vblCounter the number of client points
+     * @param vbiDrawThis the line type
+     * @return
+     */
+    private static GetDitchCountDouble(pLinePoints: POINT2[],
+        vblCounter: int,
+        vbiDrawThis: int): int {
+        let vblXCounter: int = 0;
+        try {
+            //declarations
+            let j: int = 0;
+            let nHowManyThisSegment: int = 0;
+            let dHowFar: double = 0;
+            //dPrinter = (double) nPrinter;
+
+            vblXCounter = vblCounter;
+
+            for (j = 0; j < vblCounter - 1; j++) {
+                dHowFar = lineutility.CalcDistanceDouble(pLinePoints[j], pLinePoints[j + 1]);
+                nHowManyThisSegment = Math.trunc((dHowFar - 1) / 12);
+                if (dHowFar > 24) {
+                    switch (vbiDrawThis) {
+                        //case TacticalLines.FORT:
+                        //    break;
+                        case TacticalLines.ATDITCHM: {
+                            vblXCounter += 5 * nHowManyThisSegment + 1;//was 4 * nHowManyThisSegment
+                            break;
+                        }
+
+                        default: {
+                            vblXCounter += 4 * nHowManyThisSegment;//was 3 * nHowManyThisSegment
+                            break;
+                        }
+
+                    }	//end switch
+                } //end if
+                else {
+                    vblXCounter += 2;
+                }
+            }	//end for
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(countsupport._className, "GetDitchcountDouble",
+                    new RendererException("Failed inside GetDitchCountDouble " + vbiDrawThis.toString(), exc));
+            } else {
+                throw exc;
+            }
+        }
+        return vblXCounter;
+    }
+    static GetSquallQty(pLinePoints: POINT2[],
+        quantity: int,
+        length: double,
+        numPoints: int): int {
+        let counter: int = 0;
+        try {
+            let j: int = 0;
+            let dist: double = 0;
+            let numCurves: int = 0;
+            //end declarations
+
+            for (j = 0; j < numPoints - 1; j++) {
+                dist = lineutility.CalcDistanceDouble(pLinePoints[j], pLinePoints[j + 1]);
+                numCurves = Math.trunc(dist / length as double);
+                counter += numCurves * quantity;
+                if (numCurves === 0) {
+                    counter += 2;
+                }
+            }
+
+            if (counter < numPoints) {
+                counter = numPoints;
+            }
+
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(countsupport._className, "GetSquallQty",
+                    new RendererException("Failed inside GetSquallQty", exc));
+            } else {
+                throw exc;
+            }
+        }
+        return counter;
+    }
+
+    static GetSquallSegQty(StartPt: POINT2,
+        EndPt: POINT2,
+        quantity: int,
+        length: double): int {
+        let qty: int = 0;
+        try {
+            let dist: double = lineutility.CalcDistanceDouble(StartPt, EndPt);
+            let numCurves: int = Math.trunc(dist / length as double);
+            qty = numCurves * quantity;
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(countsupport._className, "GetSquallSegQty",
+                    new RendererException("Failed inside GetSquallSegQty", exc));
+            } else {
+                throw exc;
+            }
+        }
+        return qty;
+    }
+
+    /**
+     * returns number of points required for ATWALL, FORT and other symbols
+     * @param pLinePoints the client points
+     * @param vblCounter the number of client points
+     * @return
+     */
+    static GetFORTLCountDouble(tg: TGLight, pLinePoints: POINT2[], vblCounter: int): int {
+        let lCounter: int = 0;
+        try {
+            //declarations
+            let j: int = 0;
+            let dCounter: double = 0;
+            let dIncrement: double = 0;
+            //end declarations
+
+            switch (tg.get_LineType()) {
+                case TacticalLines.UCF:
+                case TacticalLines.CF:
+                case TacticalLines.CFG:
+                case TacticalLines.CFY: {
+                    dIncrement = arraysupport.getScaledSize(60, tg.get_LineThickness(), tg.get_patternScale());
+                    break;
+                }
+
+                case TacticalLines.RIDGE: {
+                    dIncrement = arraysupport.getScaledSize(20, tg.get_LineThickness(), tg.get_patternScale());
+                    break;
+                }
+
+                default: {
+                    dIncrement = arraysupport.getScaledSize(20, tg.get_LineThickness(), tg.get_patternScale());
+                    break;
+                }
+
+            }
+
+            for (j = 0; j < vblCounter - 1; j++) {
+                dCounter = lineutility.CalcDistanceDouble(pLinePoints[j], pLinePoints[j + 1]);
+
+                switch (tg.get_LineType()) {
+                    case TacticalLines.CFG: {
+                        dCounter = (dCounter / dIncrement) * 13;
+                        break;
+                    }
+
+                    case TacticalLines.CFY: {
+                        dCounter = (dCounter / dIncrement) * 17;
+                        break;
+                    }
+
+                    default: {
+                        dCounter = (dCounter / dIncrement) * 10;
+                        break;
+                    }
+
+                }
+
+                if (dCounter < 4) {
+                    dCounter = 4;
+                }
+                lCounter += Math.trunc(dCounter);
+            }
+            lCounter += 10 + vblCounter;
+
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(countsupport._className, "GetFORTLCountDouble",
+                    new RendererException("Failed inside GetFORTLCountDouble", exc));
+            } else {
+                throw exc;
+            }
+        }
+        return lCounter;
+    }
+
+    private static GetByDifSegment(points: POINT2[], pointsCorner: POINT2[]): void {
+        try {
+            // draw open-ended rectangle
+            let point_mid: POINT2 = new POINT2();
+            //int j=0;
+            //	POINT1 pts[4];
+            if (pointsCorner == null) {
+                pointsCorner = new Array<POINT2>(2);
+                lineutility.InitializePOINT2Array(pointsCorner);
+            }
+            point_mid.x = (points[0].x + points[1].x) / 2;
+            point_mid.y = (points[0].y + points[1].y) / 2;
+            pointsCorner[0].x = points[0].x - point_mid.x + points[2].x;
+            pointsCorner[0].y = points[0].y - point_mid.y + points[2].y;
+            pointsCorner[1].x = points[1].x - point_mid.x + points[2].x;
+            pointsCorner[1].y = points[1].y - point_mid.y + points[2].y;
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(countsupport._className, "GetByDifSegment",
+                    new RendererException("Failed inside GetByDifSegment", exc));
+            } else {
+                throw exc;
+            }
+        }
+    }
+    /**
+     * clipBounds is used because of the glyphs on one segment
+     * @param FirstLinePoint
+     * @param LastLinePoint
+     * @param clipBounds
+     * @return
+     */
+    protected static GetDISMFixCountDouble(FirstLinePoint: POINT2,
+        LastLinePoint: POINT2,
+        clipBounds: Rectangle2D): int {
+        let counter: int = 0;
+        try {
+            let savepoints: POINT2[] = new Array<POINT2>(2);
+            //double dAngle1 = 0;
+            let dLength: double = 0;
+            let dJaggyHalfAmp: double = 0;
+            let dJaggyHalfPeriod: double = 0;
+            let iNumJaggies: int = 0;
+
+            savepoints[0] = new POINT2(FirstLinePoint);
+            savepoints[1] = new POINT2(LastLinePoint);
+
+            //Boolean drawJaggies=true;
+            if (clipBounds != null) {
+                let ul: POINT2 = new POINT2(clipBounds.getMinX(), clipBounds.getMinY());
+                let lr: POINT2 = new POINT2(clipBounds.getMaxX(), clipBounds.getMaxY());
+                savepoints = lineutility.BoundOneSegment(FirstLinePoint, LastLinePoint, ul, lr);
+            }
+
+            if (savepoints == null) {
+
+                return 0;
+            }
+
+
+            dLength = Math.sqrt((savepoints[1].x - savepoints[0].x) * (savepoints[1].x - savepoints[0].x) +
+                (savepoints[1].y - savepoints[0].y) * (savepoints[1].y - savepoints[0].y));
+            dJaggyHalfAmp = dLength / 15; // half the amplitude of the "jaggy function"
+
+            let DPIScaleFactor: double = RendererSettings.getInstance().getDeviceDPI() / 96.0;
+            if (dJaggyHalfAmp > countsupport.maxLength * DPIScaleFactor) {
+                dJaggyHalfAmp = countsupport.maxLength * DPIScaleFactor;
+            }
+            if (dJaggyHalfAmp < countsupport.minLength * DPIScaleFactor) {
+                dJaggyHalfAmp = countsupport.minLength * DPIScaleFactor;
+            }
+
+            dJaggyHalfPeriod = dJaggyHalfAmp / 1.5; // half the period of the "jaggy function"
+            iNumJaggies = Math.trunc(dLength / dJaggyHalfPeriod) - 3;
+            if (iNumJaggies < 0) {
+                iNumJaggies = 0;
+            }
+
+            savepoints = null;
+            counter = 20 + iNumJaggies * 3;
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(countsupport._className, "GetDISMFixCount",
+                    new RendererException("Failed inside GetDISMFixCount", exc));
+            } else {
+                throw exc;
+            }
+        }
+        return counter;
+    }
+
+}