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

package/src/main/ts/armyc2/c5isr/JavaTacticalRenderer/clsChannelUtility.ts

@@ -1,647 +0,0 @@
-import { type int, type double } from "../graphics2d/BasicTypes";
-
-import { BasicStroke } from "../graphics2d/BasicStroke"
-import { Rectangle2D } from "../graphics2d/Rectangle2D"
-import { arraysupport } from "../JavaLineArray/arraysupport"
-import { CELineArray } from "../JavaLineArray/CELineArray"
-import { Channels } from "../JavaLineArray/Channels"
-import { lineutility } from "../JavaLineArray/lineutility"
-import { POINT2 } from "../JavaLineArray/POINT2"
-import { ref } from "../JavaLineArray/ref"
-import { Shape2 } from "../JavaLineArray/Shape2"
-import { TacticalLines } from "../JavaLineArray/TacticalLines"
-import { P1 } from "../JavaTacticalRenderer/P1"
-import { TGLight } from "../JavaTacticalRenderer/TGLight"
-import { Color } from "../renderer/utilities/Color"
-import { EntityCode } from "../renderer/utilities/EntityCode"
-import { ErrorLogger } from "../renderer/utilities/ErrorLogger"
-import { IPointConversion } from "../renderer/utilities/IPointConversion"
-import { RendererException } from "../renderer/utilities/RendererException"
-import { SymbolID } from "../renderer/utilities/SymbolID"
-import { clsRenderer2 } from "../RenderMultipoints/clsRenderer2"
-import { clsUtility } from "./clsUtility";
-
-/**
- * A class to process channel types.
- *
- *
- */
-export class clsChannelUtility {
-
-    private static readonly _className: string = "clsChannelUtility";
-
-    /**
-     * Gets partitions from the client points based on the segments generated by
-     * GetSegments. Partitions are used handle double-backed segments. Each
-     * partition is a continuous sequence of points for a channel.
-     *
-     * @param segments
-     * @param partitions OUT the partitions
-     * @return
-     */
-    private static GetPartitions(segments: boolean[],
-        partitions: Array<P1>): int {
-        try {
-            let j: int = 0;
-            let nextSegment: boolean = false;
-            //worst case is every segment is a separate partition
-            //caller must deallocate partitions
-            let p1: P1 = new P1();
-            //first segment will always be true,
-            //there are no bad one-segment channels
-            if (segments[0] === false) {
-                return 0;
-            }
-
-            if (partitions != null) {
-                partitions.length = 0; // partitions.clear()
-            } else {
-                return 0;
-            }
-
-            p1.start = 0;
-            //only add the partitions after p1.end has been set
-            let n: int = segments.length;
-            //for (j = 0; j < segments.length - 1; j++) 
-            for (j = 0; j < n - 1; j++) {
-                nextSegment = segments[j + 1];
-                if (nextSegment === false) {
-                    //the end of the current partition is the last good segment
-                    p1.end_Renamed = j;
-                    partitions.push(p1);
-                    //beginning of the next partition
-                    p1 = new P1();
-                    p1.start = j + 1;
-                }
-            }
-            p1.end_Renamed = j;
-            partitions.push(p1);
-        } catch (exc) {
-            if (exc instanceof Error) {
-                //console.log(e.message);
-                //clsUtility.WriteFile("error in clsChanneUtility.GetPartitions");
-                ErrorLogger.LogException(clsChannelUtility._className, "GetPartitions",
-                    new RendererException("Failed inside GetPartitions", exc));
-            } else {
-                throw exc;
-            }
-        }
-        return partitions.length;
-    }
-
-    /**
-     * Draws a partition to the shapes array and stores the calculated channel
-     * points
-     *
-     * @param fromSegment
-     * @param toSegment
-     * @param pixels
-     * @param channelWidth
-     * @param bolLastSegment
-     * @param shapes
-     * @param channelPoints
-     * @param distanceToChannelPoint
-     * @return
-     */
-    private static DrawGoodChannel2(tg: TGLight,
-        fromSegment: int,
-        toSegment: int,
-        pixels: number[],
-        channelWidth: int,
-        bolLastSegment: boolean,
-        shapes: Array<Shape2>,
-        channelPoints: Array<POINT2>,
-        distanceToChannelPoint: double): int {
-        let returnValue: int = 0;	// Had to initialize to something
-        try {
-            let lineType: int = tg.get_LineType();
-            let lineType2: int = 0;
-            let channelPixels: number[];
-            switch (lineType) {
-                case TacticalLines.LC:
-                case TacticalLines.UNSP:
-                case TacticalLines.DFENCE:
-                case TacticalLines.SFENCE:
-                case TacticalLines.DOUBLEA:
-                case TacticalLines.LWFENCE:
-                case TacticalLines.HWFENCE:
-                case TacticalLines.BBS_LINE:
-                case TacticalLines.SINGLEC:
-                case TacticalLines.DOUBLEC:
-                case TacticalLines.TRIPLE: {
-                    lineType2 = lineType;
-                    break;
-                }
-
-                case TacticalLines.SPT: {
-                    if (fromSegment === 0) {
-                        lineType2 = TacticalLines.CHANNEL_FLARED;
-                    } else {
-                        lineType2 = TacticalLines.CHANNEL;
-                    }
-                    break;
-                }
-
-                case TacticalLines.MAIN: {
-                    if (fromSegment === 0) {
-                        lineType2 = TacticalLines.CHANNEL_FLARED;
-                    } else {
-                        lineType2 = TacticalLines.CHANNEL;
-                    }
-                    break;
-                }
-
-                case TacticalLines.CATK: {
-                    lineType2 = TacticalLines.CHANNEL_DASHED;
-                    break;
-                }
-
-                case TacticalLines.CATKBYFIRE: {
-                    lineType2 = TacticalLines.CHANNEL_DASHED;
-                    break;
-                }
-
-                default: {
-                    lineType2 = TacticalLines.CHANNEL;
-                    break;
-                }
-
-            }
-            if (bolLastSegment === true) {
-                if (fromSegment !== 0) {
-                    switch (lineType) {
-                        case TacticalLines.SPT: {
-                            lineType2 = TacticalLines.SPT_STRAIGHT;
-                            break;
-                        }
-
-                        case TacticalLines.MAIN: {
-                            lineType2 = TacticalLines.MAIN_STRAIGHT;
-                            break;
-                        }
-
-                        default: {
-                            lineType2 = lineType as int;
-                            break;
-                        }
-
-                    }
-                } else {
-                    lineType2 = lineType as int;
-                }
-            }
-
-            if (fromSegment < 0) {
-                return returnValue;
-            }
-            if (toSegment < 0) {
-                return returnValue;
-            }
-            if (toSegment < fromSegment) {
-                return returnValue;
-            }
-            let j: int = 0;
-            let lineCount: int = 0;
-            let numPoints: int = 0;
-            let counter: int = 0;
-            let goodUpperPixels: number[];
-            let goodLowerPixels: number[];
-            numPoints = toSegment - fromSegment + 2;
-            goodUpperPixels = new Array<number>(2 * numPoints);
-            goodLowerPixels = new Array<number>(2 * numPoints);
-
-            counter = 0;
-            for (j = fromSegment; j < toSegment + 2; j++) {
-                goodUpperPixels[counter] = pixels[2 * j];
-                goodUpperPixels[counter + 1] = pixels[2 * j + 1];
-                goodLowerPixels[counter] = pixels[2 * j];
-                goodLowerPixels[counter + 1] = pixels[2 * j + 1];
-                counter = counter + 2;
-            }
-
-            tg.set_LineType(lineType2);
-            lineCount = CELineArray.CGetLineCountDouble(tg, goodUpperPixels, numPoints, channelWidth);
-            channelPixels = new Array<number>(3 * lineCount);
-            let pt: POINT2;
-            lineCount = Channels.GetChannel1Double(tg, goodUpperPixels, goodLowerPixels, channelPixels, numPoints, numPoints, channelWidth / 2, distanceToChannelPoint as int, shapes);
-            tg.set_LineType(lineType);
-
-            //if shapes is null then it is not a CPOF client
-            if (shapes == null && channelPixels != null) {
-                //do not clear channelPoints first because the function gets successive calls
-                let n: int = channelPixels.length;
-                //for (j = 0; j < channelPixels.length / 3; j++) 
-                for (j = 0; j < n / 3; j++) {
-                    pt = new POINT2(channelPixels[3 * j], channelPixels[3 * j + 1], channelPixels[3 * j + 2] as int);
-                    if (j === channelPixels.length / 3 - 1) {
-                        pt.style = 5;
-                    }
-                    channelPoints.push(pt);
-                }
-            }
-
-            if (lineCount > 0) {
-                //DrawChannelPixels2(lineCount, channelPixels, (int)lineType);
-                returnValue = channelPixels.length;
-            } else {
-                returnValue = 0;
-            }
-            //channelPixels[channelPixels.length - 1] = 5;
-            if (lineCount > 0) {
-                channelPixels[lineCount - 1] = 5;
-            }
-            //clean up
-            goodUpperPixels = null;
-            goodLowerPixels = null;
-        } catch (exc) {
-            if (exc instanceof Error) {
-                //clsUtility.WriteFile("error in clsChanneUtility.DrawGoodChannel2");
-                ErrorLogger.LogException(clsChannelUtility._className, "DrawGoodChannel2",
-                    new RendererException("Failed inside DrawGoodChannel2", exc));
-            } else {
-                throw exc;
-            }
-        }
-        return returnValue;
-    }
-
-    /**
-     * Draws the channel partitions to the shapes array
-     *
-     * @param pixels
-     * @param partitions
-     * @param channelWidth channel width in pixels
-     * @param shapes
-     * @param channelPoints
-     * @param distanceToChannelPoint distance in pixels from the tip to the back
-     * of the arrow
-     */
-    private static DrawSegments(tg: TGLight,
-        pixels: number[],
-        partitions: Array<P1>,
-        channelWidth: int,
-        shapes: Array<Shape2>,
-        channelPoints: Array<POINT2>,
-        distanceToChannelPoint: double): void {
-        try {
-            let j: int = 0;
-            let n: int = 0;
-            let t: int = partitions.length;
-            //for (j = 0; j < partitions.length - 1; j++) 
-            for (j = 0; j < t - 1; j++) {
-                n = clsChannelUtility.DrawGoodChannel2(tg, partitions[j].start, partitions[j].end_Renamed, pixels, channelWidth, false, shapes, channelPoints, distanceToChannelPoint);
-
-            }
-            //draw the last partition using linetype
-            n = clsChannelUtility.DrawGoodChannel2(tg, partitions[j].start, partitions[j].end_Renamed, pixels, channelWidth, true, shapes, channelPoints, distanceToChannelPoint);
-        } catch (exc) {
-            if (exc instanceof Error) {
-                //clsUtility.WriteFile("error in clsChanneUtility.DrawSegments");
-                ErrorLogger.LogException(clsChannelUtility._className, "DrawSegments",
-                    new RendererException("Failed inside DrawSegments", exc));
-            } else {
-                throw exc;
-            }
-        }
-    }
-
-    private static DrawLCSingleLineSegments(tg: TGLight,
-        pixels2: number[],
-        singleLinePartitions: Array<P1>,
-        shapes: Array<Shape2>,
-        clipBounds: Rectangle2D,
-        converter: IPointConversion): void {
-        try {
-            for (let flotPartition of singleLinePartitions) {
-                let vblSaveCounter: int = flotPartition.end_Renamed - flotPartition.start + 1;
-                let flotPixels: Array<POINT2> = new Array();
-                for (let i: int = 0; i < vblSaveCounter; i++) {
-
-                    flotPixels.push(new POINT2(pixels2[2 * (i + flotPartition.start)], pixels2[2 * (i + flotPartition.start) + 1]));
-                }
-
-
-                let flotID: string = tg.get_SymbolId();
-                flotID = SymbolID.setAffiliation(flotID, SymbolID.StandardIdentity_Affiliation_Hostile_Faker);
-                flotID = SymbolID.setEntityCode(flotID, EntityCode.EntityCode_FLOT);
-                let flotTG: TGLight = new TGLight();
-                flotTG.set_LineType(TacticalLines.FLOT);
-                flotTG.set_Pixels(flotPixels);
-                flotTG.set_SymbolId(flotID);
-                flotTG.set_LineThickness(tg.get_LineThickness());
-
-                let flotShapes: Array<Shape2> | null = clsRenderer2.GetLineArray(flotTG, converter, false, clipBounds);
-
-                if (flotShapes != null) {
-                    for (let shape of flotShapes) {
-
-                        shape.setLineColor(Color.RED);
-                    }
-
-                    shapes.push(...flotShapes);
-                }
-            }
-        } catch (exc) {
-            if (exc instanceof Error) {
-                ErrorLogger.LogException(clsChannelUtility._className, "DrawLCFlotSegments",
-                    new RendererException("Failed inside DrawLCFlotSegments", exc));
-            } else {
-                throw exc;
-            }
-        }
-    }
-
-    /**
-     * Handle symbol too small for line of contact
-     * @param tg
-     * @param pixels
-     * @return 
-     */
-    private static getLCPixels(tg: TGLight, pixels: Array<POINT2>): Array<POINT2> {
-        let pixels2: Array<POINT2>;
-        try {
-            if (tg.get_LineType() !== TacticalLines.LC) {
-
-                return pixels;
-            }
-
-            let pts: POINT2[] = tg.Pixels;
-            let ul: POINT2 = new POINT2();
-            let lr: POINT2 = new POINT2();
-            lineutility.CalcMBRPoints(pts as POINT2[], pts.length, ul, lr);
-            let flotDiameter: double = arraysupport.getScaledSize(21, tg.get_LineThickness(), tg.get_patternScale());
-            if (lr.x - ul.x >= flotDiameter) {
-
-                return pixels;
-            }
-
-            else {
-                if (lr.y - ul.y >= flotDiameter) {
-
-                    return pixels;
-                }
-
-            }
-
-            //at this point the mbr is too small for a meaningful LC symbol
-            let x0: double = pts[0].x;
-            let y0: double = pts[0].y;
-            let x1: double = pts[1].x;
-            let y1: double = pts[1].y;
-            if (x0 <= x1) {
-
-                x1 = x0 + flotDiameter;
-            }
-
-            else {
-
-                x1 = x0 - flotDiameter;
-            }
-
-            y1 = y0;
-            let pt0: POINT2 = new POINT2(x0, y0);
-            let pt1: POINT2 = new POINT2(x1, y1);
-            pixels2 = new Array();
-            pixels2.push(pt0);
-            pixels2.push(pt1);
-        } catch (exc) {
-            if (exc instanceof Error) {
-                //clsUtility.WriteFile("error in clsChanneUtility.DrawSegments");
-                ErrorLogger.LogException(clsChannelUtility._className, "getLCPixels",
-                    new RendererException("Failed inside getLCPixels", exc));
-            } else {
-                throw exc;
-            }
-        }
-        return pixels2;
-    }
-
-    /**
-     * The main interface to clsChannelUtility calls DrawChannel2 after stuffing
-     * the points into an array of 2-tuples x,y
-     *
-     * @param pixels the client points
-     * @param linetype the line type
-     * @param tg the tactical graphic
-     * @param shapes
-     * @param channelPoints
-     */
-    public static DrawChannel(pixels: Array<POINT2>,
-        linetype: int,
-        tg: TGLight,
-        shapes: Array<Shape2>,
-        channelPoints: Array<POINT2> | null,
-        clipBounds: Rectangle2D,
-        converter: IPointConversion): void {
-        try {
-            pixels = clsChannelUtility.getLCPixels(tg, pixels);
-            //we must do this because the rotary arrow tip now has to match the
-            //anchor point, i.e. the rotary feature can no longer stick out past the anchor point
-            //45 pixels shift here matches the 45 pixels shift for catkbyfire found in Channels.GetAXADDouble
-            lineutility.adjustCATKBYFIREControlPoint(linetype, pixels, 45);
-
-            let j: int = 0;
-            let pixels2: number[] = new Array<number>(pixels.length * 2);
-            let n: int = pixels.length;
-            //for (j = 0; j < pixels.length; j++) 
-            for (j = 0; j < n; j++) {
-                pixels2[2 * j] = pixels[j].x;
-                pixels2[2 * j + 1] = pixels[j].y;
-            }
-            clsChannelUtility.DrawChannel2(pixels2, linetype, tg, shapes, channelPoints, clipBounds, converter);
-        } catch (exc) {
-            if (exc instanceof Error) {
-                //clsUtility.WriteFile("error in clsChanneUtility.DrawSegments");
-                ErrorLogger.LogException(clsChannelUtility._className, "DrawChannel",
-                    new RendererException("Failed inside DrawChannel", exc));
-            } else {
-                throw exc;
-            }
-        }
-    }
-
-    /**
-     * utility for clsMETOC to handle double-backed segments
-     *
-     * @param tg the tactical graphic object
-     */
-    public static GetPartitions2(tg: TGLight): Array<P1> | null {
-        let partitions: Array<P1>;
-        try {
-            let pixels: number[] = new Array<number>(tg.Pixels.length * 2);
-            let n: int = tg.Pixels.length;
-            //for(int j=0;j<tg.Pixels.length;j++)
-            for (let j: int = 0; j < n; j++) {
-                pixels[2 * j] = tg.Pixels[j].x;
-                pixels[2 * j + 1] = tg.Pixels[j].y;
-            }
-
-            let segments: boolean[] = new Array<boolean>(pixels.length / 2 - 1);
-            if (segments.length === 0) {
-                return null;
-            }
-
-            let factor: double = arraysupport.getScaledSize(3, tg.get_LineThickness(), tg.get_patternScale());
-
-            clsUtility.GetSegments(pixels, segments, factor);
-            partitions = new Array<P1>();
-            clsChannelUtility.GetPartitions(segments, partitions);
-        } catch (exc) {
-            if (exc instanceof Error) {
-                ErrorLogger.LogException(clsChannelUtility._className, "GetPartitions2",
-                    new RendererException("Failed inside GetPartitions2", exc));
-            } else {
-                throw exc;
-            }
-        }
-        return partitions;
-    }
-
-    /**
-     * The main function for processing channel types. Gets segments, then gets
-     * partitions from the segments and then draws the partitions.
-     *
-     * @param pixels the client points as an array of 2-tuples x,y
-     * @param linetype the line type
-     * @param tg the tactical graphic object
-     * @param shapes
-     * @param channelPoints
-     */
-    private static DrawChannel2(pixels: number[],
-        linetype: int,
-        tg: TGLight,
-        shapes: Array<Shape2>,
-        channelPoints: Array<POINT2> | null,
-        clipBounds: Rectangle2D,
-        converter: IPointConversion): void {
-        try {
-            let distanceToChannelPoint: ref<number[]> = new ref();
-            let j: int = 0;
-            let pixels2: number[];
-            let channelWidth: int = 0;
-            let partitions: Array<P1>;
-            let n: int = pixels.length;
-            let numPoints: int = 0;
-            //LC and others do not call clsUtility.ChannelWidth, but the
-            //value array still needs to be allocated or there is a
-            //null pointer exception in DrawGoodChannel2
-            distanceToChannelPoint.value = new Array<number>(1);
-            distanceToChannelPoint.value[0] = arraysupport.getScaledSize(20, tg.get_LineThickness(), tg.get_patternScale());
-
-            switch (linetype) {
-                case TacticalLines.MAIN:
-                case TacticalLines.CATK:
-                case TacticalLines.CATKBYFIRE:
-                case TacticalLines.AIRAOA:
-                case TacticalLines.AAAAA:
-                case TacticalLines.SPT: {
-                    clsUtility.ReorderPixels(pixels);
-                    numPoints = pixels.length / 2;
-
-                    if (numPoints < 3) {
-                        return;
-                    }
-                    //moved this to be prior to stuffing pixels2
-                    channelWidth = clsUtility.ChannelWidth(pixels, distanceToChannelPoint) / 2;
-                    //ValidateChannelPixels2(ref pixels, ref channelWidth, ref distanceToChannelPoint);
-
-                    numPoints = pixels.length / 2;
-                    pixels2 = new Array<number>(pixels.length - 2);
-
-                    for (j = 0; j < numPoints; j++) {
-                        if (j < numPoints - 1) {
-                            pixels2[2 * j] = pixels[2 * j];
-                            pixels2[2 * j + 1] = pixels[2 * j + 1];
-                        }
-                    }
-                    break;
-                }
-
-                case TacticalLines.LC: {
-                    channelWidth = arraysupport.getScaledSize(40, tg.get_LineThickness(), tg.get_patternScale()) as int;// was 20;
-                    pixels2 = new Array<number>(pixels.length);
-                    n = pixels.length;
-                    //for (j = 0; j < pixels.length; j++) 
-                    for (j = 0; j < n; j++) {
-                        pixels2[j] = pixels[j];
-                    }
-                    break;
-                }
-
-                case TacticalLines.UNSP:
-                case TacticalLines.DFENCE:
-                case TacticalLines.SFENCE:
-                case TacticalLines.DOUBLEA:
-                case TacticalLines.LWFENCE:
-                case TacticalLines.HWFENCE:
-                case TacticalLines.SINGLEC:
-                case TacticalLines.DOUBLEC:
-                case TacticalLines.TRIPLE: {
-                    tg.set_lineCap(BasicStroke.CAP_BUTT);
-                    channelWidth = arraysupport.getScaledSize(30, tg.get_LineThickness(), tg.get_patternScale()) as int;
-                    if (Channels.getShiftLines()) {
-                        channelWidth = arraysupport.getScaledSize(60, tg.get_LineThickness(), tg.get_patternScale()) as int;
-                    }
-                    pixels2 = new Array<number>(pixels.length);
-                    n = pixels.length;
-                    //for (j = 0; j < pixels.length; j++) 
-                    for (j = 0; j < n; j++) {
-                        pixels2[j] = pixels[j];
-                    }
-                    break;
-                }
-
-                case TacticalLines.BBS_LINE: {
-                    channelWidth = 8 * tg.Pixels[0].style;  //was 20 1-10-13
-                    let pixels2: double[] = [];
-                    n = pixels.length;
-                    //for (j = 0; j < pixels.length; j++)
-                    for (j = 0; j < n; j++) {
-                        pixels2[j] = pixels[j];
-                    }
-                    break;
-                }
-
-                default: {
-
-                    break;
-                }
-
-            }
-
-            //we require new partitions because pixels are dirty
-            let segments: boolean[] = new Array<boolean>(Math.trunc(pixels2.length / 2) - 1);
-            if (segments.length === 0) {
-                return;
-            }
-
-            // Line of contact looks bad with small channel corners extending out
-            if (linetype === TacticalLines.LC) {
-                partitions = new Array();
-                let singleLinePartitions: Array<P1> = new Array();
-                clsUtility.GetLCPartitions(pixels2, arraysupport.getScaledSize(40, tg.get_LineThickness(), tg.get_patternScale()), partitions, singleLinePartitions);
-                clsChannelUtility.DrawSegments(tg, pixels2, partitions, channelWidth, shapes, channelPoints, distanceToChannelPoint.value[0]);
-
-                if (singleLinePartitions.length > 0) {
-                    // Render any small angles that only have side (not channel) as FLOT
-                    clsChannelUtility.DrawLCSingleLineSegments(tg, pixels2, singleLinePartitions, shapes, clipBounds, converter);
-                }
-            } else {
-                let factor: double = 3;
-
-                clsUtility.GetSegments(pixels2, segments, factor);
-                partitions = new Array();
-                clsChannelUtility.GetPartitions(segments, partitions);
-
-                clsChannelUtility.DrawSegments(tg, pixels2, partitions, channelWidth, shapes, channelPoints, distanceToChannelPoint.value[0]);
-            }
-        } catch (exc) {
-            if (exc instanceof Error) {
-                ErrorLogger.LogException(clsChannelUtility._className, "DrawChannel2",
-                    new RendererException("Failed inside DrawChannel2", exc));
-            } else {
-                throw exc;
-            }
-        }
-    }
-}