001package armyc2.c5isr.JavaTacticalRenderer;
002
003import static armyc2.c5isr.JavaTacticalRenderer.clsUtility.GetLinetypeFromString;
004
005import android.graphics.Bitmap;
006
007import java.util.ArrayList;
008import java.util.HashMap;
009import java.util.Map;
010
011import armyc2.c5isr.JavaLineArray.Channels;
012import armyc2.c5isr.JavaLineArray.POINT2;
013import armyc2.c5isr.JavaLineArray.Shape2;
014import armyc2.c5isr.JavaLineArray.TacticalLines;
015import armyc2.c5isr.JavaLineArray.arraysupport;
016import armyc2.c5isr.JavaLineArray.lineutility;
017import armyc2.c5isr.graphics2d.AffineTransform;
018import armyc2.c5isr.graphics2d.BasicStroke;
019import armyc2.c5isr.graphics2d.BufferedImage;
020import armyc2.c5isr.graphics2d.Font;
021import armyc2.c5isr.graphics2d.FontMetrics;
022import armyc2.c5isr.graphics2d.FontRenderContext;
023import armyc2.c5isr.graphics2d.Graphics2D;
024import armyc2.c5isr.graphics2d.Line2D;
025import armyc2.c5isr.graphics2d.PathIterator;
026import armyc2.c5isr.graphics2d.Point;
027import armyc2.c5isr.graphics2d.Point2D;
028import armyc2.c5isr.graphics2d.Polygon;
029import armyc2.c5isr.graphics2d.Rectangle2D;
030import armyc2.c5isr.graphics2d.Shape;
031import armyc2.c5isr.graphics2d.TextLayout;
032import armyc2.c5isr.renderer.SinglePointRenderer;
033import armyc2.c5isr.renderer.utilities.Color;
034import armyc2.c5isr.renderer.utilities.EntityCode;
035import armyc2.c5isr.renderer.utilities.ErrorLogger;
036import armyc2.c5isr.renderer.utilities.GENCLookup;
037import armyc2.c5isr.renderer.utilities.IPointConversion;
038import armyc2.c5isr.renderer.utilities.ImageInfo;
039import armyc2.c5isr.renderer.utilities.MilStdAttributes;
040import armyc2.c5isr.renderer.utilities.Modifiers;
041import armyc2.c5isr.renderer.utilities.RendererException;
042import armyc2.c5isr.renderer.utilities.RendererSettings;
043import armyc2.c5isr.renderer.utilities.RendererUtilities;
044import armyc2.c5isr.renderer.utilities.ShapeInfo;
045import armyc2.c5isr.renderer.utilities.SymbolID;
046
047/**
048 * This class handles everything having to do with text for a
049 * tactical graphic. Note: labels are handled the same as text modifiers.
050 * 
051 */
052public class Modifier2 {
053    private POINT2[] textPath;
054    private String textID;
055    private String featureID;
056    private String text;
057
058    private Bitmap image;
059    private int iteration;
060    private int justify;
061    private int type;
062    private double lineFactor;
063    private static final String _className = "Modifier2";
064    @Deprecated
065    private boolean isIntegral = false;
066    private boolean fitsMBR = true;
067
068    Modifier2() {
069        textPath = new POINT2[2];
070    }
071
072    /**
073     * Put label next to pt0 on opposite side of line
074     */
075    private static final int toEnd = 1; // Put next to pt0 on opposite side of line
076    /**
077     * put label between both point and apply the angle between the two points
078     */
079    private static final int aboveMiddle = 2;    //use both points
080    /**
081     * one point, label always right-side-up
082     */
083    private static final int area = 3;   //use one point
084    /**
085     * one point, label always right-side-up
086     */
087    private static final int screen = 4;   //use one point, screen, cover, guard points
088    /**
089     * Put next to pt0, but above the line
090     */
091    private static final int aboveEnd = 5; // Put next to pt0 on line
092    /**
093     * between both points but perpendicular rotation of text
094     */
095    private static final int aboveMiddlePerpendicular = 6; //use both points
096    /**
097     * For Moving and Halted Convoy.
098     * At start of line behind arrowhead
099     */
100    private static final int aboveStartInside = 7; //place at the start inside the shape
101    /**
102     * For Moving and Halted Convoy.
103     * At back of line inside arrow shape.
104     */
105    private static final int aboveEndInside = 8;  //place at the end inside the shape
106    /**
107     * Image Modifier, uses one point
108     */
109    private static final int areaImage = 9;   //use one point
110    private static double fillAlphaCanObscureText = 50d;
111
112    private static boolean DoublesBack(POINT2 pt0, POINT2 pt1, POINT2 pt2) {
113        boolean result = true;
114        try {
115            double theta1 = Math.atan2(pt2.y - pt1.y, pt2.x - pt1.x);
116            double theta0 = Math.atan2(pt0.y - pt1.y, pt0.x - pt1.x);
117            double beta = Math.abs(theta0 - theta1);
118            if (beta > 0.1) {
119                result = false;
120            }
121
122        } catch (Exception exc) {
123            ErrorLogger.LogException(_className, "DoublesBack",
124                    new RendererException("Failed inside DoublesBack", exc));
125        }
126        return result;
127    }
128
129    /**
130     * Returns a generic label for the symbol per Mil-Std-2525
131     *
132     * @param tg
133     * @return
134     */
135    private static String GetCenterLabel(TGLight tg) {
136        String label = "";
137        try {
138            switch (tg.get_LineType()) {
139                case TacticalLines.SHIP_AOI_RECTANGULAR:
140                case TacticalLines.SHIP_AOI_CIRCULAR:
141                    label = "AOI";
142                    break;
143                case TacticalLines.DEFENDED_AREA_RECTANGULAR:
144                case TacticalLines.DEFENDED_AREA_CIRCULAR:
145                    label = "DA";
146                    break;
147                case TacticalLines.NOTACK:
148                    label = "N";
149                    break;
150                case TacticalLines.LAUNCH_AREA:
151                    label = "LA";
152                    break;
153                case TacticalLines.SL:
154                    label = "SL";
155                    break;
156                case TacticalLines.TC:
157                    label = "TC";
158                    break;
159                case TacticalLines.AARROZ:
160                    label = "AARROZ";
161                    break;
162                case TacticalLines.UAROZ:
163                    label = "UAROZ";
164                    break;
165                case TacticalLines.WEZ:
166                    label = "WEZ";
167                    break;
168                case TacticalLines.FEZ:
169                    label = "FEZ";
170                    break;
171                case TacticalLines.JEZ:
172                    label = "JEZ";
173                    break;
174                case TacticalLines.IFF_OFF:
175                    label = "IFF OFF";
176                    break;
177                case TacticalLines.IFF_ON:
178                    label = "IFF ON";
179                    break;
180                case TacticalLines.BCL_REVD:
181                case TacticalLines.BCL:
182                    label = "BCL";
183                    break;
184                case TacticalLines.ICL:
185                    label = "ICL";
186                    break;
187                case TacticalLines.FEBA:
188                    label = "FEBA";
189                    break;
190                case TacticalLines.BDZ:
191                    label = "BDZ";
192                    break;
193                case TacticalLines.JTAA:
194                    label = "JTAA";
195                    break;
196                case TacticalLines.SAA:
197                    label = "SAA";
198                    break;
199                case TacticalLines.SGAA:
200                    label = "SGAA";
201                    break;
202                case TacticalLines.ASSAULT:
203                    label = "ASLT";
204                    break;
205                case TacticalLines.SAAFR:
206                    label = "SAAFR";
207                    break;
208                case TacticalLines.AC:
209                    label = "AC";
210                    break;
211                case TacticalLines.SECURE:
212                case TacticalLines.SEIZE:
213                    label = "S";
214                    break;
215                case TacticalLines.EVACUATE:
216                    label = "E";
217                    break;
218                case TacticalLines.TURN:
219                    label = "T";
220                    break;
221                case TacticalLines.RETAIN:
222                    label = "R";
223                    break;
224                case TacticalLines.PENETRATE:
225                    label = "P";
226                    break;
227                case TacticalLines.OCCUPY:
228                    label = "O";
229                    break;
230                case TacticalLines.ISOLATE:
231                    label = "I";
232                    break;
233                case TacticalLines.AREA_DEFENSE:
234                    label = "AD";
235                    break;
236                case TacticalLines.FIX:
237                    label = "F";
238                    break;
239                case TacticalLines.DISRUPT:
240                    label = "D";
241                    break;
242                case TacticalLines.CAPTURE:
243                case TacticalLines.CANALIZE:
244                case TacticalLines.CLEAR:
245                case TacticalLines.CONTROL:
246                    label = "C";
247                    break;
248                case TacticalLines.BREACH:
249                case TacticalLines.BYPASS:
250                    label = "B";
251                    break;
252                case TacticalLines.CORDONKNOCK:
253                    label = "C/K";
254                    break;
255                case TacticalLines.CORDONSEARCH:
256                    label = "C/S";
257                    break;
258                case TacticalLines.UXO:
259                    label = "UXO";
260                    break;
261                case TacticalLines.RETIRE:
262                    label = "R";
263                    break;
264                case TacticalLines.PURSUIT:
265                    label = "P";
266                    break;
267                case TacticalLines.ENVELOPMENT:
268                    label = "E";
269                    break;
270                case TacticalLines.FPOL:
271                    label = "P(F)";
272                    break;
273                case TacticalLines.RPOL:
274                    label = "P(R)";
275                    break;
276                case TacticalLines.BRDGHD:
277                case TacticalLines.BRDGHD_GE:
278                    if (SymbolID.getVersion(tg.get_SymbolId()) >= SymbolID.Version_2525E)
279                        label = "BL";
280                    else
281                        label = "B";
282                    break;
283                case TacticalLines.HOLD:
284                case TacticalLines.HOLD_GE:
285                    //label="HOLDING LINE";
286                    label = "HL";
287                    break;
288                case TacticalLines.PL:
289                    label = "PL";
290                    break;
291                case TacticalLines.LL:
292                    label = "LL";
293                    break;
294                case TacticalLines.LOCATE:
295                    label = "LOC";
296                    break;
297                case TacticalLines.EWL:
298                    label = "EWL";
299                    break;
300                case TacticalLines.SCREEN:
301                    label = "S";
302                    break;
303                case TacticalLines.COVER:
304                    label = "C";
305                    break;
306                case TacticalLines.GUARD:
307                    label = "G";
308                    break;
309                case TacticalLines.RIP:
310                    label = "RIP";
311                    break;
312                case TacticalLines.MOBILE_DEFENSE:
313                    label = "MD";
314                    break;
315                case TacticalLines.DEMONSTRATE:
316                    label = "DEM";
317                    break;
318                case TacticalLines.WITHDRAW:
319                    label = "W";
320                    break;
321                case TacticalLines.DISENGAGE:
322                    label = "DIS";
323                    break;
324                case TacticalLines.WDRAWUP:
325                    label = "WP";
326                    break;
327                case TacticalLines.CATK:
328                case TacticalLines.CATKBYFIRE:
329                    label = "CATK";
330                    break;
331                case TacticalLines.FLOT:
332                    label = "FLOT";
333                    break;
334                case TacticalLines.LC:
335                    label = "LC";
336                    break;
337                case TacticalLines.ASSY:
338                    label = "AA";
339                    break;
340                case TacticalLines.EA:
341                    label = "EA";
342                    break;
343                case TacticalLines.DZ:
344                    label = "DZ";
345                    break;
346                case TacticalLines.EZ:
347                    label = "EZ";
348                    break;
349                case TacticalLines.LZ:
350                    label = "LZ";
351                    break;
352                case TacticalLines.LAA:
353                    label = "LAA";
354                    break;
355                case TacticalLines.PZ:
356                    label = "PZ";
357                    break;
358                case TacticalLines.MRR:
359                    label = "MRR";
360                    break;
361                case TacticalLines.SC:
362                    label = "SC";
363                    break;
364                case TacticalLines.LLTR:
365                    label = "LLTR";
366                    break;
367                case TacticalLines.ROZ:
368                    label = "ROZ";
369                    break;
370                case TacticalLines.FAADZ:
371                    label = "SHORADEZ";
372                    break;
373                case TacticalLines.HIDACZ:
374                    label = "HIDACZ";
375                    break;
376                case TacticalLines.MEZ:
377                    label = "MEZ";
378                    break;
379                case TacticalLines.LOMEZ:
380                    label = "LOMEZ";
381                    break;
382                case TacticalLines.HIMEZ:
383                    label = "HIMEZ";
384                    break;
385                case TacticalLines.WFZ_REVD:
386                case TacticalLines.WFZ:
387                    label = "WFZ";
388                    break;
389                case TacticalLines.MINED:
390                case TacticalLines.FENCED:
391                    label = "M";
392                    break;
393                case TacticalLines.PNO:
394                    label = "(P)";
395                    break;
396                case TacticalLines.OBJ:
397                    label = "OBJ";
398                    break;
399                case TacticalLines.NAI:
400                    label = "NAI";
401                    break;
402                case TacticalLines.TAI:
403                    label = "TAI";
404                    break;
405                case TacticalLines.BASE_CAMP_REVD:
406                case TacticalLines.BASE_CAMP:
407                    label = "BC";
408                    break;
409                case TacticalLines.GUERILLA_BASE_REVD:
410                case TacticalLines.GUERILLA_BASE:
411                    label = "GB";
412                    break;
413                case TacticalLines.LINTGTS:
414                    label = "SMOKE";
415                    break;
416                case TacticalLines.FPF:
417                    label = "FPF";
418                    break;
419                case TacticalLines.ATKPOS:
420                    label = "ATK";
421                    break;
422                case TacticalLines.FCL:
423                    label = "FCL";
424                    break;
425                case TacticalLines.LOA:
426                    label = "LOA";
427                    break;
428                case TacticalLines.LOD:
429                    label = "LD";
430                    break;
431                case TacticalLines.PLD:
432                    label = "PLD";
433                    break;
434                case TacticalLines.DELAY:
435                case TacticalLines.DENY:
436                    label = "D";
437                    break;
438                case TacticalLines.RELEASE:
439                    label = "RL";
440                    break;
441                case TacticalLines.HOL:
442                    label = "HOL";
443                    break;
444                case TacticalLines.BHL:
445                    label = "BHL";
446                    break;
447                case TacticalLines.SMOKE:
448                    label = "SMOKE";
449                    break;
450                case TacticalLines.NFL:
451                    label = "NFL";
452                    break;
453                case TacticalLines.MFP:
454                    label = "MFP";
455                    break;
456                case TacticalLines.FSCL:
457                    label = "FSCL";
458                    break;
459                case TacticalLines.CFL:
460                    label = "CFL";
461                    break;
462                case TacticalLines.RFL:
463                    label = "RFL";
464                    break;
465                case TacticalLines.AO:
466                    label = "AO";
467                    break;
468                case TacticalLines.BOMB:
469                    label = "BOMB";
470                    break;
471                case TacticalLines.TGMF:
472                    label = "TGMF";
473                    break;
474                case TacticalLines.FSA:
475                    label = "FSA";
476                    break;
477                case TacticalLines.FSA_CIRCULAR:
478                case TacticalLines.FSA_RECTANGULAR:
479                    label = "FSA";
480                    break;
481                case TacticalLines.ACA:
482                case TacticalLines.ACA_CIRCULAR:
483                case TacticalLines.ACA_RECTANGULAR:
484                    label = "ACA";
485                    break;
486                case TacticalLines.FFA:
487                case TacticalLines.FFA_CIRCULAR:
488                case TacticalLines.FFA_RECTANGULAR:
489                    label = "FFA";
490                    break;
491                case TacticalLines.NFA:
492                case TacticalLines.NFA_CIRCULAR:
493                case TacticalLines.NFA_RECTANGULAR:
494                    label = "NFA";
495                    break;
496                case TacticalLines.RFA:
497                case TacticalLines.RFA_CIRCULAR:
498                case TacticalLines.RFA_RECTANGULAR:
499                    label = "RFA";
500                    break;
501                case TacticalLines.ATI:
502                case TacticalLines.ATI_CIRCULAR:
503                case TacticalLines.ATI_RECTANGULAR:
504                    if (SymbolID.getVersion(tg.get_SymbolId()) >= SymbolID.Version_2525Ech1)
505                        label = "ATIZ";
506                    else
507                        label = "ATI ZONE";
508                    break;
509                case TacticalLines.PAA:
510                case TacticalLines.PAA_CIRCULAR:
511                case TacticalLines.PAA_RECTANGULAR:
512                    label = "PAA";
513                    break;
514                case TacticalLines.CFFZ:
515                case TacticalLines.CFFZ_CIRCULAR:
516                case TacticalLines.CFFZ_RECTANGULAR:
517                    label = "CFF ZONE";
518                    break;
519                case TacticalLines.CFZ:
520                case TacticalLines.CFZ_CIRCULAR:
521                case TacticalLines.CFZ_RECTANGULAR:
522                    label = "CF ZONE";
523                    break;
524                case TacticalLines.SENSOR:
525                case TacticalLines.SENSOR_CIRCULAR:
526                case TacticalLines.SENSOR_RECTANGULAR:
527                    label = "SENSOR ZONE";
528                    break;
529                case TacticalLines.CENSOR:
530                case TacticalLines.CENSOR_CIRCULAR:
531                case TacticalLines.CENSOR_RECTANGULAR:
532                    label = "CENSOR ZONE";
533                    break;
534                case TacticalLines.DA:
535                case TacticalLines.DA_CIRCULAR:
536                case TacticalLines.DA_RECTANGULAR:
537                    label = "DA";
538                    break;
539                case TacticalLines.ZOR:
540                case TacticalLines.ZOR_CIRCULAR:
541                case TacticalLines.ZOR_RECTANGULAR:
542                    label = "ZOR";
543                    break;
544                case TacticalLines.TBA:
545                case TacticalLines.TBA_CIRCULAR:
546                case TacticalLines.TBA_RECTANGULAR:
547                    label = "TBA";
548                    break;
549                case TacticalLines.TVAR:
550                case TacticalLines.TVAR_CIRCULAR:
551                case TacticalLines.TVAR_RECTANGULAR:
552                    label = "TVAR";
553                    break;
554                case TacticalLines.KILLBOXBLUE:
555                case TacticalLines.KILLBOXBLUE_CIRCULAR:
556                case TacticalLines.KILLBOXBLUE_RECTANGULAR:
557                    label = "BKB";
558                    break;
559                case TacticalLines.KILLBOXPURPLE:
560                case TacticalLines.KILLBOXPURPLE_CIRCULAR:
561                case TacticalLines.KILLBOXPURPLE_RECTANGULAR:
562                    label = "PKB";
563                    break;
564                case TacticalLines.MSR:
565                case TacticalLines.MSR_ONEWAY:
566                case TacticalLines.MSR_TWOWAY:
567                case TacticalLines.MSR_ALT:
568                    label = "MSR";
569                    break;
570                case TacticalLines.ASR:
571                case TacticalLines.ASR_ONEWAY:
572                case TacticalLines.ASR_TWOWAY:
573                case TacticalLines.ASR_ALT:
574                    label = "ASR";
575                    break;
576                case TacticalLines.TRAFFIC_ROUTE:
577                case TacticalLines.TRAFFIC_ROUTE_ONEWAY:
578                case TacticalLines.TRAFFIC_ROUTE_ALT:
579                    label = "ROUTE";
580                    break;
581                case TacticalLines.LDLC:
582                    label = "LD/LC";
583                    break;
584                case TacticalLines.AIRHEAD:
585                    label = "AIRHEAD LINE";
586                    break;
587                case TacticalLines.BLOCK:
588                case TacticalLines.BEARING:
589                    label = "B";
590                    break;
591                case TacticalLines.BEARING_J:
592                    label = "J";
593                    break;
594                case TacticalLines.BEARING_RDF:
595                    label = "RDF";
596                    break;
597                case TacticalLines.ELECTRO:
598                case TacticalLines.ESCORT:
599                    label = "E";
600                    break;
601                case TacticalLines.BEARING_EW:
602                    label = "EW";
603                    break;
604                case TacticalLines.ACOUSTIC:
605                case TacticalLines.ACOUSTIC_AMB:
606                    label = "A";
607                    break;
608                case TacticalLines.TORPEDO:
609                    label = "T";
610                    break;
611                case TacticalLines.OPTICAL:
612                    label = "O";
613                    break;
614                case TacticalLines.DHA:
615                    label = "DHA";
616                    break;
617                case TacticalLines.KILL_ZONE:
618                    label = "KILL ZONE";
619                    break;
620                case TacticalLines.FARP:
621                    label = "FARP";
622                    break;
623                case TacticalLines.BSA:
624                    label = "BSA";
625                    break;
626                case TacticalLines.DSA:
627                    label = "DSA";
628                    break;
629                case TacticalLines.CSA:
630                    label = "CSA";
631                    break;
632                case TacticalLines.RSA:
633                    label = "RSA";
634                    break;
635                case TacticalLines.CONTAIN:
636                    label = "C";
637                    break;
638                case TacticalLines.OBSFAREA:
639                    label = "FREE";
640                    break;
641                case TacticalLines.TRIP:
642                    label = "t";
643                    break;
644                case TacticalLines.EXFILTRATION:
645                    label = "EX";
646                    break;
647                case TacticalLines.INFILTRATION:
648                    label = "IN";
649                    break;
650                default:
651                    break;
652            }
653        } catch (Exception exc) {
654            //clsUtility.WriteFile("Error in Modifier2.GetCenterLabel");
655            ErrorLogger.LogException(_className, "GetCenterLabel",
656                    new RendererException("Failed inside GetCenterLabel", exc));
657        }
658        return label;
659    }
660    //non CPOF clients using best fit need these accessors
661
662    public POINT2[] get_TextPath() {
663        return textPath;
664    }
665
666    protected void set_TextPath(POINT2[] value) {
667        textPath = value;
668    }
669
670    @Deprecated
671    protected void set_IsIntegral(boolean value) {
672        isIntegral = value;
673    }
674
675    @Deprecated
676    protected boolean get_IsIntegral() {
677        return isIntegral;
678    }
679
680    private static void AddOffsetModifier(TGLight tg,
681            String text,
682            int type,
683            double lineFactor,
684            int startIndex,
685            int endIndex,
686            double spaces,
687            String rightOrLeft) {
688        if (rightOrLeft == null || tg.Pixels == null || tg.Pixels.size() < 2 || endIndex >= tg.Pixels.size()) {
689            return;
690        }
691
692        POINT2 pt0 = tg.Pixels.get(startIndex);
693        POINT2 pt1 = tg.Pixels.get(endIndex);
694        if (rightOrLeft.equals("left")) {
695            pt0.x -= spaces;
696            pt1.x -= spaces;
697        } else {
698            pt0.x += spaces;
699            pt1.x += spaces;
700        }
701        AddModifier2(tg, text, type, lineFactor, pt0, pt1, false);
702    }
703
704    /**
705     *
706     * @param tg
707     * @param text
708     * @param type
709     * @param lineFactor
710     * @param ptStart
711     * @param ptEnd
712     */
713    private static void AddModifier(TGLight tg,
714            String text,
715            int type,
716            double lineFactor,
717            POINT2 ptStart,
718            POINT2 ptEnd) {
719        if (tg.Pixels == null || tg.Pixels.size() < 2) {
720            return;
721        }
722        AddModifier2(tg, text, type, lineFactor, ptStart, ptEnd, false);
723    }
724
725    private static void AddModifier2(TGLight tg,
726            String text,
727            int type,
728            double lineFactor,
729            POINT2 pt0,
730            POINT2 pt1,
731            boolean isIntegral) {
732        AddModifier2(tg, text, type, lineFactor, pt0, pt1, isIntegral, null);
733    }
734
735    private static void AddModifier2(TGLight tg,
736            String text,
737            int type,
738            double lineFactor,
739            POINT2 pt0,
740            POINT2 pt1,
741            boolean isIntegral,
742            String modifierType) {
743        try {
744            if (text == null || text.equals("")) {
745                return;
746            }
747
748            Modifier2 modifier = new Modifier2();
749            modifier.set_IsIntegral(isIntegral);
750            modifier.text = text;
751            modifier.type = type;
752            modifier.lineFactor = lineFactor;
753            modifier.textPath[0] = pt0;
754            modifier.textPath[1] = pt1;
755            modifier.textID = modifierType;
756            tg.modifiers.add(modifier);
757        } catch (Exception exc) {
758            ErrorLogger.LogException(_className, "AddModifier",
759                    new RendererException("Failed inside AddModifier", exc));
760        }
761    }
762
763    private static void AddIntegralModifier(TGLight tg,
764            String text,
765            int type,
766            double lineFactor,
767            int startIndex,
768            int endIndex) {
769        AddIntegralModifier(tg, text, type, lineFactor, startIndex, endIndex, true);
770    }
771
772    private static void AddIntegralModifier(TGLight tg,
773            String text,
774            int type,
775            double lineFactor,
776            int startIndex,
777            int endIndex,
778            Boolean isIntegral) {
779        AddIntegralModifier(tg, text, type, lineFactor, startIndex, endIndex, isIntegral, null);
780    }
781
782    private static void AddIntegralModifier(TGLight tg,
783            String text,
784            int type,
785            double lineFactor,
786            int startIndex,
787            int endIndex,
788            Boolean isIntegral,
789            String modifierType) {
790        if (tg.Pixels == null || tg.Pixels.isEmpty() || endIndex >= tg.Pixels.size()) {
791            return;
792        }
793        AddIntegralAreaModifier(tg, text, type, lineFactor, tg.Pixels.get(startIndex), tg.Pixels.get(endIndex), isIntegral, modifierType);
794    }
795
796    /**
797     * Creates and adds center modifiers for generic areas
798     *
799     * @param tg
800     * @param text
801     * @param type
802     * @param lineFactor
803     * @param pt0
804     * @param pt1
805     */
806    private static void AddAreaModifier(TGLight tg,
807            String text,
808            int type,
809            double lineFactor,
810            POINT2 pt0,
811            POINT2 pt1) {
812        AddIntegralAreaModifier(tg, text, type, lineFactor, pt0, pt1, true);
813    }
814
815    /**
816     * sets modifier.textId to the modifier type, e.g. label, T, T1, etc.
817     *
818     * @param tg
819     * @param text
820     * @param type
821     * @param lineFactor
822     * @param pt0
823     * @param pt1
824     * @param modifierType
825     */
826    private static void AddAreaModifier(TGLight tg,
827            String text,
828            int type,
829            double lineFactor,
830            POINT2 pt0,
831            POINT2 pt1,
832            String modifierType) {
833        AddIntegralAreaModifier(tg, text, type, lineFactor, pt0, pt1, true, modifierType);
834    }
835
836    private static void AddIntegralAreaModifier(TGLight tg,
837            String text,
838            int type,
839            double lineFactor,
840            POINT2 pt0,
841            POINT2 pt1,
842            Boolean isIntegral) {
843        AddIntegralAreaModifier(tg,text,type,lineFactor,pt0, pt1, isIntegral, null);
844    }
845
846    private static void AddIntegralAreaModifier(TGLight tg,
847            Bitmap image,
848            int type,
849            double lineFactor,
850            POINT2 pt0,
851            POINT2 pt1,
852            Boolean isIntegral) {
853        try {
854            if (image == null || image.equals("")) {
855                return;
856            }
857
858            Modifier2 modifier = new Modifier2();
859            modifier.set_IsIntegral(isIntegral);
860            modifier.image = image;
861            if (image == null || image.equals("")) {
862                return;
863            }
864
865            if (pt0 == null || pt1 == null) {
866                return;
867            }
868
869            modifier.type = type;
870            modifier.lineFactor = lineFactor;
871            modifier.textPath[0] = pt0;
872            modifier.textPath[1] = pt1;
873            tg.modifiers.add(modifier);
874        } catch (Exception exc) {
875            ErrorLogger.LogException(_className, "AddAreaModifier",
876                    new RendererException("Failed inside AddAreaModifier", exc));
877        }
878    }
879
880    private static void AddIntegralAreaModifier(TGLight tg,
881            String text,
882            int type,
883            double lineFactor,
884            POINT2 pt0,
885            POINT2 pt1,
886            Boolean isIntegral,
887            String modifierType) {
888        if (pt0 == null || pt1 == null) {
889            return;
890        }
891        AddModifier2(tg, text, type, lineFactor, pt0, pt1, isIntegral, modifierType);
892    }
893
894    /**
895     * Returns symbol MBR. Assumes points have been initialized with value of
896     * 0th point
897     *
898     * @param tg the tactical graphic object
899     * @param ptUl OUT - MBR upper left
900     * @param ptUr OUT - MBR upper right
901     * @param ptLr OUT - MBR lower right
902     * @param ptLl OUT - MBR lower left
903     */
904    public static void GetMBR(TGLight tg,
905            POINT2 ptUl,
906            POINT2 ptUr,
907            POINT2 ptLr,
908            POINT2 ptLl) {
909        try {
910            int j = 0;
911            double x = 0;
912            double y = 0;
913            ptUl.x = tg.Pixels.get(0).x;
914            ptUl.y = tg.Pixels.get(0).y;
915            ptUr.x = tg.Pixels.get(0).x;
916            ptUr.y = tg.Pixels.get(0).y;
917            ptLl.x = tg.Pixels.get(0).x;
918            ptLl.y = tg.Pixels.get(0).y;
919            ptLr.x = tg.Pixels.get(0).x;
920            ptLr.y = tg.Pixels.get(0).y;
921            int n = tg.Pixels.size();
922            //for (j = 1; j < tg.Pixels.size(); j++) 
923            for (j = 1; j < n; j++) {
924                x = tg.Pixels.get(j).x;
925                y = tg.Pixels.get(j).y;
926                if (x < ptLl.x) {
927                    ptLl.x = x;
928                    ptUl.x = x;
929                }
930                if (x > ptLr.x) {
931                    ptLr.x = x;
932                    ptUr.x = x;
933                }
934                if (y > ptLl.y) {
935                    ptLl.y = y;
936                    ptLr.y = y;
937                }
938                if (y < ptUl.y) {
939                    ptUl.y = y;
940                    ptUr.y = y;
941                }
942            }
943        } catch (Exception exc) {
944            ErrorLogger.LogException(_className, "GetMBR",
945                    new RendererException("Failed inside GetMBR", exc));
946        }
947    }
948
949    /**
950     * Tests segment of a Boundary
951     *
952     * @param tg
953     * @param g2d
954     * @param middleSegment
955     * @return
956     */
957    private static boolean GetBoundarySegmentTooShort(TGLight tg,
958            Graphics2D g2d,
959            int middleSegment) {
960        boolean lineTooShort = false;
961        try {
962            //int middleSegment = tg.Pixels.size() / 2 - 1;
963            g2d.setFont(tg.get_Font());
964            FontMetrics metrics = g2d.getFontMetrics();
965            String echelonSymbol = null;
966            int stringWidthEchelonSymbol = 0;
967
968            POINT2 pt0 = tg.Pixels.get(middleSegment);
969            POINT2 pt1 = tg.Pixels.get(middleSegment + 1);
970            double dist = lineutility.CalcDistanceDouble(pt0, pt1);
971
972            echelonSymbol = tg.get_EchelonSymbol();
973
974            if (echelonSymbol != null) {
975                stringWidthEchelonSymbol = metrics.stringWidth(echelonSymbol);
976            }
977
978            int tWidth = 0, t1Width = 0;
979            if (tg.get_Name() != null && !tg.get_Name().isEmpty()) {
980                tWidth = metrics.stringWidth(tg.get_Name());
981            }
982            if (tg.get_T1() != null && !tg.get_T1().isEmpty()) {
983                t1Width = metrics.stringWidth(tg.get_T1());
984            }
985
986            int totalWidth = stringWidthEchelonSymbol;
987            if (totalWidth < tWidth) {
988                totalWidth = tWidth;
989            }
990            if (totalWidth < t1Width) {
991                totalWidth = t1Width;
992            }
993
994            switch (tg.get_LineType()) {
995                case TacticalLines.BOUNDARY:
996                    if (dist < 1.25 * (totalWidth)) {
997                        lineTooShort = true;
998                    }
999                    break;
1000                default:
1001                    break;
1002            }
1003        } catch (Exception exc) {
1004            ErrorLogger.LogException(_className, "GetBoundaryLineTooShort",
1005                    new RendererException("Failed inside GetBoundaryLineTooShort", exc));
1006        }
1007        return lineTooShort;
1008    }
1009
1010    /**
1011     * Handles the line breaks for Boundary and Engineer Work Line
1012     *
1013     * @param tg
1014     * @param g2d
1015     */
1016    private static void AddBoundaryModifiers(TGLight tg,
1017            Graphics2D g2d,
1018            Object clipBounds) {
1019        try {
1020            int j = 0;
1021            double csFactor = 1d;
1022            Boolean foundSegment = false;
1023            POINT2 pt0 = null, pt1 = null, ptLast = null;
1024            double TLineFactor = 0, T1LineFactor = 0;
1025            Boolean lineTooShort = false;
1026            String countryCode = "";
1027            if(!tg.get_AS().equals("")) {
1028                countryCode = " (" + tg.get_AS() + ")";
1029            }
1030            if (tg.get_Client().equals("cpof3d")) {
1031                csFactor = 0.85d;
1032            }
1033
1034            int middleSegment = getVisibleMiddleSegment(tg, clipBounds);
1035            //for (j = 0; j < tg.Pixels.size() - 1; j++) {
1036            for (j = middleSegment; j == middleSegment; j++) {
1037                /* if (tg.get_Client().equalsIgnoreCase("ge")) {
1038                    if (j != middleSegment) {
1039                        continue;
1040                    }
1041                }*/
1042
1043                pt0 = tg.Pixels.get(j);
1044                pt1 = tg.Pixels.get(j + 1);
1045                if (pt0.x < pt1.x) {
1046                    TLineFactor = -1.3;
1047                    T1LineFactor = 1;
1048                } else if (pt0.x == pt1.x) {
1049                    if (pt1.y < pt0.y) {
1050                        TLineFactor = -1;
1051                        T1LineFactor = 1;
1052                    } else {
1053                        TLineFactor = 1;
1054                        T1LineFactor = -1;
1055                    }
1056                } else {
1057                    TLineFactor = 1;
1058                    T1LineFactor = -1.3;
1059                }
1060                //is the segment too short?
1061                lineTooShort = GetBoundarySegmentTooShort(tg, g2d, j);
1062
1063                if (lineTooShort == false) {
1064                    foundSegment = true;
1065                    AddIntegralModifier(tg, tg.get_Name() + countryCode, aboveMiddle, TLineFactor * csFactor, j, j + 1, true);
1066                    //the echelon symbol
1067                    if (tg.get_EchelonSymbol() != null && !tg.get_EchelonSymbol().equals("")) {
1068                        AddIntegralModifier(tg, tg.get_EchelonSymbol(), aboveMiddle, -0.20 * csFactor, j, j + 1, true);
1069                    }
1070                    //the T1 modifier
1071                    AddIntegralModifier(tg, tg.get_T1(), aboveMiddle, T1LineFactor * csFactor, j, j + 1, true);
1072                }
1073            }//end for loop
1074            if (foundSegment == false) {
1075                pt0 = new POINT2();
1076                pt1 = new POINT2();
1077                // Get boundary middle segment
1078                final String echelonSymbol = tg.get_EchelonSymbol();
1079                final FontMetrics metrics = g2d.getFontMetrics();
1080                double modDist = 0;
1081
1082                if (echelonSymbol != null) {
1083                    modDist = 1.5 * metrics.stringWidth(echelonSymbol);
1084                }
1085
1086                final double segDist = lineutility.CalcDistanceDouble(tg.Pixels.get(middleSegment), tg.Pixels.get(middleSegment + 1));
1087
1088                g2d.setFont(tg.get_Font());
1089                POINT2 midpt = lineutility.MidPointDouble(tg.Pixels.get(middleSegment), tg.Pixels.get(middleSegment + 1), 0);
1090                POINT2 ptTemp = null;
1091                if (segDist < modDist) {
1092                    ptTemp = lineutility.ExtendAlongLineDouble(midpt, tg.Pixels.get(middleSegment), modDist / 2);
1093                    pt0.x = ptTemp.x;
1094                    pt0.y = ptTemp.y;
1095                    ptTemp = lineutility.ExtendAlongLineDouble(midpt, tg.Pixels.get(middleSegment + 1), modDist / 2);
1096                } else {
1097                    ptTemp = tg.Pixels.get(middleSegment);
1098                    pt0.x = ptTemp.x;
1099                    pt0.y = ptTemp.y;
1100                    ptTemp = tg.Pixels.get(middleSegment + 1);
1101                }
1102                pt1.x = ptTemp.x;
1103                pt1.y = ptTemp.y;
1104
1105                AddIntegralModifier(tg, tg.get_Name() + countryCode, aboveMiddle, TLineFactor * csFactor, middleSegment, middleSegment + 1, true);
1106                //the echelon symbol
1107                if (echelonSymbol != null && !echelonSymbol.equals("")) {
1108                    AddIntegralModifier(tg, echelonSymbol, aboveMiddle, -0.2020 * csFactor, middleSegment, middleSegment + 1, true);
1109                }
1110                //the T1 modifier
1111                AddIntegralModifier(tg, tg.get_T1(), aboveMiddle, T1LineFactor * csFactor, middleSegment, middleSegment + 1, true);
1112            }//end if foundSegment==false
1113        } catch (Exception exc) {
1114            ErrorLogger.LogException(_className, "AddBoundaryModifiers",
1115                    new RendererException("Failed inside AddBoundaryModifiers", exc));
1116        }
1117    }
1118
1119    /**
1120     * added for USAS
1121     *
1122     * @param tg
1123     * @param metrics
1124     * @deprecated
1125     */
1126    private static void AddNameAboveDTG(TGLight tg, FontMetrics metrics) {
1127        try {
1128            double csFactor = 1;
1129            if (tg.get_Client().equals("cpof3d")) {
1130                csFactor = 0.667;
1131            }
1132            String label = GetCenterLabel(tg);
1133            POINT2 pt0 = new POINT2(tg.Pixels.get(0));
1134            POINT2 pt1 = new POINT2(tg.Pixels.get(1));
1135            int lastIndex = tg.Pixels.size() - 1;
1136            int nextToLastIndex = tg.Pixels.size() - 2;
1137            POINT2 ptLast = new POINT2(tg.Pixels.get(lastIndex));
1138            POINT2 ptNextToLast = new POINT2(tg.Pixels.get(nextToLastIndex));
1139            shiftModifierPath(tg, pt0, pt1, ptLast, ptNextToLast);
1140            double stringWidth = metrics.stringWidth(label + " " + tg.get_Name());
1141            AddIntegralAreaModifier(tg, label + " " + tg.get_Name(), toEnd, 0, pt0, pt1, false);
1142            pt1 = lineutility.ExtendAlongLineDouble(tg.Pixels.get(0), tg.Pixels.get(1), -1.5 * stringWidth);
1143            AddModifier2(tg, tg.get_DTG(), aboveMiddle, 0.7 * csFactor, pt0, pt1, false);
1144            AddModifier2(tg, tg.get_DTG1(), aboveMiddle, 1.7 * csFactor, pt0, pt1, false);
1145            AddIntegralAreaModifier(tg, label + " " + tg.get_Name(), toEnd, 0, ptLast, ptNextToLast, false);
1146            pt0 = tg.Pixels.get(lastIndex);
1147            pt1 = lineutility.ExtendAlongLineDouble(tg.Pixels.get(lastIndex), tg.Pixels.get(nextToLastIndex), -1.5 * stringWidth);
1148            AddModifier2(tg, tg.get_DTG(), aboveMiddle, 0.7 * csFactor, pt0, pt1, false);
1149            AddModifier2(tg, tg.get_DTG1(), aboveMiddle, 1.7 * csFactor, pt0, pt1, false);
1150        } catch (Exception exc) {
1151            ErrorLogger.LogException(_className, "AddNameAboveDTG",
1152                    new RendererException("Failed inside AddNameAboveDTG", exc));
1153        }
1154    }
1155
1156    /**
1157     * shifts the path for modifiers that use toEnd to prevent vertical paths
1158     *
1159     * @param tg
1160     * @param pt0
1161     * @param pt1
1162     * @param ptLast
1163     * @param ptNextToLast
1164     */
1165    private static void shiftModifierPath(TGLight tg,
1166            POINT2 pt0,
1167            POINT2 pt1,
1168            POINT2 ptLast,
1169            POINT2 ptNextToLast) {
1170        try {
1171            POINT2 p0 = null, p1 = null;
1172            double last = -1.0;
1173            switch (tg.get_LineType()) {
1174                case TacticalLines.BOUNDARY:
1175                    for (int j = 0; j < tg.Pixels.size() - 1; j++) {
1176                        p0 = tg.Pixels.get(j);
1177                        p1 = tg.Pixels.get(j + 1);
1178                        //if(p0.x==p1.x)
1179                        if (Math.abs(p0.x - p1.x) < 1) {
1180                            p1.x += last;
1181                            last = -last;
1182                        }
1183                    }
1184                    break;
1185                case TacticalLines.PDF:
1186                case TacticalLines.PL:
1187                case TacticalLines.DECISION_LINE:
1188                case TacticalLines.FEBA:
1189                case TacticalLines.LOA:
1190                case TacticalLines.LOD:
1191                case TacticalLines.RELEASE:
1192                case TacticalLines.HOL:
1193                case TacticalLines.BHL:
1194                case TacticalLines.LDLC:
1195                case TacticalLines.LL:
1196                case TacticalLines.EWL:
1197                case TacticalLines.FCL:
1198                case TacticalLines.PLD:
1199                case TacticalLines.NFL:
1200                case TacticalLines.FLOT:
1201                case TacticalLines.LC:
1202                case TacticalLines.HOLD:
1203                case TacticalLines.BRDGHD:
1204                case TacticalLines.HOLD_GE:
1205                case TacticalLines.BRDGHD_GE:
1206                    //if (pt0 != null && pt1 != null && pt0.x == pt1.x) 
1207                    if (pt0 != null && pt1 != null && Math.abs(pt0.x - pt1.x) < 1) {
1208                        pt1.x += 1;
1209                    }
1210                    //if (ptLast != null && ptNextToLast != null && ptNextToLast.x == ptLast.x) 
1211                    if (ptLast != null && ptNextToLast != null && Math.abs(ptNextToLast.x - ptLast.x) < 1) {
1212                        ptNextToLast.x += 1;
1213                    }
1214                    break;
1215                default:
1216                    return;
1217            }
1218        } catch (Exception exc) {
1219            ErrorLogger.LogException(_className, "shiftModifierPath",
1220                    new RendererException("Failed inside shiftModifierPath", exc));
1221        }
1222    }
1223
1224    /**
1225     * Adds two or four labels on area outline
1226     *
1227     * @param label
1228     * @param tg
1229     * @param twoLabelOnly - when true only two labels are added to line (east and west most segment midpoints)
1230     *                     when false, four labels are added to line (north, south, east and west most segment midpoints)
1231     */
1232    private static void addModifierOnLine(String label, TGLight tg, boolean twoLabelOnly) {
1233        if (label == null || label.isEmpty() || tg.Pixels.isEmpty()) {
1234            return;
1235        }
1236        try {
1237            POINT2 leftPt = lineutility.MidPointDouble(tg.Pixels.get(0), tg.Pixels.get(1), 0);
1238            POINT2 rightPt = lineutility.MidPointDouble(tg.Pixels.get(0), tg.Pixels.get(1), 0);
1239            POINT2 topPt = lineutility.MidPointDouble(tg.Pixels.get(0), tg.Pixels.get(1), 0);
1240            POINT2 bottomPt = lineutility.MidPointDouble(tg.Pixels.get(0), tg.Pixels.get(1), 0);
1241            for (int j = 1; j < tg.Pixels.size() - 1; j++) {
1242                POINT2 midPt = lineutility.MidPointDouble(tg.Pixels.get(j), tg.Pixels.get(j + 1), 0);
1243                if (midPt.x <= leftPt.x) {
1244                    leftPt = midPt;
1245                }
1246                if (midPt.x >= rightPt.x) {
1247                    rightPt = midPt;
1248                }
1249                if (midPt.y <= topPt.y) {
1250                    topPt = midPt;
1251                }
1252                if (midPt.y >= bottomPt.y) {
1253                    bottomPt = midPt;
1254                }
1255            }
1256
1257            if (leftPt != rightPt)
1258                AddAreaModifier(tg, label, aboveMiddle, 0, leftPt, leftPt);
1259            AddAreaModifier(tg, label, aboveMiddle, 0, rightPt, rightPt);
1260            if (!twoLabelOnly) {
1261                if (bottomPt != leftPt && bottomPt != rightPt)
1262                    AddAreaModifier(tg, label, aboveMiddle, 0, bottomPt, bottomPt);
1263                if (topPt != leftPt && topPt != rightPt && topPt != bottomPt)
1264                    AddAreaModifier(tg, label, aboveMiddle, 0, topPt, topPt);
1265            }
1266        } catch (Exception exc) {
1267            ErrorLogger.LogException(_className, "addModifierOnLine",
1268                    new RendererException("Failed inside addModifierOnLine", exc));
1269        }
1270    }
1271
1272    private static void addModifierOnLine(String label, TGLight tg) {
1273        addModifierOnLine(label, tg, false);
1274    }
1275
1276    /**
1277     * Adds N modifier on area outline
1278     */
1279    private static void addNModifier(TGLight tg) {
1280        if (tg.isHostile()) {
1281            addModifierOnLine(tg.get_N(), tg, true);
1282        }
1283    }
1284
1285    private static void addModifierBottomSegment(TGLight tg, String text) {
1286        int index = 0;
1287        double y = tg.Pixels.get(index).y + tg.Pixels.get(index + 1).y;
1288        for (int i = 1; i < tg.Pixels.size() - 1; i++) {
1289            if (tg.Pixels.get(i).y + tg.Pixels.get(i + 1).y > y) {
1290                index = i;
1291                y = tg.Pixels.get(index).y + tg.Pixels.get(index + 1).y;
1292            }
1293        }
1294        AddIntegralModifier(tg, text, aboveMiddle, 0, index, index + 1, false);
1295    }
1296
1297    private static void addModifierTopSegment(TGLight tg, String text) {
1298        int index = 0;
1299        double y = tg.Pixels.get(index).y + tg.Pixels.get(index + 1).y;
1300        for (int i = 1; i < tg.Pixels.size() - 1; i++) {
1301            if (tg.Pixels.get(i).y + tg.Pixels.get(i + 1).y < y) {
1302                index = i;
1303                y = tg.Pixels.get(index).y + tg.Pixels.get(index + 1).y;
1304            }
1305        }
1306        AddIntegralModifier(tg, text, aboveMiddle, 0, index, index + 1, false);
1307    }
1308
1309    private static void addDTG(TGLight tg, int type, double lineFactor1, double lineFactor2, POINT2 pt0, POINT2 pt1, FontMetrics metrics) {
1310        if (pt0 == null || pt1 == null)
1311            return;
1312
1313        double maxDTGWidth;
1314        if (pt0.x == pt1.x && pt0.y == pt1.y) {
1315            POINT2 ptUl = new POINT2(), ptUr = new POINT2(), ptLr = new POINT2(), ptLl = new POINT2();
1316            GetMBR(tg, ptUl, ptUr, ptLr, ptLl);
1317            maxDTGWidth = lineutility.CalcDistanceDouble(ptUl, ptUr);
1318        } else {
1319            maxDTGWidth = lineutility.CalcDistanceDouble(pt0, pt1);
1320        }
1321
1322        String dash = "";
1323        if (tg.get_DTG() != null && tg.get_DTG1() != null && !tg.get_DTG().isEmpty() && !tg.get_DTG1().isEmpty()) {
1324            dash = " - ";
1325        }
1326
1327        String combinedDTG = tg.get_DTG() + dash + tg.get_DTG1();
1328
1329        double stringWidth = metrics.stringWidth(combinedDTG);
1330
1331        /*if (stringWidth < maxDTGWidth) {
1332            // Add on one line
1333            AddModifier(tg, combinedDTG, type, lineFactor1, pt0, pt1);
1334        } else {
1335            // add on two lines
1336            // Use min and max on lineFactors. Always want W1 on top. This fixes when lineFactor < 0 W1 should use lineFactor1
1337            AddModifier(tg, tg.get_DTG() + dash, type, Math.min(lineFactor1, lineFactor2), pt0, pt1);
1338            AddModifier(tg, tg.get_DTG1(), type, Math.max(lineFactor1, lineFactor2), pt0, pt1);
1339        }*///Aways draw DTG! & DTG2 on two lines
1340        AddModifier(tg, tg.get_DTG() + dash, type, Math.min(lineFactor1, lineFactor2), pt0, pt1);
1341        AddModifier(tg, tg.get_DTG1(), type, Math.max(lineFactor1, lineFactor2), pt0, pt1);
1342    }
1343
1344    private static int getVisibleMiddleSegment(TGLight tg, Object clipBounds) {
1345        int middleSegment = -1;
1346        try {
1347            Polygon clipBoundsPoly = null;
1348            Rectangle2D clipRect = null;
1349            boolean useClipRect; // true if clipBounds is Rectangle2D otherwise use clipBoundsPoly
1350            POINT2 pt0 = null, pt1 = null;
1351            double dist = 0;
1352            POINT2 lastPt = null;
1353            long lineType = tg.get_LineType();
1354            //we want the middle segment to be visible
1355            middleSegment = (tg.Pixels.size() + 1) / 2 - 1;
1356
1357            boolean foundVisibleSegment = false;
1358            if (clipBounds == null) {
1359                return middleSegment;
1360            }
1361
1362            if (ArrayList.class.isAssignableFrom(clipBounds.getClass())) {
1363                useClipRect = false;
1364                clipBoundsPoly = new Polygon();
1365                ArrayList<Point2D> clipArray = (ArrayList<Point2D>) clipBounds;
1366                for (int j = 0; j < clipArray.size(); j++) {
1367                    int x = (int) (clipArray.get(j)).getX();
1368                    int y = (int) (clipArray.get(j)).getY();
1369                    clipBoundsPoly.addPoint(x, y);
1370                }
1371            } else if (Rectangle2D.class.isAssignableFrom(clipBounds.getClass())) {
1372                useClipRect = true;
1373                clipRect = (Rectangle2D) clipBounds;
1374            } else {
1375                return middleSegment;
1376            }
1377
1378            //walk through the segments to find the first visible segment from the middle
1379            for (int j = middleSegment; j < tg.Pixels.size() - 1; j++) {
1380                pt0 = tg.Pixels.get(j);
1381                pt1 = tg.Pixels.get(j + 1);
1382                dist = lineutility.CalcDistanceDouble(pt0, pt1);
1383                if (dist < 5) {
1384                    continue;
1385                }
1386                //diagnostic
1387                if (j > 0 && lineType == TacticalLines.BOUNDARY) {
1388                    if (lastPt == null) {
1389                        lastPt = tg.Pixels.get(j - 1);
1390                    }
1391                    if (DoublesBack(lastPt, pt0, pt1)) {
1392                        continue;
1393                    }
1394
1395                    lastPt = null;
1396                }
1397                //if either of the points is within the bound then most of the segment is visible
1398                if (!useClipRect) {
1399                    if (clipBoundsPoly.contains(pt0.x, pt0.y) || clipBoundsPoly.contains(pt1.x, pt1.y)) {
1400                        middleSegment = j;
1401                        foundVisibleSegment = true;
1402                        break;
1403                    }
1404                } else {
1405                    if (clipRect.contains(pt0.x, pt0.y) || clipRect.contains(pt1.x, pt1.y)) {
1406                        middleSegment = j;
1407                        foundVisibleSegment = true;
1408                        break;
1409                    }
1410                }
1411            }
1412
1413            if (!foundVisibleSegment) {
1414                for (int j = middleSegment; j > 0; j--) {
1415                    pt0 = tg.Pixels.get(j);
1416                    pt1 = tg.Pixels.get(j - 1);
1417                    dist = lineutility.CalcDistanceDouble(pt0, pt1);
1418                    if (dist < 5) {
1419                        continue;
1420                    }
1421                    //diagnostic
1422                    if (lineType == TacticalLines.BOUNDARY) {
1423                        if (lastPt == null) {
1424                            lastPt = tg.Pixels.get(j - 1);
1425                        }
1426
1427                        if ( DoublesBack(lastPt, pt0, pt1)) {
1428                            continue;
1429                        }
1430
1431                        lastPt = null;
1432                    }
1433                    //if either of the points is within the bound then most of the segment is visible
1434                    if (!useClipRect) {
1435                        if (clipBoundsPoly.contains(pt0.x, pt0.y) || clipBoundsPoly.contains(pt1.x, pt1.y)) {
1436                            middleSegment = j - 1;
1437                            foundVisibleSegment = true;
1438                            break;
1439                        }
1440                    } else {
1441                        if (clipRect.contains(pt0.x, pt0.y) || clipRect.contains(pt1.x, pt1.y)) {
1442                            middleSegment = j - 1;
1443                            foundVisibleSegment = true;
1444                            break;
1445                        }
1446                    }
1447                }
1448            }
1449
1450            if (!foundVisibleSegment) {
1451                middleSegment = tg.Pixels.size() / 2 - 1;
1452            }
1453        } catch (Exception exc) {
1454            ErrorLogger.LogException(_className, "getMiddleSegment",
1455                    new RendererException("Failed inside getMiddleSegment", exc));
1456        }
1457        return middleSegment;
1458    }
1459
1460    /**
1461     * called repeatedly by RemoveModifiers to remove modifiers which fall
1462     * outside the symbol MBR
1463     *
1464     * @param tg
1465     * @param modifierType
1466     */
1467    private static void removeModifier(TGLight tg,
1468            String modifierType) {
1469        try {
1470            int j = 0;
1471            Modifier2 modifier = null;
1472            int n = tg.Pixels.size();
1473            //for (j = 0; j < tg.modifiers.size(); j++) 
1474            for (j = 0; j < n; j++) {
1475                modifier = tg.modifiers.get(j);
1476
1477                if (modifier.textID == null) {
1478                    continue;
1479                }
1480
1481                if (modifier.textID.equalsIgnoreCase(modifierType)) {
1482                    tg.modifiers.remove(modifier);
1483                    break;
1484                }
1485            }
1486        } catch (Exception exc) {
1487            ErrorLogger.LogException(_className, "removeModifier",
1488                    new RendererException("Failed inside removeModifier", exc));
1489        }
1490    }
1491
1492    /**
1493     * removes text modifiers for CPOF tactical areas which do not fit inside
1494     * the symbol MBR
1495     *
1496     * @param tg
1497     * @param g2d
1498     * @param isTextFlipped true if text is flipped from the last segment
1499     * orientation
1500     * @param iteration the instance count for this modifier
1501     */
1502    public static void RemoveModifiers(TGLight tg,
1503            Graphics2D g2d,
1504            boolean isTextFlipped,
1505            int iteration) {
1506        try {
1507            //CPOF clients only
1508            if (!tg.get_Client().equalsIgnoreCase("cpof2d") && !tg.get_Client().equalsIgnoreCase("cpof3d")) {
1509                return;
1510            }
1511
1512            int j = 0;
1513            Polygon mbrPoly = null;
1514            //if it's a change 1 rectangular area then use the pixels instead of the mbr
1515            //because those use aboveMiddle to build angular text
1516            switch (tg.get_LineType()) {
1517                case TacticalLines.RECTANGULAR:
1518                case TacticalLines.CUED_ACQUISITION:
1519                case TacticalLines.ACA_RECTANGULAR: //aboveMiddle modifiers: slanted text
1520                case TacticalLines.FFA_RECTANGULAR:
1521                case TacticalLines.NFA_RECTANGULAR:
1522                case TacticalLines.RFA_RECTANGULAR:
1523                case TacticalLines.KILLBOXBLUE_RECTANGULAR:
1524                case TacticalLines.KILLBOXPURPLE_RECTANGULAR:
1525                case TacticalLines.FSA_RECTANGULAR:
1526                case TacticalLines.SHIP_AOI_RECTANGULAR:
1527                case TacticalLines.DEFENDED_AREA_RECTANGULAR:
1528                case TacticalLines.ATI_RECTANGULAR:
1529                case TacticalLines.CFFZ_RECTANGULAR:
1530                case TacticalLines.SENSOR_RECTANGULAR:
1531                case TacticalLines.CENSOR_RECTANGULAR:
1532                case TacticalLines.DA_RECTANGULAR:
1533                case TacticalLines.CFZ_RECTANGULAR:
1534                case TacticalLines.ZOR_RECTANGULAR:
1535                case TacticalLines.TBA_RECTANGULAR:
1536                case TacticalLines.TVAR_RECTANGULAR:
1537                case TacticalLines.ACA_CIRCULAR:
1538                case TacticalLines.CIRCULAR:
1539                case TacticalLines.BDZ:
1540                case TacticalLines.FSA_CIRCULAR:
1541                case TacticalLines.NOTACK:
1542                case TacticalLines.ATI_CIRCULAR:
1543                case TacticalLines.CFFZ_CIRCULAR:
1544                case TacticalLines.SENSOR_CIRCULAR:
1545                case TacticalLines.CENSOR_CIRCULAR:
1546                case TacticalLines.DA_CIRCULAR:
1547                case TacticalLines.CFZ_CIRCULAR:
1548                case TacticalLines.ZOR_CIRCULAR:
1549                case TacticalLines.TBA_CIRCULAR:
1550                case TacticalLines.TVAR_CIRCULAR:
1551                case TacticalLines.FFA_CIRCULAR:
1552                case TacticalLines.NFA_CIRCULAR:
1553                case TacticalLines.RFA_CIRCULAR:
1554                case TacticalLines.KILLBOXBLUE_CIRCULAR:
1555                case TacticalLines.KILLBOXPURPLE_CIRCULAR:
1556                    if (tg.modifiers == null || tg.modifiers.isEmpty() || iteration != 1) {
1557                        return;
1558                    }
1559
1560                    mbrPoly = new Polygon();
1561                    int n = tg.Pixels.size();
1562                    //for (j = 0; j < tg.Pixels.size(); j++) 
1563                    for (j = 0; j < n; j++) {
1564                        mbrPoly.addPoint((int) tg.Pixels.get(j).x, (int) tg.Pixels.get(j).y);
1565                    }
1566
1567                    break;
1568                default:    //area modifiers: horizontal text
1569                    if (clsUtility.isClosedPolygon(tg.get_LineType()) == false || iteration != 0) {
1570                        return;
1571                    }
1572                    if (tg.modifiers == null || tg.modifiers.isEmpty()) {
1573                        return;
1574                    }
1575
1576                    mbrPoly = new Polygon();
1577                    int t = tg.Pixels.size();
1578                    //for (j = 0; j < tg.Pixels.size(); j++) 
1579                    for (j = 0; j < t; j++) {
1580                        mbrPoly.addPoint((int) tg.Pixels.get(j).x, (int) tg.Pixels.get(j).y);
1581                    }
1582            }
1583
1584            Font font = null;
1585            font = tg.get_Font();    //might have to change this
1586            if (font == null) {
1587                font = g2d.getFont();
1588            }
1589            g2d.setFont(font);
1590            FontMetrics metrics = g2d.getFontMetrics();
1591
1592            double stringWidth = 0, stringHeight = 0;
1593            boolean wfits = true, w1fits = true, ww1fits = true, hfits = true, h1fits = true, h2fits = true;
1594            Modifier2 modifier = null;
1595            String modifierType = "";
1596            String s = "";
1597            POINT2 pt0 = null, pt1 = null, pt2 = null, pt3 = null, pt4 = null;
1598            double lineFactor = 0;
1599            double x = 0, y = 0;
1600            double x1 = 0, y1 = 0, x2 = 0, y2 = 0;            //logic as follows:
1601            //we have to loop through to determine if each modifiers fits and set its fitsMBR member
1602            //then run a 2nd loop to remove groups of modifiers based on whether any of the others do not fit
1603            //e.g. if W does not fit then remove W and W1 modifiers
1604            int n = tg.modifiers.size();
1605            //for (j = 0; j < tg.modifiers.size(); j++) 
1606            for (j = 0; j < n; j++) {
1607                modifier = tg.modifiers.get(j);
1608                if (modifier.textID == null || modifier.textID.isEmpty()) {
1609                    continue;
1610                }
1611
1612                modifierType = modifier.textID;
1613                lineFactor = modifier.lineFactor;
1614
1615                if (isTextFlipped) {
1616                    lineFactor = -lineFactor;
1617                }
1618
1619                s = modifier.text;
1620                if (s == null || s.equals("")) {
1621                    continue;
1622                }
1623                stringWidth = (double) metrics.stringWidth(s) + 1;
1624                stringHeight = (double) font.getSize();
1625
1626                if (modifier.type == area) {
1627                    pt0 = modifier.textPath[0];
1628                    x1 = pt0.x;
1629                    y1 = pt0.y;
1630                    x = (int) x1 - (int) stringWidth / 2;
1631                    y = (int) y1 + (int) (stringHeight / 2) + (int) (1.25 * lineFactor * stringHeight);
1632                    //pt1 = modifier.textPath[1];
1633                    x2 = (int) x1 + (int) stringWidth / 2;
1634                    y2 = (int) y1 + (int) (stringHeight / 2) + (int) (1.25 * lineFactor * stringHeight);
1635                    if (mbrPoly.contains(x, y) && mbrPoly.contains(x2, y2)) {
1636                        modifier.fitsMBR = true;
1637                    } else {
1638                        modifier.fitsMBR = false;
1639                    }
1640                } else if (modifier.type == aboveMiddle) {
1641                    pt0 = modifier.textPath[0];
1642                    pt1 = modifier.textPath[1];
1643                    //double dist=lineutility.CalcDistanceDouble(pt0, pt1);
1644                    POINT2 ptCenter = lineutility.MidPointDouble(pt0, pt1, 0);
1645                    pt0 = lineutility.ExtendAlongLineDouble(ptCenter, pt0, stringWidth / 2);
1646                    pt1 = lineutility.ExtendAlongLineDouble(ptCenter, pt1, stringWidth / 2);
1647
1648                    if (lineFactor >= 0) {
1649                        pt2 = lineutility.ExtendDirectedLine(ptCenter, pt0, pt0, 3, Math.abs((lineFactor) * stringHeight));
1650                    } else {
1651                        pt2 = lineutility.ExtendDirectedLine(ptCenter, pt0, pt0, 2, Math.abs((lineFactor) * stringHeight));
1652                    }
1653
1654                    if (lineFactor >= 0) {
1655                        pt3 = lineutility.ExtendDirectedLine(ptCenter, pt1, pt1, 3, Math.abs((lineFactor) * stringHeight));
1656                    } else {
1657                        pt3 = lineutility.ExtendDirectedLine(ptCenter, pt1, pt1, 2, Math.abs((lineFactor) * stringHeight));
1658                    }
1659
1660                    x1 = pt2.x;
1661                    y1 = pt2.y;
1662                    x2 = pt3.x;
1663                    y2 = pt3.y;
1664                    if (mbrPoly.contains(x1, y1) && mbrPoly.contains(x2, y2)) {
1665                        modifier.fitsMBR = true;
1666                    } else {
1667                        modifier.fitsMBR = false;
1668                    }
1669                } else {
1670                    modifier.fitsMBR = true;
1671                }
1672            }
1673            n = tg.modifiers.size();
1674            //for (j = 0; j < tg.modifiers.size(); j++) 
1675            for (j = 0; j < n; j++) {
1676                modifier = tg.modifiers.get(j);
1677                if (modifier.textID == null || modifier.textID.isEmpty()) {
1678                    continue;
1679                }
1680
1681                if (modifier.fitsMBR == false) {
1682                    if (modifier.textID.equalsIgnoreCase("W")) {
1683                        wfits = false;
1684                    } else if (modifier.textID.equalsIgnoreCase("W1")) {
1685                        w1fits = false;
1686                    } else if (modifier.textID.equalsIgnoreCase("W+W1")) {
1687                        ww1fits = false;
1688                    } else if (modifier.textID.equalsIgnoreCase("H")) {
1689                        hfits = false;
1690                    } else if (modifier.textID.equalsIgnoreCase("H1")) {
1691                        h1fits = false;
1692                    } else if (modifier.textID.equalsIgnoreCase("H2")) {
1693                        h2fits = false;
1694                    }
1695                }
1696            }
1697            if (wfits == false || w1fits == false) {
1698                removeModifier(tg, "W");
1699                removeModifier(tg, "W1");
1700            }
1701            if (ww1fits == false) {
1702                removeModifier(tg, "W+W1");
1703            }
1704            if (hfits == false || h1fits == false || h2fits == false) {
1705                removeModifier(tg, "H");
1706                removeModifier(tg, "H1");
1707                removeModifier(tg, "H2");
1708            }
1709
1710        } catch (Exception exc) {
1711            ErrorLogger.LogException(_className, "RemoveModifeirs",
1712                    new RendererException("Failed inside RemoveModifiers", exc));
1713        }
1714    }
1715
1716    /**
1717     * Calculates a segment in the pixels middle by length to hold a string.
1718     *
1719     * @param tg
1720     * @param stringWidth
1721     * @param segPt0
1722     * @param segPt1
1723     */
1724    private static void getPixelsMiddleSegment(TGLight tg,
1725            double stringWidth,
1726            POINT2 segPt0,
1727            POINT2 segPt1) {
1728        try {
1729            switch (tg.get_LineType()) {
1730                case TacticalLines.CFL:
1731                    break;
1732                default:
1733                    return;
1734            }
1735            int totalLength = 0;
1736            int j = 0;
1737            double dist = 0;
1738            double mid = 0;
1739            double remainder = 0;
1740            POINT2 pt0 = null, pt1 = null, pt2 = null, pt3 = null;
1741            POINT2 midPt = null;
1742            //first get the total length of all the segments
1743            int n = tg.Pixels.size();
1744            //for (j = 0; j < tg.Pixels.size() - 1; j++) 
1745            for (j = 0; j < n - 1; j++) {
1746                dist = lineutility.CalcDistanceDouble(tg.Pixels.get(j), tg.Pixels.get(j + 1));
1747                totalLength += dist;
1748            }
1749            mid = totalLength / 2;
1750            totalLength = 0;
1751            //walk thru the segments to find the middle
1752            //for (j = 0; j < tg.Pixels.size() - 1; j++) 
1753            for (j = 0; j < n - 1; j++) {
1754                dist = lineutility.CalcDistanceDouble(tg.Pixels.get(j), tg.Pixels.get(j + 1));
1755                totalLength += dist;
1756                if (totalLength >= mid)//current segment contains the middle
1757                {
1758                    remainder = totalLength - mid;
1759                    pt0 = tg.Pixels.get(j);
1760                    pt1 = tg.Pixels.get(j + 1);
1761                    //calculate the pixels mid point
1762                    midPt = lineutility.ExtendAlongLineDouble2(pt1, pt0, remainder);
1763                    pt2 = lineutility.ExtendAlongLineDouble2(midPt, pt0, stringWidth / 2);
1764                    pt3 = lineutility.ExtendAlongLineDouble2(midPt, pt1, stringWidth / 2);
1765                    segPt0.x = pt2.x;
1766                    segPt0.y = pt2.y;
1767                    segPt1.x = pt3.x;
1768                    segPt1.y = pt3.y;
1769                    break;
1770                }
1771            }
1772        } catch (Exception exc) {
1773            ErrorLogger.LogException(_className, "getPixelsMidpoint",
1774                    new RendererException("Failed inside getPixelsMidpoint", exc));
1775        }
1776    }
1777
1778    private static double getChange1Height(TGLight tg) {
1779        double height = 0;
1780        try {
1781            switch (tg.get_LineType()) {
1782                //case TacticalLines.PAA_RECTANGULAR:
1783                case TacticalLines.FSA_RECTANGULAR:
1784                case TacticalLines.SHIP_AOI_RECTANGULAR:
1785                case TacticalLines.DEFENDED_AREA_RECTANGULAR:
1786                case TacticalLines.FFA_RECTANGULAR:
1787                case TacticalLines.ACA_RECTANGULAR:
1788                case TacticalLines.NFA_RECTANGULAR:
1789                case TacticalLines.RFA_RECTANGULAR:
1790                case TacticalLines.ATI_RECTANGULAR:
1791                case TacticalLines.CFFZ_RECTANGULAR:
1792                case TacticalLines.SENSOR_RECTANGULAR:
1793                case TacticalLines.CENSOR_RECTANGULAR:
1794                case TacticalLines.DA_RECTANGULAR:
1795                case TacticalLines.CFZ_RECTANGULAR:
1796                case TacticalLines.ZOR_RECTANGULAR:
1797                case TacticalLines.TBA_RECTANGULAR:
1798                case TacticalLines.TVAR_RECTANGULAR:
1799                case TacticalLines.KILLBOXBLUE_RECTANGULAR:
1800                case TacticalLines.KILLBOXPURPLE_RECTANGULAR:
1801                    break;
1802                default:
1803                    return 0;
1804            }
1805            double x1 = tg.Pixels.get(0).x;
1806            double y1 = tg.Pixels.get(0).y;
1807            double x2 = tg.Pixels.get(1).x;
1808            double y2 = tg.Pixels.get(1).y;
1809            double deltax = x2 - x1;
1810            double deltay = y2 - y1;
1811            height = Math.sqrt(deltax * deltax + deltay * deltay);
1812        } catch (Exception exc) {
1813            ErrorLogger.LogException(_className, "getChange1Height",
1814                    new RendererException("Failed inside getChange1Height", exc));
1815        }
1816        return height;
1817    }
1818
1819    /**
1820     * scale the line factor for closed areas
1821     *
1822     * @param tg
1823     */
1824    private static void scaleModifiers(TGLight tg) {
1825        try {
1826            if (RendererSettings.getInstance().getAutoCollapseModifiers() == false) {
1827                return;
1828            }
1829            if (!tg.get_Client().equalsIgnoreCase("ge")) {
1830                return;
1831            }
1832            //exit if there are no modifiers or it's not a closed area
1833            if (tg.modifiers == null || tg.modifiers.isEmpty()) {
1834                return;
1835            }
1836            int linetype = tg.get_LineType();
1837            boolean isClosedPolygon = clsUtility.isClosedPolygon(linetype);
1838            boolean isChange1Area = clsUtility.IsChange1Area(linetype);
1839            if (!isClosedPolygon && !isChange1Area) {
1840                return;
1841            }
1842            switch(linetype)
1843            {
1844                case TacticalLines.PAA_CIRCULAR:
1845                case TacticalLines.PAA_RECTANGULAR:
1846                case TacticalLines.RECTANGULAR_TARGET:
1847                case TacticalLines.RANGE_FAN:
1848                case TacticalLines.RANGE_FAN_SECTOR:
1849                case TacticalLines.RADAR_SEARCH:
1850                    return;
1851                default:
1852                    break;
1853            }
1854            POINT2 ptUl = new POINT2(), ptUr = new POINT2(), ptLr = new POINT2(), ptLl = new POINT2();
1855            GetMBR(tg, ptUl, ptUr, ptLr, ptLl);
1856            int sz = tg.get_Font().getSize();
1857            //heightMBR is half the MBR height
1858            //double heightMBR=Math.abs(ptLr.y-ptUr.y)/2;
1859            double heightMBR = 0;
1860            double change1Height = getChange1Height(tg);
1861            if (change1Height <= 0) {
1862                heightMBR = Math.abs(ptLr.y - ptUr.y) / 2;
1863            } else {
1864                heightMBR = change1Height;
1865            }
1866
1867            double heightModifiers = 0;
1868            ArrayList<Modifier2> modifiers = tg.modifiers;
1869            Modifier2 modifier = null;
1870            double minLF = Integer.MAX_VALUE;
1871            int j = 0;
1872            boolean isValid = false;
1873            for (j = 0; j < modifiers.size(); j++) {
1874                modifier = modifiers.get(j);
1875                //if(modifier.type == area)
1876                //type3Area=true;
1877                if (modifier.type == toEnd) {
1878                    continue;
1879                }
1880                if (modifier.type == aboveMiddle && isChange1Area == false) {
1881                    continue;
1882                }
1883                if (modifier.lineFactor < minLF) {
1884                    minLF = modifier.lineFactor;
1885                }
1886                isValid = true;
1887            }
1888            //if there are no 'area' modifiers then exit early
1889            if (!isValid) {
1890                return;
1891            }
1892
1893            heightModifiers = Math.abs(minLF) * sz;
1894            boolean expandModifiers = false, shrinkModifiers = false;
1895            if (heightModifiers > heightMBR) {
1896                shrinkModifiers = true;
1897            } else if (heightModifiers < 0.5 * heightMBR) {
1898                expandModifiers = true;
1899            }
1900
1901            boolean addEllipsis = false;
1902            //modifierE is ellipses modifier
1903            Modifier2 modifierE = new Modifier2();
1904            if (expandModifiers) {
1905                double factor = heightMBR / heightModifiers;
1906                factor = 1 + (factor - 1) / 4;
1907                if (factor > 2) {
1908                    factor = 2;
1909                }
1910                for (j = 0; j < modifiers.size(); j++) {
1911                    modifier = modifiers.get(j);
1912                    if(modifier.type==aboveMiddle)
1913                    {
1914                        if(isChange1Area==false)
1915                            continue;
1916                    }
1917                    else if(modifier.type!=area)
1918                            continue;
1919                    
1920                    modifier.lineFactor *= factor;
1921                }
1922            } else if (shrinkModifiers) {
1923                double deltaLF = (heightModifiers - heightMBR) / sz;
1924                double newLF = 0;
1925                //use maxLF for the ellipsis modifier
1926                double maxLF = 0;
1927                for (j = 0; j < modifiers.size(); j++) {
1928                    modifier = modifiers.get(j);
1929                    if(modifier.type==aboveMiddle)
1930                    {
1931                        if(isChange1Area==false)
1932                            continue;
1933                    }
1934                    else if(modifier.type!=area)
1935                            continue;
1936                    newLF = modifier.lineFactor + deltaLF;
1937                    if (Math.abs(newLF * sz) >= heightMBR) {
1938                        //flag the modifier to remove
1939                        if (modifier.lineFactor > minLF) {
1940                            modifierE.type = modifier.type;
1941                            modifier.type = 7;
1942                            if (!modifier.text.isEmpty()) {
1943                                addEllipsis = true;
1944                            }
1945                        }
1946                        modifier.lineFactor = newLF;
1947                        //modifierE.type=area;
1948                        //modifierE.type=modifier.type;
1949                        modifierE.textPath = modifier.textPath;
1950                        continue;
1951                    }
1952                    modifier.lineFactor = newLF;
1953                }
1954                ArrayList<Modifier2> modifiers2 = new ArrayList();
1955                for (j = 0; j < modifiers.size(); j++) {
1956                    modifier = modifiers.get(j);
1957                    if (modifier.type != 7) {
1958                        if (modifier.lineFactor > maxLF) {
1959                            maxLF = modifier.lineFactor;
1960                        }
1961                        modifiers2.add(modifier);
1962                    }
1963                }
1964                if (addEllipsis) {
1965                    Character letter = (char) 9679;
1966                    String s = Character.toString(letter);
1967                    String echelonSymbol = s + s + s;
1968                    modifierE.text = echelonSymbol;
1969                    modifierE.lineFactor = maxLF + 1;
1970                    modifiers2.add(modifierE);
1971                }
1972                tg.modifiers = modifiers2;
1973            }   //end shrink modifiers
1974        } catch (Exception exc) {
1975            ErrorLogger.LogException(_className, "scaleModifiers",
1976                    new RendererException("Failed inside scaleModifiers", exc));
1977        }
1978    }
1979
1980    /**
1981     * Calculate modifiers identical to addModifiers except use geodesic
1982     * calculations for the center point.
1983     *
1984     * @param tg
1985     * @param g2d
1986     * @param clipBounds
1987     * @param converter
1988     */
1989    public static void AddModifiersGeo(TGLight tg,
1990            Graphics2D g2d,
1991            Object clipBounds,
1992            IPointConversion converter) {
1993        try {
1994            //exit early for those not affected
1995            if (tg.Pixels == null || tg.Pixels.isEmpty()) {
1996                return;
1997            }
1998            ArrayList<POINT2> origPoints = null;
1999            Font font = tg.get_Font();
2000            if (font == null) {
2001                font = g2d.getFont();
2002            }
2003            g2d.setFont(font);
2004
2005            boolean shiftLines = Channels.getShiftLines();
2006            boolean usas = false, foundSegment = false;
2007            double csFactor = 1d, dist = 0, dist2 = 0;//this will be used for text spacing the 3d map (CommandCight)
2008            POINT2 midPt = null;
2009            int northestPtIndex = 0;
2010            int southestPtIndex = 0;
2011            POINT2 northestPt = null;
2012            POINT2 southestPt = null;
2013
2014            Rectangle2D clipRect = null;
2015            ArrayList<Point2D> clipArray = null;
2016            if (clipBounds != null && ArrayList.class.isAssignableFrom(clipBounds.getClass())) {
2017                clipArray = (ArrayList<Point2D>) clipBounds;
2018            }
2019            if (clipBounds != null && Rectangle2D.Double.class.isAssignableFrom(clipBounds.getClass())) {
2020                clipRect = (Rectangle2D.Double) clipBounds;
2021            }
2022
2023            FontMetrics metrics = g2d.getFontMetrics();
2024            int stringWidth = 0, stringWidth2 = 0;
2025            String WDash = ""; // Dash between W and W1 if they're not empty
2026            String TSpace = "", TDash = ""; // Space or dash between label and T modifier if T isn't empty
2027            if (tg.get_DTG() != null && tg.get_DTG1() != null && !tg.get_DTG().isEmpty() && !tg.get_DTG1().isEmpty()) {
2028                WDash = " - ";
2029            }
2030            if (tg.get_Name() != null && !tg.get_Name().isEmpty()) {
2031                TSpace = " ";
2032                TDash = " - ";
2033            }
2034
2035            if (tg.get_Client().equals("cpof3d")) {
2036                csFactor = 0.9d;
2037            }
2038                        
2039            switch (tg.get_LineType()) {
2040                case TacticalLines.SERIES:
2041                case TacticalLines.STRIKWARN:
2042                case TacticalLines.MSR:
2043                case TacticalLines.MSR_ONEWAY:
2044                case TacticalLines.MSR_TWOWAY:
2045                case TacticalLines.MSR_ALT:
2046                case TacticalLines.ASR:
2047                case TacticalLines.ASR_ONEWAY:
2048                case TacticalLines.ASR_TWOWAY:
2049                case TacticalLines.ASR_ALT:
2050                case TacticalLines.TRAFFIC_ROUTE:
2051                case TacticalLines.TRAFFIC_ROUTE_ONEWAY:
2052                case TacticalLines.TRAFFIC_ROUTE_ALT:
2053                case TacticalLines.DHA_REVD:
2054                case TacticalLines.DHA:
2055                case TacticalLines.KILL_ZONE:
2056                case TacticalLines.EPW:
2057                case TacticalLines.UXO:
2058                case TacticalLines.FARP:
2059                case TacticalLines.BSA:
2060                case TacticalLines.DSA:
2061                case TacticalLines.CSA:
2062                case TacticalLines.RSA:
2063                case TacticalLines.THUNDERSTORMS:
2064                case TacticalLines.ICING:
2065                case TacticalLines.FREEFORM:
2066                case TacticalLines.RHA:
2067                case TacticalLines.LINTGT:
2068                case TacticalLines.LINTGTS:
2069                case TacticalLines.FPF:
2070                case TacticalLines.GAP:
2071                case TacticalLines.DEPICT:
2072                case TacticalLines.AIRHEAD:
2073                case TacticalLines.FSA:
2074                case TacticalLines.DIRATKAIR:
2075                case TacticalLines.OBJ:
2076                case TacticalLines.AO:
2077                case TacticalLines.ACA:
2078                case TacticalLines.FFA:
2079                case TacticalLines.PAA:
2080                case TacticalLines.NFA:
2081                case TacticalLines.RFA:
2082                case TacticalLines.ATI:
2083                case TacticalLines.CFFZ:
2084                case TacticalLines.CFZ:
2085                case TacticalLines.TBA:
2086                case TacticalLines.TVAR:
2087                case TacticalLines.KILLBOXBLUE:
2088                case TacticalLines.KILLBOXPURPLE:
2089                case TacticalLines.ZOR:
2090                case TacticalLines.DA:
2091                case TacticalLines.SENSOR:
2092                case TacticalLines.CENSOR:
2093                case TacticalLines.SMOKE:
2094                case TacticalLines.BATTLE:
2095                case TacticalLines.PNO:
2096                case TacticalLines.PDF:
2097                case TacticalLines.NAI:
2098                case TacticalLines.TAI:
2099                case TacticalLines.BASE_CAMP_REVD:
2100                case TacticalLines.BASE_CAMP:
2101                case TacticalLines.GUERILLA_BASE_REVD:
2102                case TacticalLines.GUERILLA_BASE:
2103                case TacticalLines.GENERIC_AREA:
2104                case TacticalLines.ATKPOS:
2105                case TacticalLines.ASSAULT:
2106                case TacticalLines.WFZ_REVD:
2107                case TacticalLines.WFZ:
2108                case TacticalLines.OBSFAREA:
2109                case TacticalLines.OBSAREA:
2110                case TacticalLines.ROZ:
2111                case TacticalLines.AARROZ:
2112                case TacticalLines.UAROZ:
2113                case TacticalLines.WEZ:
2114                case TacticalLines.FEZ:
2115                case TacticalLines.JEZ:
2116                case TacticalLines.FAADZ:
2117                case TacticalLines.HIDACZ:
2118                case TacticalLines.MEZ:
2119                case TacticalLines.LOMEZ:
2120                case TacticalLines.HIMEZ:
2121                case TacticalLines.SAAFR:
2122                case TacticalLines.AC:
2123                case TacticalLines.MRR:
2124                case TacticalLines.SL:
2125                case TacticalLines.TC:
2126                case TacticalLines.SC:
2127                case TacticalLines.LLTR:
2128                case TacticalLines.AIRFIELD:
2129                case TacticalLines.GENERAL:
2130                case TacticalLines.JTAA:
2131                case TacticalLines.SAA:
2132                case TacticalLines.SGAA:
2133                case TacticalLines.FORT_REVD:
2134                case TacticalLines.FORT:
2135                case TacticalLines.ENCIRCLE:
2136                case TacticalLines.ASSY:
2137                case TacticalLines.EA:
2138                case TacticalLines.DZ:
2139                case TacticalLines.EZ:
2140                case TacticalLines.LZ:
2141                case TacticalLines.PZ:
2142                case TacticalLines.LAA:
2143                case TacticalLines.BOUNDARY:
2144                case TacticalLines.MINED:
2145                case TacticalLines.FENCED:
2146                case TacticalLines.PL:
2147                case TacticalLines.DECISION_LINE:
2148                case TacticalLines.FEBA:
2149                case TacticalLines.FCL:
2150                case TacticalLines.HOLD:
2151                case TacticalLines.BRDGHD:
2152                case TacticalLines.HOLD_GE:
2153                case TacticalLines.BRDGHD_GE:
2154                case TacticalLines.LOA:
2155                case TacticalLines.LOD:
2156                case TacticalLines.LL:
2157                case TacticalLines.EWL:
2158                case TacticalLines.RELEASE:
2159                case TacticalLines.HOL:
2160                case TacticalLines.BHL:
2161                case TacticalLines.LDLC:
2162                case TacticalLines.PLD:
2163                case TacticalLines.NFL:
2164                case TacticalLines.MFP:
2165                case TacticalLines.FSCL:
2166                case TacticalLines.BCL_REVD:
2167                case TacticalLines.BCL:
2168                case TacticalLines.ICL:
2169                case TacticalLines.IFF_OFF:
2170                case TacticalLines.IFF_ON:
2171                case TacticalLines.GENERIC_LINE:
2172                case TacticalLines.CFL:
2173                case TacticalLines.TRIP:
2174                case TacticalLines.RFL:
2175                case TacticalLines.FLOT:
2176                case TacticalLines.LC:
2177                case TacticalLines.CATK:
2178                case TacticalLines.CATKBYFIRE:
2179                case TacticalLines.IL:
2180                case TacticalLines.DRCL:
2181                case TacticalLines.RETIRE:
2182                case TacticalLines.PURSUIT:
2183                case TacticalLines.FPOL:
2184                case TacticalLines.RPOL:
2185                case TacticalLines.WITHDRAW:
2186                case TacticalLines.DISENGAGE:
2187                case TacticalLines.WDRAWUP:
2188                case TacticalLines.BEARING:
2189                case TacticalLines.BEARING_J:
2190                case TacticalLines.BEARING_RDF:
2191                case TacticalLines.ELECTRO:
2192                case TacticalLines.BEARING_EW:
2193                case TacticalLines.ACOUSTIC:
2194                case TacticalLines.ACOUSTIC_AMB:
2195                case TacticalLines.TORPEDO:
2196                case TacticalLines.OPTICAL:
2197                case TacticalLines.RIP:
2198                case TacticalLines.DEMONSTRATE:
2199                case TacticalLines.BOMB:
2200                case TacticalLines.ZONE:
2201                case TacticalLines.AT:
2202                case TacticalLines.STRONG:
2203                case TacticalLines.MSDZ:
2204                case TacticalLines.SCREEN:
2205                case TacticalLines.COVER:
2206                case TacticalLines.GUARD:
2207                case TacticalLines.DELAY:
2208                case TacticalLines.TGMF:
2209                case TacticalLines.BIO:
2210                case TacticalLines.BIOT://APP6/E
2211                case TacticalLines.CHEM:
2212                case TacticalLines.CHEMT://APP6/E
2213                case TacticalLines.NUC:
2214                case TacticalLines.RAD:
2215                case TacticalLines.RADT://APP6/E
2216                case TacticalLines.MINE_LINE:
2217                case TacticalLines.ANCHORAGE_LINE:
2218                case TacticalLines.ANCHORAGE_AREA:
2219                case TacticalLines.SPT:
2220                case TacticalLines.FRONTAL_ATTACK:
2221                case TacticalLines.TURNING_MOVEMENT:
2222                case TacticalLines.MOVEMENT_TO_CONTACT:
2223                case TacticalLines.AIRAOA:
2224                case TacticalLines.AAAAA:
2225                case TacticalLines.MAIN:
2226                case TacticalLines.DIRATKSPT:
2227                case TacticalLines.DIRATKGND:
2228                case TacticalLines.LAUNCH_AREA:
2229                case TacticalLines.DEFENDED_AREA_CIRCULAR:
2230                case TacticalLines.RECTANGULAR:
2231                case TacticalLines.CIRCULAR:
2232                case TacticalLines.RECTANGULAR_TARGET:
2233                case TacticalLines.LINE:
2234                case TacticalLines.ASLTXING:
2235                case TacticalLines.BS_LINE:
2236                case TacticalLines.BS_AREA:
2237                case TacticalLines.BBS_LINE:
2238                case TacticalLines.BBS_AREA:
2239                case TacticalLines.PBS_CIRCLE:
2240                case TacticalLines.PBS_ELLIPSE:
2241                case TacticalLines.PBS_RECTANGLE:
2242                case TacticalLines.BBS_POINT:
2243                    origPoints = lineutility.getDeepCopy(tg.Pixels);
2244                    break;
2245                default:    //exit early for those not applicable
2246                    return;
2247            }
2248
2249            int linetype = tg.get_LineType();
2250            int j = 0, k = 0;
2251            double x = 0, y = 0;
2252
2253            int lastIndex = tg.Pixels.size() - 1;
2254            int nextToLastIndex = tg.Pixels.size() - 2;
2255            POINT2 pt0 = new POINT2(tg.Pixels.get(0));
2256            POINT2 pt1 = null;
2257            POINT2 pt2 = null, pt3 = null;
2258            POINT2 ptLast = new POINT2(tg.Pixels.get(lastIndex));
2259            POINT2 ptNextToLast = null;
2260            double DPIScaleFactor = RendererSettings.getInstance().getDeviceDPI() / 96.0;
2261
2262            if (lastIndex > 0) {
2263                ptNextToLast = new POINT2(tg.Pixels.get(nextToLastIndex));
2264            }
2265
2266            if (tg.Pixels.size() > 1) {
2267                pt1 = new POINT2(tg.Pixels.get(1));
2268            }
2269
2270            //prevent vertical paths for modifiers that use toEnd
2271            shiftModifierPath(tg, pt0, pt1, ptLast, ptNextToLast);
2272
2273            String label = GetCenterLabel(tg);
2274            String v=tg.get_V();
2275            String ap=tg.get_AP();
2276            Object[] pts = tg.Pixels.toArray();
2277            //need this for areas and some lines
2278            POINT2 ptCenter = null;
2279            if (converter != null) //cpof uses latlonconverter so cpof passes null for this
2280            {
2281                ptCenter = mdlGeodesic.geodesic_center(tg.LatLongs);
2282                if (ptCenter != null) {
2283                    Point2D pt22 = converter.GeoToPixels(new Point2D.Double(ptCenter.x, ptCenter.y));
2284                    ptCenter.x = pt22.getX();
2285                    ptCenter.y = pt22.getY();
2286                } else {
2287                    ptCenter = lineutility.CalcCenterPointDouble2(pts, pts.length);
2288                }
2289            } else {
2290                ptCenter = lineutility.CalcCenterPointDouble2(pts, pts.length);
2291            }
2292
2293            int middleSegment = (tg.Pixels.size() + 1) / 2 - 1;
2294            int middleSegment2 = 0;
2295
2296            if (clipRect != null) {
2297                middleSegment = getVisibleMiddleSegment(tg, clipRect);
2298            } else if (clipArray != null) {
2299                middleSegment = getVisibleMiddleSegment(tg, clipArray);
2300            }
2301            if (tg.Pixels.size() > 2) {
2302                pt2 = tg.Pixels.get(2);
2303            }
2304            if (tg.Pixels.size() > 3) {
2305                pt3 = tg.Pixels.get(3);
2306            }
2307            double TLineFactor = 0, T1LineFactor = 0;
2308            POINT2 lr = new POINT2(tg.Pixels.get(0));
2309            POINT2 ll = new POINT2(tg.Pixels.get(0));
2310            POINT2 ul = new POINT2(tg.Pixels.get(0));
2311            POINT2 ur = new POINT2(tg.Pixels.get(0));
2312            int index = 0;
2313            int nextIndex = 0;
2314            int size = tg.Pixels.size();
2315            Line2D line = null;
2316                        
2317                        double dAngle0, dAngle1;
2318            int stringHeight;
2319
2320            boolean modifiersGrouped = false;
2321            if(RendererSettings.getInstance().getGroupModifiers())
2322            {
2323                switch(tg.get_LineType())
2324                {
2325                    case TacticalLines.PAA:
2326                        addModifierOnLine("PAA", tg);
2327                        AddIntegralAreaModifier(tg, buildAreaGroupString(tg, label), area, 0, ptCenter, ptCenter, false);
2328                        modifiersGrouped = true;
2329                        break;
2330                    case TacticalLines.ACA:
2331                    case TacticalLines.FFA:
2332                    case TacticalLines.RFA:
2333                    case TacticalLines.NFA:
2334                    case TacticalLines.FSA:
2335                    case TacticalLines.WFZ_REVD:
2336                    case TacticalLines.WFZ:
2337                    case TacticalLines.OBSFAREA:
2338                    case TacticalLines.OBSAREA:
2339                    case TacticalLines.ROZ:
2340                    case TacticalLines.AARROZ:
2341                    case TacticalLines.UAROZ:
2342                    case TacticalLines.WEZ:
2343                    case TacticalLines.FEZ:
2344                    case TacticalLines.JEZ:
2345                    case TacticalLines.FAADZ:
2346                    case TacticalLines.HIDACZ:
2347                    case TacticalLines.MEZ:
2348                    case TacticalLines.LOMEZ:
2349                    case TacticalLines.HIMEZ:
2350                        AddIntegralAreaModifier(tg, buildAreaGroupString(tg, label), area, 0, ptCenter, ptCenter, false);
2351                        modifiersGrouped = true;
2352                        break;
2353                    case TacticalLines.ATI:
2354                    case TacticalLines.CFFZ:
2355                    case TacticalLines.CFZ:
2356                    case TacticalLines.TBA:
2357                    case TacticalLines.TVAR:
2358                    case TacticalLines.ZOR:
2359                    case TacticalLines.DA:
2360                    case TacticalLines.SENSOR:
2361                    case TacticalLines.CENSOR:
2362                    case TacticalLines.KILLBOXBLUE:
2363                    case TacticalLines.KILLBOXPURPLE:
2364                        //Center Labels
2365                        AddIntegralAreaModifier(tg, buildAreaGroupString(tg,label), area, 0 * csFactor, ptCenter, ptCenter, false);
2366
2367                        //DTG Labels at highest left-of-center point
2368                        POINT2 highest = getHighestPointLeftOfCenter(tg.Pixels,ptCenter);
2369                        AddIntegralAreaModifier(tg, buildAreaGroupDTGString(tg), toEnd, 1 * csFactor, highest, new POINT2(highest.x + 0.001, highest.y, 0), false);
2370
2371                        //DTG labels at top left of BBOX
2372                        //GetMBR(tg, ul, ur, lr, ll);
2373                        //POINT2 ptLeft = ul;
2374                        //POINT2 ptRight = ur;
2375                        //AddIntegralAreaModifier(tg, buildAreaGroupDTGString(tg), toEnd, 1 * csFactor, ptLeft, new POINT2(ptLeft.x + 0.001, ptLeft.y, 0), false);
2376                        modifiersGrouped = true;
2377                        break;
2378                    case TacticalLines.SPT:
2379                    case TacticalLines.FRONTAL_ATTACK:
2380                    case TacticalLines.TURNING_MOVEMENT:
2381                    case TacticalLines.MOVEMENT_TO_CONTACT:
2382                    case TacticalLines.AIRAOA:
2383                    case TacticalLines.AAAAA:
2384                    case TacticalLines.MAIN:
2385                        String axisMod = buildAreaGroupDTGString(tg);
2386                        if (tg.Pixels.size() == 3) //one segment
2387                        {
2388                            midPt = lineutility.MidPointDouble(pt0, pt1, 0);
2389                            if(!tg.get_Name().isEmpty())
2390                            {
2391                                if(!axisMod.isEmpty())
2392                                    axisMod += '\n';
2393                                axisMod += tg.get_Name();
2394                            }
2395                            AddIntegralAreaModifier(tg, axisMod, area, 0, midPt, midPt, false);
2396
2397                        } else if (tg.Pixels.size() == 4) //2 segments
2398                        {
2399                            midPt = lineutility.MidPointDouble(pt1, pt2, 0);
2400                            if(!tg.get_Name().isEmpty())
2401                            {
2402                                if(!axisMod.isEmpty())
2403                                    axisMod += '\n';
2404                                axisMod += tg.get_Name();
2405                            }
2406                            AddIntegralAreaModifier(tg, axisMod, area, 0, midPt, midPt, false);
2407                        } else // 3 or more segments
2408                        {
2409                            midPt = lineutility.MidPointDouble(pt1, pt2, 0);
2410                            AddIntegralAreaModifier(tg, axisMod, area, 0, midPt, midPt, false);
2411                            midPt = lineutility.MidPointDouble(pt2, pt3, 0);
2412                            AddIntegralAreaModifier(tg, tg.get_Name(), area, 0, midPt, midPt, false);
2413                        }
2414                        modifiersGrouped = true;
2415                        break;
2416                    case TacticalLines.AC://Air Corridors
2417                    case TacticalLines.LLTR:
2418                    case TacticalLines.MRR:
2419                    case TacticalLines.SL:
2420                    case TacticalLines.TC:
2421                    case TacticalLines.SAAFR:
2422                    case TacticalLines.SC:
2423                        //AddIntegralAreaModifier(tg, buildAreaGroupString(tg, label), area, 0, ptCenter, ptCenter, false);
2424                        AddIntegralModifier(tg, buildAreaGroupString(tg, label), aboveMiddle, 0, middleSegment, middleSegment + 1, false);
2425                        modifiersGrouped = true;
2426                        break;
2427                }
2428            }
2429
2430            //modifiers aren't grouped or the symbol doesn't leverage grouped modifiers
2431            if(!modifiersGrouped) {
2432                switch (linetype) {
2433                    case TacticalLines.PL:
2434                        AddIntegralAreaModifier(tg, label + TSpace + tg.get_Name(), toEnd, T1LineFactor, pt0, pt1, false);
2435                        AddIntegralAreaModifier(tg, label + TSpace + tg.get_Name(), toEnd, T1LineFactor, ptLast, ptNextToLast, false);
2436                        break;
2437                    case TacticalLines.DECISION_LINE:
2438                        if (tg.get_AS() == null || !tg.get_AS().isEmpty())
2439                            tg.set_AS(GENCLookup.getInstance().get3CharCode(SymbolID.getCountryCode(tg.get_SymbolId())));
2440                        Bitmap bi = getImageModifier(tg);
2441
2442                        POINT2 ptDP1 = lineutility.ExtendLine2Double(pt1, pt0, bi.getWidth() / 2, 0);
2443                        POINT2 ptDP2 = lineutility.ExtendLine2Double(ptNextToLast, ptLast, bi.getWidth() / 2, 0);
2444
2445                        AddIntegralAreaModifier(tg, bi, toEnd, 0, pt0, ptDP1, false);
2446                        AddIntegralAreaModifier(tg, bi, toEnd, 0, ptLast, ptDP2, false);
2447                        break;
2448                    case TacticalLines.BS_LINE:
2449                    case TacticalLines.BBS_LINE:
2450                        if (tg.get_T1() == null || tg.get_T1().isEmpty()) {
2451                            AddIntegralAreaModifier(tg, tg.get_Name(), toEnd, T1LineFactor, pt0, pt1, false);
2452                            AddIntegralAreaModifier(tg, tg.get_Name(), toEnd, T1LineFactor, ptLast, ptNextToLast, false);
2453                        } else {
2454                            if (tg.get_T1().equalsIgnoreCase("1")) {
2455                                for (j = 0; j < tg.Pixels.size() - 1; j++) {
2456                                    AddIntegralAreaModifier(tg, tg.get_Name(), aboveMiddle, 0, tg.Pixels.get(j), tg.Pixels.get(j + 1), false);
2457                                }
2458                            } else if (tg.get_T1().equalsIgnoreCase("2")) {
2459                                AddIntegralAreaModifier(tg, tg.get_Name(), toEnd, T1LineFactor, pt0, pt1, false);
2460                                AddIntegralAreaModifier(tg, tg.get_Name(), toEnd, T1LineFactor, ptLast, ptNextToLast, false);
2461                            } else if (tg.get_T1().equalsIgnoreCase("3")) {
2462                                //either end of the polyline
2463                                dist = lineutility.CalcDistanceDouble(pt0, pt1);
2464                                stringWidth = metrics.stringWidth(tg.get_Name());
2465                                stringWidth /= 2;
2466                                pt2 = lineutility.ExtendAlongLineDouble2(pt1, pt0, dist + stringWidth);
2467                                AddIntegralAreaModifier(tg, tg.get_Name(), area, 0, pt2, pt2, false);
2468                                dist = lineutility.CalcDistanceDouble(ptNextToLast, ptLast);
2469                                pt2 = lineutility.ExtendAlongLineDouble2(ptNextToLast, ptLast, dist + stringWidth);
2470                                AddIntegralAreaModifier(tg, tg.get_Name(), area, 0, pt2, pt2, false);
2471                                //the intermediate points
2472                                for (j = 1; j < tg.Pixels.size() - 1; j++) {
2473                                    AddIntegralAreaModifier(tg, tg.get_Name(), area, 0, tg.Pixels.get(j), tg.Pixels.get(j), false);
2474                                }
2475                            } else //t1 is set inadvertantly or for other graphics
2476                            {
2477                                AddIntegralAreaModifier(tg, tg.get_Name(), toEnd, T1LineFactor, pt0, pt1, false);
2478                                AddIntegralAreaModifier(tg, tg.get_Name(), toEnd, T1LineFactor, ptLast, ptNextToLast, false);
2479                            }
2480                        }
2481                        break;
2482                    case TacticalLines.BS_AREA:
2483                    case TacticalLines.BBS_AREA:
2484                        AddIntegralAreaModifier(tg, tg.get_Name(), area, 0, ptCenter, ptCenter, false);
2485                        break;
2486                    case TacticalLines.FEBA:
2487                        AddIntegralAreaModifier(tg, label, toEnd, 0, pt0, pt1, false);
2488                        AddIntegralAreaModifier(tg, label, toEnd, 0, ptLast, ptNextToLast, false);
2489                        break;
2490                    // T before label
2491                    case TacticalLines.FSCL:
2492                        pt0 = tg.Pixels.get(0);
2493                        pt1 = tg.Pixels.get(1);
2494                        pt2 = tg.Pixels.get(tg.Pixels.size() - 1);
2495                        pt3 = tg.Pixels.get(tg.Pixels.size() - 2);
2496                        dist = lineutility.CalcDistanceDouble(pt0, pt1);
2497                        dist2 = lineutility.CalcDistanceDouble(pt2, pt3);
2498                        stringWidth = (int) ((double) metrics.stringWidth(tg.get_Name() + " " + label));
2499                        stringWidth2 = (int) ((double) metrics.stringWidth(tg.get_DTG()));
2500                        if (stringWidth2 > stringWidth) {
2501                            stringWidth = stringWidth2;
2502                        }
2503
2504                        if (tg.Pixels.size() == 2) //one segment
2505                        {
2506                            pt1 = lineutility.ExtendAlongLineDouble(pt0, pt1, stringWidth);
2507                            AddModifier2(tg, tg.get_Name() + " " + label, aboveMiddle, -0.7 * csFactor, pt0, pt1, false);
2508                            AddModifier2(tg, tg.get_DTG() + WDash, aboveMiddle, 0.7 * csFactor, pt0, pt1, false);
2509                            AddModifier2(tg, tg.get_DTG1(), aboveMiddle, 1.7 * csFactor, pt0, pt1, false);
2510                            if (dist > 3.5 * stringWidth)//was 28stringwidth+5
2511                            {
2512                                pt0 = tg.Pixels.get(tg.Pixels.size() - 1);
2513                                pt1 = tg.Pixels.get(tg.Pixels.size() - 2);
2514                                pt1 = lineutility.ExtendAlongLineDouble(pt0, pt1, stringWidth);
2515                                AddModifier2(tg, tg.get_Name() + " " + label, aboveMiddle, -0.7 * csFactor, pt0, pt1, false);
2516                                AddModifier2(tg, tg.get_DTG() + WDash, aboveMiddle, 0.7 * csFactor, pt0, pt1, false);
2517                                AddModifier2(tg, tg.get_DTG1(), aboveMiddle, 1.7 * csFactor, pt0, pt1, false);
2518                            }
2519                        } else //more than one semgent
2520                        {
2521                            double dist3 = lineutility.CalcDistanceDouble(pt0, pt2);
2522                            if (dist > stringWidth + 5 || dist >= dist2 || dist3 > stringWidth + 5) {
2523                                pt1 = lineutility.ExtendAlongLineDouble(pt0, pt1, stringWidth);
2524                                AddModifier2(tg, tg.get_Name() + " " + label, aboveMiddle, -0.7 * csFactor, pt0, pt1, false);
2525                                AddModifier2(tg, tg.get_DTG() + WDash, aboveMiddle, 0.7 * csFactor, pt0, pt1, false);
2526                                AddModifier2(tg, tg.get_DTG1(), aboveMiddle, 1.7 * csFactor, pt0, pt1, false);
2527                            }
2528                            if (dist2 > stringWidth + 5 || dist2 > dist || dist3 > stringWidth + 5) {
2529                                pt0 = tg.Pixels.get(tg.Pixels.size() - 1);
2530                                pt1 = tg.Pixels.get(tg.Pixels.size() - 2);
2531                                pt1 = lineutility.ExtendAlongLineDouble(pt0, pt1, stringWidth);
2532                                AddModifier2(tg, tg.get_Name() + " " + label, aboveMiddle, -0.7 * csFactor, pt0, pt1, false);
2533                                AddModifier2(tg, tg.get_DTG() + WDash, aboveMiddle, 0.7 * csFactor, pt0, pt1, false);
2534                                AddModifier2(tg, tg.get_DTG1(), aboveMiddle, 1.7 * csFactor, pt0, pt1, false);
2535                            }
2536                        }
2537                        break;
2538                    // T after label
2539                    case TacticalLines.ICL:
2540                    case TacticalLines.NFL:
2541                    case TacticalLines.BCL_REVD:
2542                    case TacticalLines.RFL:
2543                    case TacticalLines.BCL:
2544                        pt0 = tg.Pixels.get(0);
2545                        pt1 = tg.Pixels.get(1);
2546                        pt2 = tg.Pixels.get(tg.Pixels.size() - 1);
2547                        pt3 = tg.Pixels.get(tg.Pixels.size() - 2);
2548                        dist = lineutility.CalcDistanceDouble(pt0, pt1);
2549                        dist2 = lineutility.CalcDistanceDouble(pt2, pt3);
2550                        String TMod = ""; // Don't add parenthesis if T modifier is empty
2551
2552
2553                        int version = SymbolID.getVersion(tg.get_SymbolId());
2554                        if (version < SymbolID.Version_2525E) {
2555                            TMod = tg.get_Name();
2556                            stringWidth = (int) ((double) metrics.stringWidth(TMod + " " + label));
2557                        } else if (version == SymbolID.Version_2525E || version == SymbolID.Version_2525Ech1) {
2558                            if (linetype == TacticalLines.BCL) {
2559                                if (tg.get_Name() != null && !tg.get_Name().isEmpty())
2560                                    TMod = " (" + tg.get_Name() + ")";
2561                                stringWidth = (int) ((double) metrics.stringWidth(label + TMod));
2562                            } else {
2563                                TMod = tg.get_Name();
2564                                stringWidth = (int) ((double) metrics.stringWidth(tg.get_Name() + " " + label));
2565                            }
2566                        } else if ((version == SymbolID.Version_APP6Ech2)) {
2567                            if (tg.get_Name() != null && !tg.get_Name().isEmpty())
2568                                TMod += " " + tg.get_Name();
2569                            if (tg.get_AS() != null && !tg.get_AS().isEmpty())
2570                                TMod += " (" + tg.get_AS() + ")";
2571                            stringWidth = (int) ((double) metrics.stringWidth(label + TMod));
2572
2573                        }
2574
2575                        stringWidth2 = (int) ((double) metrics.stringWidth(tg.get_DTG()));
2576                        if (stringWidth2 > stringWidth) {
2577                            stringWidth = stringWidth2;
2578                        }
2579
2580                        if (tg.Pixels.size() == 2) //one segment
2581                        {
2582                            pt1 = lineutility.ExtendAlongLineDouble(pt0, pt1, stringWidth);
2583                            AddModifier2(tg, label + TSpace + TMod, aboveMiddle, -0.7 * csFactor, pt0, pt1, false);
2584                            AddModifier2(tg, tg.get_DTG() + WDash, aboveMiddle, 0.7 * csFactor, pt0, pt1, false);
2585                            AddModifier2(tg, tg.get_DTG1(), aboveMiddle, 1.7 * csFactor, pt0, pt1, false);
2586                            if (dist > 3.5 * stringWidth)//was 28stringwidth+5
2587                            {
2588                                pt0 = tg.Pixels.get(tg.Pixels.size() - 1);
2589                                pt1 = tg.Pixels.get(tg.Pixels.size() - 2);
2590                                pt1 = lineutility.ExtendAlongLineDouble(pt0, pt1, stringWidth);
2591                                AddModifier2(tg, label + TSpace + TMod, aboveMiddle, -0.7 * csFactor, pt0, pt1, false);
2592                                AddModifier2(tg, tg.get_DTG() + WDash, aboveMiddle, 0.7 * csFactor, pt0, pt1, false);
2593                                AddModifier2(tg, tg.get_DTG1(), aboveMiddle, 1.7 * csFactor, pt0, pt1, false);
2594                            }
2595                        } else //more than one semgent
2596                        {
2597                            double dist3 = lineutility.CalcDistanceDouble(pt0, pt2);
2598                            if (dist > stringWidth + 5 || dist >= dist2 || dist3 > stringWidth + 5) {
2599                                pt1 = lineutility.ExtendAlongLineDouble(pt0, pt1, stringWidth);
2600                                AddModifier2(tg, label + TSpace + TMod, aboveMiddle, -0.7 * csFactor, pt0, pt1, false);
2601                                AddModifier2(tg, tg.get_DTG() + WDash, aboveMiddle, 0.7 * csFactor, pt0, pt1, false);
2602                                AddModifier2(tg, tg.get_DTG1(), aboveMiddle, 1.7 * csFactor, pt0, pt1, false);
2603                            }
2604                            if (dist2 > stringWidth + 5 || dist2 > dist || dist3 > stringWidth + 5) {
2605                                pt0 = tg.Pixels.get(tg.Pixels.size() - 1);
2606                                pt1 = tg.Pixels.get(tg.Pixels.size() - 2);
2607                                pt1 = lineutility.ExtendAlongLineDouble(pt0, pt1, stringWidth);
2608                                AddModifier2(tg, label + TSpace + TMod, aboveMiddle, -0.7 * csFactor, pt0, pt1, false);
2609                                AddModifier2(tg, tg.get_DTG() + WDash, aboveMiddle, 0.7 * csFactor, pt0, pt1, false);
2610                                AddModifier2(tg, tg.get_DTG1(), aboveMiddle, 1.7 * csFactor, pt0, pt1, false);
2611                            }
2612                        }
2613                        break;
2614                    case TacticalLines.DIRATKSPT:
2615                    case TacticalLines.DIRATKAIR:
2616                    case TacticalLines.DIRATKGND:
2617                        midPt = lineutility.MidPointDouble(pt0, pt1, 0);
2618                        //midPt=lineutility.MidPointDouble(pt0, midPt, 0);
2619                        AddIntegralAreaModifier(tg, tg.get_Name(), aboveMiddle, 0, pt0, midPt, false);
2620                        addDTG(tg, aboveMiddle, csFactor, 2 * csFactor, pt0, pt1, metrics);
2621                        break;
2622                    case TacticalLines.SPT:
2623                    case TacticalLines.FRONTAL_ATTACK:
2624                    case TacticalLines.TURNING_MOVEMENT:
2625                    case TacticalLines.MOVEMENT_TO_CONTACT:
2626                    case TacticalLines.AIRAOA:
2627                    case TacticalLines.AAAAA:
2628                    case TacticalLines.MAIN:
2629                        if (tg.Pixels.size() == 3) //one segment
2630                        {
2631                            midPt = lineutility.MidPointDouble(pt0, pt1, 0);
2632                            AddIntegralAreaModifier(tg, tg.get_DTG() + WDash, aboveMiddle, 0, midPt, midPt, false);
2633                            AddIntegralAreaModifier(tg, tg.get_DTG1(), aboveMiddle, csFactor, midPt, midPt, false);
2634                            AddIntegralAreaModifier(tg, tg.get_Name(), aboveMiddle, 2 * csFactor, midPt, midPt, false);
2635
2636                        } else if (tg.Pixels.size() == 4) //2 segments
2637                        {
2638                            midPt = lineutility.MidPointDouble(pt1, pt2, 0);
2639                            AddIntegralAreaModifier(tg, tg.get_DTG() + WDash, aboveMiddle, 0, midPt, midPt, false);
2640                            AddIntegralAreaModifier(tg, tg.get_DTG1(), aboveMiddle, csFactor, midPt, midPt, false);
2641                            AddIntegralAreaModifier(tg, tg.get_Name(), aboveMiddle, 2 * csFactor, midPt, midPt, false);
2642                        } else // 3 or more segments
2643                        {
2644                            midPt = lineutility.MidPointDouble(pt1, pt2, 0);
2645                            AddIntegralAreaModifier(tg, tg.get_DTG() + WDash, aboveMiddle, -csFactor / 2, midPt, midPt, false);
2646                            AddIntegralAreaModifier(tg, tg.get_DTG1(), aboveMiddle, csFactor / 2, midPt, midPt, false);
2647                            midPt = lineutility.MidPointDouble(pt2, pt3, 0);
2648                            AddIntegralAreaModifier(tg, tg.get_Name(), aboveMiddle, -csFactor / 2, midPt, midPt, false);
2649                        }
2650                        break;
2651                    case TacticalLines.LL:
2652                    case TacticalLines.LOD:
2653                    case TacticalLines.LDLC:
2654                    case TacticalLines.PLD:
2655                    case TacticalLines.RELEASE:
2656                    case TacticalLines.HOL:
2657                    case TacticalLines.BHL:
2658                    case TacticalLines.FCL:
2659                    case TacticalLines.HOLD:
2660                    case TacticalLines.BRDGHD:
2661                    case TacticalLines.HOLD_GE:
2662                    case TacticalLines.BRDGHD_GE:
2663                    case TacticalLines.LOA:
2664                    case TacticalLines.IFF_OFF:
2665                    case TacticalLines.IFF_ON:
2666                        AddIntegralAreaModifier(tg, label, aboveEnd, -csFactor, pt0, pt1, false);
2667                        AddIntegralAreaModifier(tg, label, aboveEnd, -csFactor, ptLast, ptNextToLast, false);
2668                        break;
2669                    case TacticalLines.EWL:
2670                        AddIntegralAreaModifier(tg, label, aboveEnd, -csFactor, pt0, pt1, false);
2671                        AddIntegralAreaModifier(tg, label, aboveEnd, -csFactor, ptLast, ptNextToLast, false);
2672                        tg.set_EchelonSymbol("");
2673                        if (clipRect != null) {
2674                            AddBoundaryModifiers(tg, g2d, clipRect);
2675                        } else {
2676                            AddBoundaryModifiers(tg, g2d, clipArray);
2677                        }
2678                        break;
2679                    case TacticalLines.AIRFIELD:
2680                        ur = new POINT2();
2681                        ul = new POINT2();
2682                        ll = new POINT2();
2683                        lr = new POINT2();
2684                        Modifier2.GetMBR(tg, ul, ur, lr, ll);
2685                        stringWidth = metrics.stringWidth(tg.get_H());
2686                        pt0.x = ur.x + stringWidth / 2 + 1;
2687                        //pt0.x=ptUr.x+1;
2688                        //pt0.y=(ptUr.y+ptLr.y)/2-metrics.getFont().getSize()
2689                        pt0.y = (ur.y + lr.y) / 2 - font.getSize();
2690                        AddIntegralAreaModifier(tg, tg.get_H(), area, csFactor, pt0, pt0, false);
2691                        break;
2692                    case TacticalLines.LAUNCH_AREA:
2693                    case TacticalLines.DEFENDED_AREA_CIRCULAR:
2694                        AddIntegralAreaModifier(tg, label + TDash + tg.get_Name(), area, 0, ptCenter, ptCenter, false);
2695                        break;
2696                    case TacticalLines.JTAA:
2697                    case TacticalLines.SAA:
2698                    case TacticalLines.SGAA:
2699                        addNModifier(tg);
2700                        AddIntegralAreaModifier(tg, label + TDash + tg.get_Name(), area, 0, ptCenter, ptCenter, false);
2701                        addDTG(tg, area, csFactor, 2 * csFactor, ptCenter, ptCenter, metrics);
2702                        break;
2703                    case TacticalLines.FORT:
2704                    case TacticalLines.ZONE:
2705                        AddIntegralAreaModifier(tg, tg.get_Name(), area, 0, ptCenter, ptCenter, false);
2706                        break;
2707                    case TacticalLines.BDZ:
2708                        AddIntegralAreaModifier(tg, label, area, 0, pt0, pt0, false);
2709                        break;
2710                    case TacticalLines.ASSAULT:
2711                    case TacticalLines.ATKPOS:
2712                    case TacticalLines.OBJ:
2713                    case TacticalLines.NAI:
2714                    case TacticalLines.TAI:
2715                    case TacticalLines.BASE_CAMP_REVD:
2716                    case TacticalLines.GUERILLA_BASE_REVD:
2717                    case TacticalLines.ASSY:
2718                    case TacticalLines.EA:
2719                    case TacticalLines.DZ:
2720                    case TacticalLines.EZ:
2721                    case TacticalLines.LZ:
2722                    case TacticalLines.PZ:
2723                    case TacticalLines.AO:
2724                        AddIntegralAreaModifier(tg, label + TSpace + tg.get_Name(), area, 0, ptCenter, ptCenter, false);
2725                        break;
2726                    case TacticalLines.BASE_CAMP:
2727                    case TacticalLines.GUERILLA_BASE:
2728                        AddIntegralAreaModifier(tg, label + TSpace + tg.get_Name(), area, -1 * csFactor, ptCenter, ptCenter, false);
2729                        AddModifier(tg, tg.get_H(), area, 0, ptCenter, ptCenter);
2730                        addDTG(tg, area, 1 * csFactor, 2 * csFactor, ptCenter, ptCenter, metrics);
2731                        addNModifier(tg);
2732                        addModifierBottomSegment(tg, tg.get_EchelonSymbol());
2733                        break;
2734                    case TacticalLines.GENERIC_AREA:
2735                        AddIntegralAreaModifier(tg, tg.get_H() + " " + tg.get_Name(), area, -0.5 * csFactor, ptCenter, ptCenter, false);
2736                        addDTG(tg, area, 0.5 * csFactor, 1.5 * csFactor, ptCenter, ptCenter, metrics);
2737                        addNModifier(tg);
2738                        break;
2739                    case TacticalLines.AIRHEAD:
2740                        GetMBR(tg, ul, ur, lr, ll);
2741                        AddIntegralAreaModifier(tg, label, aboveMiddle, csFactor, ll, lr, false);
2742                        break;
2743                    case TacticalLines.AC:
2744                    case TacticalLines.LLTR:
2745                    case TacticalLines.MRR:
2746                    case TacticalLines.SL:
2747                    case TacticalLines.TC:
2748                    case TacticalLines.SAAFR:
2749                    case TacticalLines.SC:
2750                        AddIntegralModifier(tg, "Name: " + tg.get_Name(), aboveMiddle, -7 * csFactor, middleSegment, middleSegment + 1, false);
2751                        AddIntegralModifier(tg, "Width: " + removeDecimal(tg.get_AM()), aboveMiddle, -6 * csFactor, middleSegment, middleSegment + 1, false);
2752                        AddIntegralModifier(tg, "Min Alt: " + tg.get_X(), aboveMiddle, -5 * csFactor, middleSegment, middleSegment + 1, false);
2753                        AddIntegralModifier(tg, "Max Alt: " + tg.get_X1(), aboveMiddle, -4 * csFactor, middleSegment, middleSegment + 1, false);
2754                        AddIntegralModifier(tg, "DTG Start: " + tg.get_DTG(), aboveMiddle, -3 * csFactor, middleSegment, middleSegment + 1, false);
2755                        AddIntegralModifier(tg, "DTG End: " + tg.get_DTG1(), aboveMiddle, -2 * csFactor, middleSegment, middleSegment + 1, false);
2756                        AddIntegralModifier(tg, label + TSpace + tg.get_Name(), aboveMiddle, 0, middleSegment, middleSegment + 1, false);
2757                        break;
2758                    case TacticalLines.BEARING_J:
2759                    case TacticalLines.BEARING_RDF:
2760                    case TacticalLines.BEARING:
2761                    case TacticalLines.ELECTRO:
2762                    case TacticalLines.BEARING_EW:
2763                    case TacticalLines.ACOUSTIC:
2764                    case TacticalLines.ACOUSTIC_AMB:
2765                    case TacticalLines.TORPEDO:
2766                    case TacticalLines.OPTICAL:
2767                        midPt = lineutility.MidPointDouble(pt0, pt1, 0);
2768                        AddIntegralAreaModifier(tg, label, aboveMiddle, 0, midPt, midPt, true);
2769                        pt3 = lineutility.ExtendDirectedLine(pt0, pt1, pt1, 3, font.getSize() / 2.0);
2770                        AddIntegralAreaModifier(tg, tg.get_H(), aboveMiddle, 1, pt3, pt3, true);
2771                        break;
2772                    case TacticalLines.ACA:
2773                        AddIntegralAreaModifier(tg, label + TSpace + tg.get_Name(), area, -3 * csFactor, ptCenter, ptCenter, false);
2774                        AddIntegralAreaModifier(tg, tg.get_T1(), area, -2 * csFactor, ptCenter, ptCenter, false);
2775                        AddIntegralAreaModifier(tg, "MIN ALT: " + tg.get_X(), area, -1 * csFactor, ptCenter, ptCenter, false, "H");
2776                        AddIntegralAreaModifier(tg, "MAX ALT: " + tg.get_X1(), area, 0, ptCenter, ptCenter, false, "H1");
2777                        AddIntegralAreaModifier(tg, "GRID " + tg.get_Location(), area, 1 * csFactor, ptCenter, ptCenter, false, "H2");
2778                        AddModifier2(tg, "EFF " + tg.get_DTG() + WDash, area, 2 * csFactor, ptCenter, ptCenter, false, "W");
2779                        AddModifier2(tg, tg.get_DTG1(), area, 3 * csFactor, ptCenter, ptCenter, false, "W1");
2780                        break;
2781                    case TacticalLines.MFP:
2782                        pt0 = tg.Pixels.get(middleSegment);
2783                        pt1 = tg.Pixels.get(middleSegment + 1);
2784                        AddIntegralModifier(tg, label, aboveMiddle, 0, middleSegment, middleSegment + 1, true);
2785                        AddIntegralModifier(tg, tg.get_DTG() + WDash, aboveEnd, 1 * csFactor, 0, 1, false);
2786                        AddIntegralModifier(tg, tg.get_DTG1(), aboveEnd, 2 * csFactor, 0, 1, false);
2787                        break;
2788                    case TacticalLines.LINTGT:
2789                        AddIntegralModifier(tg, ap, aboveMiddle, -0.7 * csFactor, middleSegment, middleSegment + 1, false);
2790                        break;
2791                    case TacticalLines.LINTGTS:
2792                        AddIntegralModifier(tg, ap, aboveMiddle, -0.7 * csFactor, middleSegment, middleSegment + 1, false);
2793                        AddIntegralModifier(tg, label, aboveMiddle, 0.7 * csFactor, middleSegment, middleSegment + 1, false);
2794                        break;
2795                    case TacticalLines.FPF:
2796                        AddIntegralModifier(tg, ap, aboveMiddle, -0.7 * csFactor, 0, 1, false);
2797                        AddIntegralModifier(tg, label, aboveMiddle, .7 * csFactor, 0, 1, false);
2798                        AddIntegralModifier(tg, tg.get_T1(), aboveMiddle, 1.7 * csFactor, 0, 1, false);
2799                        AddIntegralModifier(tg, v, aboveMiddle, 2.7 * csFactor, 0, 1, false);
2800                        break;
2801                    case TacticalLines.AT:
2802                        AddIntegralAreaModifier(tg, ap, area, 0, ptCenter, ptCenter, false);
2803                        break;
2804                    case TacticalLines.RECTANGULAR:
2805                    case TacticalLines.CIRCULAR:
2806                        AddIntegralAreaModifier(tg, ap, area, 0, pt0, pt0, false);
2807                        break;
2808                    case TacticalLines.PBS_CIRCLE:
2809                    case TacticalLines.PBS_ELLIPSE:
2810                    case TacticalLines.PBS_RECTANGLE:
2811                    case TacticalLines.BBS_POINT:
2812                        AddIntegralAreaModifier(tg, tg.get_Name(), area, 0, pt0, pt0, false);
2813                        break;
2814                    case TacticalLines.RECTANGULAR_TARGET:
2815                        stringWidth = metrics.stringWidth(tg.get_Name());
2816                        POINT2 offsetCenterPoint = new POINT2(ptCenter.x + ((double) stringWidth) / 2.0, ptCenter.y);
2817                        AddIntegralAreaModifier(tg, tg.get_Name(), area, -1 * csFactor, offsetCenterPoint, offsetCenterPoint, false);
2818                        break;
2819                    case TacticalLines.SMOKE:
2820                        AddIntegralAreaModifier(tg, ap, area, -csFactor, ptCenter, ptCenter, false);
2821                        AddIntegralAreaModifier(tg, label, area, 0, ptCenter, ptCenter, false);
2822                        addDTG(tg, area, 1 * csFactor, 2 * csFactor, ptCenter, ptCenter, metrics);
2823                        break;
2824                    case TacticalLines.LINE:
2825                        AddIntegralModifier(tg, tg.get_Name(), aboveMiddle, csFactor, middleSegment, middleSegment + 1, false);
2826                        break;
2827                    case TacticalLines.MINED:
2828                        if (tg.isHostile()) {
2829                            pt1 = lineutility.MidPointDouble(pt0, pt1, 0);
2830                            AddIntegralAreaModifier(tg, tg.get_N(), aboveMiddle, 0, pt0, pt1, true);
2831                            if (middleSegment != 0) {
2832                                pt0 = tg.Pixels.get(middleSegment);
2833                                pt1 = tg.Pixels.get(middleSegment + 1);
2834                                pt1 = lineutility.MidPointDouble(pt0, pt1, 0);
2835                                AddIntegralAreaModifier(tg, tg.get_N(), aboveMiddle, 0, pt0, pt1, true);
2836                            }
2837                        }
2838                        GetMBR(tg, ul, ur, lr, ll);
2839                        AddIntegralAreaModifier(tg, tg.get_H(), aboveMiddle, -1.5 * csFactor, ul, ur, false);
2840                        AddIntegralAreaModifier(tg, tg.get_DTG(), aboveMiddle, 1.5 * csFactor, ll, lr, false);
2841                        addModifierOnLine("M", tg);
2842                        AddIntegralAreaModifier(tg, getImageModifier(tg), areaImage, 0, ptCenter, ptCenter, false);
2843                        break;
2844                    case TacticalLines.FENCED:
2845                        if (tg.isHostile()) {
2846                            pt1 = lineutility.MidPointDouble(pt0, pt1, 0);
2847                            AddIntegralAreaModifier(tg, tg.get_N(), aboveMiddle, 0, pt0, pt1, true);
2848                            if (middleSegment != 0) {
2849                                pt0 = tg.Pixels.get(middleSegment);
2850                                pt1 = tg.Pixels.get(middleSegment + 1);
2851                                pt1 = lineutility.MidPointDouble(pt0, pt1, 0);
2852                                AddIntegralAreaModifier(tg, tg.get_N(), aboveMiddle, 0, pt0, pt1, true);
2853                            }
2854                        }
2855                        addModifierOnLine("M", tg);
2856                        AddIntegralAreaModifier(tg, getImageModifier(tg), areaImage, 0, ptCenter, ptCenter, false);
2857                        break;
2858                    case TacticalLines.ASLTXING:
2859                        if (tg.Pixels.get(1).y > tg.Pixels.get(0).y) {
2860                            pt0 = tg.Pixels.get(1);
2861                            pt1 = tg.Pixels.get(3);
2862                            pt2 = tg.Pixels.get(0);
2863                            pt3 = tg.Pixels.get(2);
2864                        } else {
2865                            pt0 = tg.Pixels.get(0);
2866                            pt1 = tg.Pixels.get(2);
2867                            pt2 = tg.Pixels.get(1);
2868                            pt3 = tg.Pixels.get(3);
2869                        }
2870                        pt2 = lineutility.ExtendAlongLineDouble2(pt0, pt2, -20);
2871                        pt3 = lineutility.ExtendAlongLineDouble2(pt1, pt3, -20);
2872                        addDTG(tg, aboveMiddle, 0, csFactor, pt2, pt3, metrics);
2873                        break;
2874                    case TacticalLines.SERIES:
2875                    case TacticalLines.DRCL:
2876                        addModifierTopSegment(tg, tg.get_Name());
2877                        break;
2878                    case TacticalLines.STRIKWARN:
2879                        AddIntegralModifier(tg, "1", aboveMiddle, 0, index, index + 1, true);
2880                        AddIntegralModifier(tg, "2", aboveMiddle, 0, size / 2, size / 2 + 1, true);
2881                        break;
2882                    case TacticalLines.SCREEN:
2883                    case TacticalLines.COVER:
2884                    case TacticalLines.GUARD:
2885                        if (tg.Pixels.size() == 4) {
2886                            pt1 = new POINT2(tg.Pixels.get(1));
2887                            pt2 = new POINT2(tg.Pixels.get(2));
2888                            AddIntegralAreaModifier(tg, label, area, 0, pt1, pt1, true);
2889                            AddIntegralAreaModifier(tg, label, area, 0, pt2, pt2, true);
2890                        } else {
2891                            stringHeight = (int) (0.5 * (double) font.getSize());
2892                            dAngle0 = Math.atan2(tg.Pixels.get(0).y - tg.Pixels.get(1).y, tg.Pixels.get(0).x - tg.Pixels.get(1).x);
2893                            dAngle1 = Math.atan2(tg.Pixels.get(0).y - tg.Pixels.get(2).y, tg.Pixels.get(0).x - tg.Pixels.get(2).x);
2894                            pt0 = new POINT2(tg.Pixels.get(0));
2895                            pt0.x -= 30 * Math.cos(dAngle0);
2896                            pt0.y -= 30 * Math.sin(dAngle0) + stringHeight;
2897                            pt1 = new POINT2(tg.Pixels.get(0));
2898                            pt1.x -= 30 * Math.cos(dAngle1);
2899                            pt1.y -= 30 * Math.sin(dAngle1) + stringHeight;
2900                            AddIntegralAreaModifier(tg, label, area, 0, pt0, pt0, true);
2901                            AddIntegralAreaModifier(tg, label, area, 0, pt1, pt1, true);
2902                        }
2903                        break;
2904                    case TacticalLines.MSR_ONEWAY:
2905                    case TacticalLines.ASR_ONEWAY:
2906                    case TacticalLines.TRAFFIC_ROUTE_ONEWAY:
2907                    case TacticalLines.MSR_TWOWAY:
2908                    case TacticalLines.ASR_TWOWAY:
2909                    case TacticalLines.MSR_ALT:
2910                    case TacticalLines.ASR_ALT:
2911                    case TacticalLines.TRAFFIC_ROUTE_ALT:
2912                        stringWidth = (int) (1.5 * (double) metrics.stringWidth(label + TSpace + tg.get_Name()));
2913                        double arrowOffset = 10 * DPIScaleFactor;
2914                        if (linetype == TacticalLines.MSR_TWOWAY || linetype == TacticalLines.ASR_TWOWAY)
2915                            arrowOffset = 25 * DPIScaleFactor;
2916                        boolean isAlt = linetype == TacticalLines.MSR_ALT || linetype == TacticalLines.ASR_ALT || linetype == TacticalLines.TRAFFIC_ROUTE_ALT;
2917                        if (isAlt) {
2918                            stringWidth2 = (int) (1.5 * (double) metrics.stringWidth("ALT"));
2919                            if (stringWidth2 > stringWidth) {
2920                                stringWidth = stringWidth2;
2921                            }
2922                        }
2923
2924                        foundSegment = false;
2925                        //acevedo - 11/30/2017 - adding option to render only 2 labels.
2926                        if (RendererSettings.getInstance().getTwoLabelOnly() == false) {
2927                            for (j = 0; j < tg.Pixels.size() - 1; j++) {
2928                                pt0 = tg.Pixels.get(j);
2929                                pt1 = tg.Pixels.get(j + 1);
2930                                dist = lineutility.CalcDistanceDouble(pt0, pt1);
2931                                int arrowSide = arraysupport.SupplyRouteArrowSide(pt0, pt1);
2932                                if (dist < stringWidth) {
2933                                    continue;
2934                                } else {
2935                                    if (arrowSide == 1 || arrowSide == 2) {
2936                                        // Shift points to account for arrow shift with DPI
2937                                        pt0 = lineutility.ExtendDirectedLine(pt1, pt0, pt0, arrowSide, arrowOffset);
2938                                        pt1 = lineutility.ExtendDirectedLine(pt1, pt0, pt1, arrowSide, arrowOffset);
2939                                        AddModifier(tg, label + TSpace + tg.get_Name(), aboveMiddle, -1.7 * csFactor, pt0, pt1);
2940                                        if (isAlt)
2941                                            AddModifier(tg, "ALT", aboveMiddle, 0, pt0, pt1);
2942                                    } else {
2943                                        AddModifier(tg, label + TSpace + tg.get_Name(), aboveMiddle, -0.7 * csFactor, pt0, pt1);
2944                                        if (isAlt) {
2945                                            pt0 = lineutility.ExtendDirectedLine(pt1, pt0, pt0, arrowSide, arrowOffset);
2946                                            pt1 = lineutility.ExtendDirectedLine(pt1, pt0, pt1, arrowSide, arrowOffset);
2947                                            AddModifier(tg, "ALT", aboveMiddle, 0, pt0, pt1);
2948                                        }
2949                                    }
2950                                    foundSegment = true;
2951                                }
2952                            }
2953                            if (foundSegment == false) {
2954                                pt0 = tg.Pixels.get(middleSegment);
2955                                pt1 = tg.Pixels.get(middleSegment + 1);
2956                                int arrowSide = arraysupport.SupplyRouteArrowSide(pt0, pt1);
2957                                if (arrowSide == 1 || arrowSide == 2) {
2958                                    // Shift points to account for arrow shift with DPI
2959                                    pt0 = lineutility.ExtendDirectedLine(pt1, pt0, pt0, arrowSide, arrowOffset);
2960                                    pt1 = lineutility.ExtendDirectedLine(pt1, pt0, pt1, arrowSide, arrowOffset);
2961                                    AddModifier(tg, label + TSpace + tg.get_Name(), aboveMiddle, -1.7 * csFactor, pt0, pt1);
2962                                    if (isAlt)
2963                                        AddModifier(tg, "ALT", aboveMiddle, 0, pt0, pt1);
2964                                } else {
2965                                    AddModifier(tg, label + TSpace + tg.get_Name(), aboveMiddle, -0.7 * csFactor, pt0, pt1);
2966                                    if (isAlt) {
2967                                        pt0 = lineutility.ExtendDirectedLine(pt1, pt0, pt0, arrowSide, arrowOffset);
2968                                        pt1 = lineutility.ExtendDirectedLine(pt1, pt0, pt1, arrowSide, arrowOffset);
2969                                        AddModifier(tg, "ALT", aboveMiddle, 0, pt0, pt1);
2970                                    }
2971                                }
2972                            }
2973                        } else {
2974                            // 2 labels one to the north and the other to the south of graphic.
2975                            northestPtIndex = 0;
2976                            northestPt = tg.Pixels.get(northestPtIndex);
2977                            southestPtIndex = 0;
2978                            southestPt = tg.Pixels.get(southestPtIndex);
2979
2980                            for (j = 0; j < tg.Pixels.size() - 1; j++) {
2981                                pt0 = tg.Pixels.get(j);
2982                                if (pt0.y >= northestPt.y) {
2983                                    northestPt = pt0;
2984                                    northestPtIndex = j;
2985                                }
2986                                if (pt0.y <= southestPt.y) {
2987                                    southestPt = pt0;
2988                                    southestPtIndex = j;
2989                                }
2990                            }
2991
2992                            AddIntegralModifier(tg, label + TSpace + tg.get_Name(), aboveMiddle, -1.7 * csFactor, northestPtIndex, northestPtIndex + 1, false);
2993                            if (isAlt)
2994                                AddIntegralModifier(tg, "ALT", aboveMiddle, -0.7 * csFactor, northestPtIndex, northestPtIndex + 1, false);
2995
2996                            if (northestPtIndex != southestPtIndex) {
2997                                AddIntegralModifier(tg, label + TSpace + tg.get_Name(), aboveMiddle, -1.7 * csFactor, southestPtIndex, southestPtIndex + 1, false);
2998                                if (isAlt)
2999                                    AddIntegralModifier(tg, "ALT", aboveMiddle, -0.7 * csFactor, southestPtIndex, southestPtIndex + 1, false);
3000                            }
3001                        }//else
3002                        break;
3003                    case TacticalLines.DHA_REVD:
3004                        AddIntegralAreaModifier(tg, "DETAINEE", area, -1.5 * csFactor, ptCenter, ptCenter, false);
3005                        AddIntegralAreaModifier(tg, "HOLDING", area, -0.5 * csFactor, ptCenter, ptCenter, false);
3006                        AddIntegralAreaModifier(tg, "AREA", area, 0.5 * csFactor, ptCenter, ptCenter, false);
3007                        AddIntegralAreaModifier(tg, tg.get_Name(), area, 1.5 * csFactor, ptCenter, ptCenter, false);
3008                        break;
3009                    case TacticalLines.EPW:
3010                        AddIntegralAreaModifier(tg, "EPW", area, -1.5 * csFactor, ptCenter, ptCenter, false);
3011                        AddIntegralAreaModifier(tg, "HOLDING", area, -0.5 * csFactor, ptCenter, ptCenter, false);
3012                        AddIntegralAreaModifier(tg, "AREA", area, 0.5 * csFactor, ptCenter, ptCenter, false);
3013                        AddIntegralAreaModifier(tg, tg.get_Name(), area, 1.5 * csFactor, ptCenter, ptCenter, false);
3014                        break;
3015                    case TacticalLines.UXO:
3016                        addModifierOnLine("UXO", tg, true);
3017                        break;
3018                    case TacticalLines.GENERAL:
3019                        addNModifier(tg);
3020                        break;
3021                    case TacticalLines.DHA:
3022                    case TacticalLines.KILL_ZONE:
3023                    case TacticalLines.FARP:
3024                        AddIntegralAreaModifier(tg, label, area, -0.5 * csFactor, ptCenter, ptCenter, false);
3025                        AddIntegralAreaModifier(tg, tg.get_Name(), area, 0.5 * csFactor, ptCenter, ptCenter, false);
3026                        break;
3027                    case TacticalLines.BSA:
3028                    case TacticalLines.DSA:
3029                    case TacticalLines.CSA:
3030                    case TacticalLines.RSA:
3031                        AddIntegralAreaModifier(tg, label, area, 0, ptCenter, ptCenter, false);
3032                        break;
3033                    case TacticalLines.RHA:
3034                        AddIntegralAreaModifier(tg, "REFUGEE", area, -1.5 * csFactor, ptCenter, ptCenter, false);
3035                        AddIntegralAreaModifier(tg, "HOLDING", area, -0.5 * csFactor, ptCenter, ptCenter, false);
3036                        AddIntegralAreaModifier(tg, "AREA", area, 0.5 * csFactor, ptCenter, ptCenter, false);
3037                        AddIntegralAreaModifier(tg, tg.get_Name(), area, 1.5 * csFactor, ptCenter, ptCenter, false);
3038                        break;
3039                    case TacticalLines.MSR:
3040                    case TacticalLines.ASR:
3041                    case TacticalLines.TRAFFIC_ROUTE:
3042                        //AddIntegralModifier(tg, label + tg.get_Name(), aboveMiddle, -1*csFactor, middleSegment, middleSegment + 1,false);
3043                        foundSegment = false;
3044                        //acevedo - 11/30/2017 - adding option to render only 2 labels.
3045                        if (RendererSettings.getInstance().getTwoLabelOnly() == false) {
3046                            for (j = 0; j < tg.Pixels.size() - 1; j++) {
3047                                pt0 = tg.Pixels.get(j);
3048                                pt1 = tg.Pixels.get(j + 1);
3049                                stringWidth = (int) (1.5 * (double) metrics.stringWidth(label + TSpace + tg.get_Name()));
3050                                dist = lineutility.CalcDistanceDouble(pt0, pt1);
3051                                if (dist < stringWidth) {
3052                                    continue;
3053                                } else {
3054                                    AddIntegralModifier(tg, label + TSpace + tg.get_Name(), aboveMiddle, -1 * csFactor, j, j + 1, false);
3055                                    foundSegment = true;
3056                                }
3057                            }
3058                            if (foundSegment == false) {
3059                                AddIntegralModifier(tg, label + TSpace + tg.get_Name(), aboveMiddle, -1 * csFactor, middleSegment, middleSegment + 1, false);
3060                            }
3061                        } else {
3062                            // 2 labels one to the north and the other to the south of graphic.
3063                            for (j = 0; j < tg.Pixels.size(); j++) {
3064                                pt0 = tg.Pixels.get(j);
3065
3066                                if (northestPt == null) {
3067                                    northestPt = pt0;
3068                                    northestPtIndex = j;
3069                                }
3070                                if (southestPt == null) {
3071                                    southestPt = pt0;
3072                                    southestPtIndex = j;
3073                                }
3074                                if (pt0.y >= northestPt.y) {
3075                                    northestPt = pt0;
3076                                    northestPtIndex = j;
3077                                }
3078
3079                                if (pt0.y <= southestPt.y) {
3080                                    southestPt = pt0;
3081                                    southestPtIndex = j;
3082                                }
3083                            }//for
3084                            middleSegment = northestPtIndex;
3085                            middleSegment2 = southestPtIndex;
3086
3087                            if (middleSegment == tg.Pixels.size() - 1) {
3088                                middleSegment -= 1;
3089                            }
3090                            if (middleSegment2 == tg.Pixels.size() - 1) {
3091                                middleSegment2 -= 1;
3092                            }
3093                            if (middleSegment == middleSegment2) {
3094                                middleSegment2 -= 1;
3095                            }
3096
3097                            // if (middleSegment != middleSegment2) {
3098                            AddIntegralModifier(tg, label + TSpace + tg.get_Name(), aboveMiddle, 0, middleSegment, middleSegment + 1, false);
3099                            //}
3100                            AddIntegralModifier(tg, label + TSpace + tg.get_Name(), aboveMiddle, 0, middleSegment2, middleSegment2 + 1, false);
3101
3102                        }//else
3103                        break;
3104                    case TacticalLines.TRIP:
3105                        foundSegment = false;
3106                        stringWidth = (int) (1.5 * (double) metrics.stringWidth(label));
3107                        for (j = 0; j < tg.Pixels.size() - 1; j++) {
3108                            pt0 = tg.Pixels.get(j);
3109                            pt1 = tg.Pixels.get(j + 1);
3110                            midPt = lineutility.MidPointDouble(pt0, pt1, 0);
3111                            dist = lineutility.CalcDistanceDouble(pt0, pt1);
3112                            if (dist > stringWidth) {
3113                                AddModifier2(tg, label, aboveMiddle, -0.7 * csFactor, midPt, midPt, false);
3114                                foundSegment = true;
3115                            }
3116                        }
3117                        if (!foundSegment) {
3118                            midPt = lineutility.MidPointDouble(tg.Pixels.get(middleSegment), tg.Pixels.get(middleSegment + 1), 0);
3119                            AddModifier2(tg, label, aboveMiddle, -0.7 * csFactor, midPt, midPt, false);
3120                        }
3121                        break;
3122                    case TacticalLines.GAP:
3123                        if (tg.Pixels.get(1).y > tg.Pixels.get(0).y) {
3124                            pt0 = tg.Pixels.get(1);
3125                            pt1 = tg.Pixels.get(3);
3126                            pt2 = tg.Pixels.get(0);
3127                            pt3 = tg.Pixels.get(2);
3128                        } else {
3129                            pt0 = tg.Pixels.get(0);
3130                            pt1 = tg.Pixels.get(2);
3131                            pt2 = tg.Pixels.get(1);
3132                            pt3 = tg.Pixels.get(3);
3133                        }
3134                        pt2 = lineutility.ExtendAlongLineDouble2(pt0, pt2, -20);
3135                        pt3 = lineutility.ExtendAlongLineDouble2(pt1, pt3, -20);
3136                        AddIntegralAreaModifier(tg, tg.get_Name(), aboveMiddle, 0, pt0, pt1, false);
3137                        addDTG(tg, aboveMiddle, 0, csFactor, pt2, pt3, metrics);
3138                        break;
3139                    case TacticalLines.BIO:
3140                    case TacticalLines.BIOT:
3141                    case TacticalLines.CHEM:
3142                    case TacticalLines.CHEMT:
3143                    case TacticalLines.NUC:
3144                    case TacticalLines.RAD:
3145                    case TacticalLines.RADT:
3146                        AddIntegralAreaModifier(tg, getImageModifier(tg), areaImage, 0, ptCenter, ptCenter, false);
3147                        break;
3148                    case TacticalLines.ANCHORAGE_LINE:
3149                        AddIntegralAreaModifier(tg, getImageModifier(tg), aboveMiddle, -0.15 * csFactor, tg.Pixels.get(middleSegment), tg.Pixels.get(middleSegment + 1), false);
3150                        break;
3151                    case TacticalLines.ANCHORAGE_AREA:
3152                        // Add anchor on segment with lowest midpoint
3153                        y = pt0.y + pt1.y;
3154                        index = 0;
3155                        for (j = 1; j < size - 1; j++) {
3156                            if (y < tg.Pixels.get(j).y + tg.Pixels.get(j + 1).y) {
3157                                index = j;
3158                                y = tg.Pixels.get(index).y + tg.Pixels.get(index + 1).y;
3159                            }
3160                        }
3161                        AddIntegralAreaModifier(tg, getImageModifier(tg), aboveMiddle, -0.25 * csFactor, tg.Pixels.get(index), tg.Pixels.get(index + 1), false);
3162                        break;
3163                    case TacticalLines.MINE_LINE:
3164                        AddIntegralAreaModifier(tg, getImageModifier(tg), aboveMiddle, -0.2 * csFactor, tg.Pixels.get(middleSegment), tg.Pixels.get(middleSegment + 1), false);
3165                        if (tg.isHostile()) {
3166                            AddIntegralAreaModifier(tg, tg.get_N(), toEnd, 0.0, pt0, pt1, false);
3167                            AddIntegralAreaModifier(tg, tg.get_N(), toEnd, 0.0, ptLast, ptNextToLast, false);
3168                        }
3169                        break;
3170                    case TacticalLines.DEPICT:
3171                        GetMBR(tg, ul, ur, lr, ll);
3172                        addNModifier(tg);
3173                        AddIntegralAreaModifier(tg, getImageModifier(tg), areaImage, 0, ptCenter, ptCenter, false);
3174                        break;
3175                    case TacticalLines.FFA:
3176                    case TacticalLines.RFA:
3177                    case TacticalLines.NFA:
3178                        AddIntegralAreaModifier(tg, label, area, -1 * csFactor, ptCenter, ptCenter, false);
3179                        AddIntegralAreaModifier(tg, tg.get_Name(), area, 0, ptCenter, ptCenter, false);
3180                        addDTG(tg, area, 1 * csFactor, 2 * csFactor, ptCenter, ptCenter, metrics);
3181                        break;
3182                    case TacticalLines.PAA:
3183                        addModifierOnLine("PAA", tg);
3184                        AddIntegralAreaModifier(tg, tg.get_Name(), area, -0.5 * csFactor, ptCenter, ptCenter, false);
3185                        addDTG(tg, area, 0.5 * csFactor, 1.5 * csFactor, ptCenter, ptCenter, metrics);
3186                        break;
3187                    case TacticalLines.FSA:
3188                        AddIntegralAreaModifier(tg, label + TSpace + tg.get_Name(), area, -0.5 * csFactor, ptCenter, ptCenter, false);
3189                        addDTG(tg, area, 0.5 * csFactor, 1.5 * csFactor, ptCenter, ptCenter, metrics);
3190                        break;
3191                    case TacticalLines.ATI:
3192                    case TacticalLines.CFFZ:
3193                    case TacticalLines.CFZ:
3194                    case TacticalLines.TBA:
3195                    case TacticalLines.TVAR:
3196                    case TacticalLines.ZOR:
3197                    case TacticalLines.DA:
3198                    case TacticalLines.SENSOR:
3199                    case TacticalLines.CENSOR:
3200                    case TacticalLines.KILLBOXBLUE:
3201                    case TacticalLines.KILLBOXPURPLE:
3202                        AddIntegralAreaModifier(tg, label, area, -0.5 * csFactor, ptCenter, ptCenter, false);
3203                        AddIntegralAreaModifier(tg, tg.get_Name(), area, 0.5 * csFactor, ptCenter, ptCenter, false);
3204
3205                        //DTG label top left point of BBOX
3206                        /*GetMBR(tg, ul, ur, lr, ll);
3207                        POINT2 ptLeft = ul;
3208                        POINT2 ptRight = ur;
3209                        //if (tg.get_Client().equalsIgnoreCase("ge")) {
3210                        //    ptLeft.x -= font.getSize() / 2;
3211                        //    ptRight.x -= font.getSize() / 2;}
3212
3213                        AddIntegralAreaModifier(tg, tg.get_DTG() + WDash, toEnd, 0.5 * csFactor, ptLeft, ptRight, false, "W");
3214                        AddIntegralAreaModifier(tg, tg.get_DTG1(), toEnd, 1.5 * csFactor, ptLeft, ptRight, false, "W1");//*/
3215
3216                        //DTG Labels at highest left-of-center point
3217                        //Could be more expensive than the bbox approximation above if there are a lot of points.
3218                        POINT2 highest = getHighestPointLeftOfCenter(tg.Pixels,ptCenter);
3219                        AddIntegralAreaModifier(tg, tg.get_DTG() + WDash, toEnd, 0.5 * csFactor, highest, new POINT2(highest.x + 0.001, highest.y), false, "W");
3220                        AddIntegralAreaModifier(tg, tg.get_DTG1(), toEnd, 1.5 * csFactor, highest, new POINT2(highest.x + 0.001, highest.y), false, "W1");
3221                        break;
3222                    case TacticalLines.BATTLE:
3223                    case TacticalLines.STRONG:
3224                        AddIntegralAreaModifier(tg, tg.get_Name(), area, 0, ptCenter, ptCenter, false);
3225                        addModifierBottomSegment(tg, tg.get_EchelonSymbol());
3226                        break;
3227                    case TacticalLines.PNO:
3228                        AddIntegralAreaModifier(tg, label + TSpace + tg.get_Name(), area, 0, ptCenter, ptCenter, false);
3229                        addModifierBottomSegment(tg, tg.get_EchelonSymbol());
3230                        addNModifier(tg);
3231                        break;
3232                    case TacticalLines.WFZ_REVD:
3233                        AddIntegralAreaModifier(tg, label, area, -1.5 * csFactor, ptCenter, ptCenter, true);
3234                        AddIntegralAreaModifier(tg, tg.get_Name(), area, -0.5 * csFactor, ptCenter, ptCenter, true);
3235                        AddIntegralAreaModifier(tg, "TIME FROM: " + tg.get_DTG(), area, 0.5 * csFactor, ptCenter, ptCenter, true, "W");
3236                        AddIntegralAreaModifier(tg, "TIME TO: " + tg.get_DTG1(), area, 1.5 * csFactor, ptCenter, ptCenter, true, "W1");
3237                        break;
3238                    case TacticalLines.WFZ:
3239                        AddIntegralAreaModifier(tg, label, area, -2.5 * csFactor, ptCenter, ptCenter, true);
3240                        AddIntegralAreaModifier(tg, tg.get_Name(), area, -1.5 * csFactor, ptCenter, ptCenter, true);
3241                        AddIntegralAreaModifier(tg, "TIME FROM: " + tg.get_DTG(), area, -0.5 * csFactor, ptCenter, ptCenter, true, "W");
3242                        AddIntegralAreaModifier(tg, "TIME TO: " + tg.get_DTG1(), area, 0.5 * csFactor, ptCenter, ptCenter, true, "W1");
3243                        AddIntegralAreaModifier(tg, "MIN ALT: " + tg.get_X(), area, 1.5 * csFactor, ptCenter, ptCenter, false, "H");
3244                        AddIntegralAreaModifier(tg, "MAX ALT: " + tg.get_X1(), area, 2.5, ptCenter, ptCenter, false, "H1");
3245                        break;
3246                    case TacticalLines.OBSFAREA:
3247                        AddIntegralAreaModifier(tg, label, area, -1.5 * csFactor, ptCenter, ptCenter, false);
3248                        AddIntegralAreaModifier(tg, tg.get_Name(), area, -0.5 * csFactor, ptCenter, ptCenter, false);
3249                        AddIntegralAreaModifier(tg, tg.get_DTG() + WDash, area, 0.5 * csFactor, ptCenter, ptCenter, false, "W");
3250                        AddIntegralAreaModifier(tg, tg.get_DTG1(), area, 1.5 * csFactor, ptCenter, ptCenter, false, "W1");
3251                        break;
3252                    case TacticalLines.OBSAREA:
3253                        AddIntegralAreaModifier(tg, tg.get_Name(), area, -1 * csFactor, ptCenter, ptCenter, true);
3254                        AddIntegralAreaModifier(tg, tg.get_DTG() + WDash, area, 0, ptCenter, ptCenter, true, "W");
3255                        AddIntegralAreaModifier(tg, tg.get_DTG1(), area, 1 * csFactor, ptCenter, ptCenter, true, "W1");
3256                        break;
3257                    case TacticalLines.ROZ:
3258                    case TacticalLines.AARROZ:
3259                    case TacticalLines.UAROZ:
3260                    case TacticalLines.WEZ:
3261                    case TacticalLines.FEZ:
3262                    case TacticalLines.JEZ:
3263                    case TacticalLines.FAADZ:
3264                    case TacticalLines.HIDACZ:
3265                    case TacticalLines.MEZ:
3266                    case TacticalLines.LOMEZ:
3267                    case TacticalLines.HIMEZ:
3268                        AddIntegralAreaModifier(tg, label, area, -2.5, ptCenter, ptCenter, false, "");
3269                        AddIntegralAreaModifier(tg, tg.get_Name(), area, -1.5, ptCenter, ptCenter, false, "T");
3270                        AddIntegralAreaModifier(tg, "MIN ALT: " + tg.get_X(), area, -0.5, ptCenter, ptCenter, false, "H");
3271                        AddIntegralAreaModifier(tg, "MAX ALT: " + tg.get_X1(), area, 0.5, ptCenter, ptCenter, false, "H1");
3272                        AddIntegralAreaModifier(tg, "TIME FROM: " + tg.get_DTG(), area, 1.5, ptCenter, ptCenter, false, "W");
3273                        AddIntegralAreaModifier(tg, "TIME TO: " + tg.get_DTG1(), area, 2.5, ptCenter, ptCenter, false, "W1");
3274                        break;
3275                    case TacticalLines.ENCIRCLE:
3276                        if (tg.isHostile()) {
3277                            AddIntegralModifier(tg, tg.get_N(), aboveMiddle, 0, 0, 1, true);
3278                            AddIntegralModifier(tg, tg.get_N(), aboveMiddle, 0, middleSegment, middleSegment + 1, true);
3279                        }
3280                        break;
3281                    case TacticalLines.LAA:
3282                        AddIntegralAreaModifier(tg, getImageModifier(tg), areaImage, 0, ptCenter, ptCenter, false);
3283                        AddIntegralAreaModifier(tg, label, area, -1 * csFactor, ptCenter, ptCenter, false);
3284                        break;
3285                    case TacticalLines.BOUNDARY:
3286                        if (clipRect != null) {
3287                            AddBoundaryModifiers(tg, g2d, clipRect);
3288                        } else {
3289                            AddBoundaryModifiers(tg, g2d, clipArray);
3290                        }
3291                        break;
3292                    case TacticalLines.CFL:
3293                        stringWidth = (int) ((double) metrics.stringWidth(label + TSpace + tg.get_Name()));
3294                        stringWidth2 = (int) ((double) metrics.stringWidth(tg.get_DTG() + WDash + tg.get_DTG1()));
3295                        if (stringWidth2 > stringWidth) {
3296                            stringWidth = stringWidth2;
3297                        }
3298                        pt0 = new POINT2(tg.Pixels.get(middleSegment));
3299                        pt1 = new POINT2(tg.Pixels.get(middleSegment + 1));
3300                        getPixelsMiddleSegment(tg, stringWidth, pt0, pt1);
3301                        AddModifier2(tg, label + TSpace + tg.get_Name(), aboveMiddle, -0.7 * csFactor, pt0, pt1, false);
3302                        addDTG(tg, aboveMiddle, 0.7 * csFactor, 1.7 * csFactor, pt0, pt1, metrics);
3303                        break;
3304                    case TacticalLines.FLOT:
3305                        if (tg.get_H().equals("1")) {
3306                            label = "LC";
3307                        } else if (tg.get_H().equals("2")) {
3308                            label = "";
3309                        }
3310                        AddIntegralAreaModifier(tg, label, toEnd, 0, pt0, pt1, false);
3311                        AddIntegralAreaModifier(tg, label, toEnd, 0, ptLast, ptNextToLast, false);
3312
3313                        if (tg.isHostile()) {
3314                            AddIntegralAreaModifier(tg, tg.get_N(), toEnd, -1 * csFactor, pt0, pt1, false);
3315                            AddIntegralAreaModifier(tg, tg.get_N(), toEnd, -1 * csFactor, ptLast, ptNextToLast, false);
3316                        }
3317                        break;
3318                    case TacticalLines.LC:
3319                        double shiftFactor = 1d;
3320                        if (shiftLines) {
3321                            shiftFactor = 0.5d;
3322                        }
3323                        if (tg.isHostile()) {
3324                            if (pt0.x < pt1.x) {
3325                                TLineFactor = -shiftFactor;//was -1
3326                            } else {
3327                                TLineFactor = shiftFactor;//was 1
3328                            }
3329                            AddIntegralAreaModifier(tg, tg.get_N(), toEnd, TLineFactor, pt0, pt1, false);
3330                            if (ptNextToLast.x < ptLast.x) {
3331                                TLineFactor = -shiftFactor;//was -1
3332                            } else {
3333                                TLineFactor = shiftFactor;//was 1
3334                            }
3335                            AddIntegralAreaModifier(tg, tg.get_N(), toEnd, TLineFactor, ptLast, ptNextToLast, false);
3336                        }
3337                        AddIntegralAreaModifier(tg, label, toEnd, 0, pt0, pt1, false);
3338                        AddIntegralAreaModifier(tg, label, toEnd, 0, ptLast, ptNextToLast, false);
3339                        break;
3340                    case TacticalLines.CATK:
3341                        AddIntegralModifier(tg, label, aboveMiddle, 0, 1, 0, false);
3342                        break;
3343                    case TacticalLines.CATKBYFIRE:
3344                        stringWidth = (int) (1.5 * (double) metrics.stringWidth(label));
3345                        pt2 = lineutility.ExtendAlongLineDouble(pt0, pt1, stringWidth);
3346                        AddModifier2(tg, label, aboveMiddle, 0, pt1, pt2, false);
3347                        break;
3348                    case TacticalLines.IL:
3349                        AddIntegralModifier(tg, tg.get_Name(), aboveMiddle, 0, 1, 0, false);
3350                        break;
3351                    case TacticalLines.RETIRE:
3352                    case TacticalLines.PURSUIT:
3353                    case TacticalLines.WITHDRAW:
3354                    case TacticalLines.DISENGAGE:
3355                    case TacticalLines.WDRAWUP:
3356                    case TacticalLines.FPOL:
3357                    case TacticalLines.RPOL:
3358                    case TacticalLines.DEMONSTRATE:
3359                        AddIntegralModifier(tg, label, aboveMiddle, 0, 0, 1, true);
3360                        break;
3361                    case TacticalLines.RIP:
3362                    case TacticalLines.BOMB:
3363                    case TacticalLines.TGMF:
3364                        AddIntegralAreaModifier(tg, label, area, 0, ptCenter, ptCenter, true);
3365                        break;
3366                    case TacticalLines.MSDZ:
3367                        AddIntegralAreaModifier(tg, "1", area, 0, pt1, pt1, true);
3368                        AddIntegralAreaModifier(tg, "2", area, 0, pt2, pt2, true);
3369                        AddIntegralAreaModifier(tg, "3", area, 0, pt3, pt3, true);
3370                        break;
3371                    case TacticalLines.DELAY:
3372                        AddIntegralModifier(tg, tg.get_DTG(), aboveMiddle, -1 * csFactor, 0, 1, false);
3373                        AddIntegralModifier(tg, label, aboveMiddle, 0, 0, 1, true);
3374                        break;
3375                    case TacticalLines.GENERIC_LINE:
3376                        pt0 = tg.Pixels.get(0);
3377                        pt1 = tg.Pixels.get(1);
3378                        pt2 = tg.Pixels.get(tg.Pixels.size() - 1);
3379                        pt3 = tg.Pixels.get(tg.Pixels.size() - 2);
3380                        dist = lineutility.CalcDistanceDouble(pt0, pt1);
3381                        dist2 = lineutility.CalcDistanceDouble(pt2, pt3);
3382                        stringWidth = (int) ((double) metrics.stringWidth(tg.get_H() + " " + tg.get_Name()));
3383                        stringWidth2 = (int) ((double) metrics.stringWidth(tg.get_DTG()));
3384                        if (stringWidth2 > stringWidth) {
3385                            stringWidth = stringWidth2;
3386                        }
3387
3388                        if (tg.Pixels.size() == 2) //one segment
3389                        {
3390                            pt1 = lineutility.ExtendAlongLineDouble(pt0, pt1, stringWidth);
3391                            AddModifier2(tg, tg.get_H() + " " + tg.get_Name(), aboveMiddle, -0.7 * csFactor, pt0, pt1, false);
3392                            AddModifier2(tg, tg.get_DTG() + WDash, aboveMiddle, 0.7 * csFactor, pt0, pt1, false);
3393                            AddModifier2(tg, tg.get_DTG1(), aboveMiddle, 1.7 * csFactor, pt0, pt1, false);
3394                            if (dist > 3.5 * stringWidth)//was 28stringwidth+5
3395                            {
3396                                pt0 = tg.Pixels.get(tg.Pixels.size() - 1);
3397                                pt1 = tg.Pixels.get(tg.Pixels.size() - 2);
3398                                pt1 = lineutility.ExtendAlongLineDouble(pt0, pt1, stringWidth);
3399                                AddModifier2(tg, tg.get_H() + " " + tg.get_Name(), aboveMiddle, -0.7 * csFactor, pt0, pt1, false);
3400                                AddModifier2(tg, tg.get_DTG() + WDash, aboveMiddle, 0.7 * csFactor, pt0, pt1, false);
3401                                AddModifier2(tg, tg.get_DTG1(), aboveMiddle, 1.7 * csFactor, pt0, pt1, false);
3402                            }
3403                        } else //more than one semgent
3404                        {
3405                            double dist3 = lineutility.CalcDistanceDouble(pt0, pt2);
3406                            if (dist > stringWidth + 5 || dist >= dist2 || dist3 > stringWidth + 5) {
3407                                pt1 = lineutility.ExtendAlongLineDouble(pt0, pt1, stringWidth);
3408                                AddModifier2(tg, tg.get_H() + " " + tg.get_Name(), aboveMiddle, -0.7 * csFactor, pt0, pt1, false);
3409                                AddModifier2(tg, tg.get_DTG() + WDash, aboveMiddle, 0.7 * csFactor, pt0, pt1, false);
3410                                AddModifier2(tg, tg.get_DTG1(), aboveMiddle, 1.7 * csFactor, pt0, pt1, false);
3411                            }
3412                            if (dist2 > stringWidth + 5 || dist2 > dist || dist3 > stringWidth + 5) {
3413                                pt0 = tg.Pixels.get(tg.Pixels.size() - 1);
3414                                pt1 = tg.Pixels.get(tg.Pixels.size() - 2);
3415                                pt1 = lineutility.ExtendAlongLineDouble(pt0, pt1, stringWidth);
3416                                AddModifier2(tg, tg.get_H() + " " + tg.get_Name(), aboveMiddle, -0.7 * csFactor, pt0, pt1, false);
3417                                AddModifier2(tg, tg.get_DTG() + WDash, aboveMiddle, 0.7 * csFactor, pt0, pt1, false);
3418                                AddModifier2(tg, tg.get_DTG1(), aboveMiddle, 1.7 * csFactor, pt0, pt1, false);
3419                            }
3420                        }
3421                        break;
3422                    default:
3423                        break;
3424                }
3425            }
3426            scaleModifiers(tg);
3427            tg.Pixels = origPoints;
3428        } catch (Exception exc) {
3429            ErrorLogger.LogException(_className, "AddModifiersGeo",
3430                    new RendererException("Failed inside AddModifiersGeo", exc));
3431        }
3432
3433    }
3434
3435    /**
3436     * RFA, NFA, FFA need these for line spacing
3437     *
3438     * @param tg
3439     * @return
3440     */
3441    private static int getRFALines(TGLight tg) {
3442        int lines = 1;
3443        try {
3444            if (tg.get_Name() != null && !tg.get_Name().isEmpty()) {
3445                lines++;
3446            }
3447            if (tg.get_DTG() != null && !tg.get_DTG().isEmpty()) {
3448                lines++;
3449            } else if (tg.get_DTG1() != null && !tg.get_DTG1().isEmpty()) {
3450                lines++;
3451            }
3452        } catch (Exception exc) {
3453            ErrorLogger.LogException(_className, "AddModifiers",
3454                    new RendererException("Failed inside AddModifiers", exc));
3455        }
3456        return lines;
3457    }
3458
3459    /**
3460     * Added sector range fan modifiers based using the calculated orientation
3461     * indicator points
3462     *
3463     * @param tg
3464     * @param converter
3465     * @return
3466     */
3467    private static void addSectorModifiers(TGLight tg, IPointConversion converter) {
3468        try {
3469            if (tg.get_LineType() == TacticalLines.RANGE_FAN_SECTOR) {
3470                ArrayList<Double> AM = new ArrayList<>();
3471                ArrayList<Double> AN = new ArrayList<>();
3472                //get the number of sectors
3473                String X = tg.get_X();
3474                String[] altitudes = null;
3475                String[] am = tg.get_AM().split(",");
3476                String[] an = tg.get_AN().split(",");
3477                int numSectors = an.length / 2;
3478                //there must be at least one sector
3479                if (numSectors < 1) {
3480                    return;
3481                }
3482                if (!X.isEmpty()) {
3483                    altitudes = X.split(",");
3484                }
3485                try {
3486                    for (String s : am) {
3487                        AM.add(Double.parseDouble(s));
3488                    }
3489                    for (String s : an) {
3490                        AN.add(Double.parseDouble(s));
3491                    }
3492                } catch (NumberFormatException e) {
3493                    return;
3494                }
3495                if (numSectors + 1 > AM.size()) {
3496                    if (Double.parseDouble(am[0]) != 0d) {
3497                        AM.add(0, 0d);
3498                    }
3499                }
3500
3501                int n = tg.Pixels.size();
3502                //pt0 and pt1 are points for the location indicator
3503                POINT2 pt0 = tg.Pixels.get(n - 5);
3504                POINT2 pt1 = tg.Pixels.get(n - 4);
3505                Point2D pt02d = new Point2D.Double(pt0.x, pt0.y);
3506                Point2D pt12d = new Point2D.Double(pt1.x, pt1.y);
3507                pt02d = converter.PixelsToGeo(pt02d);
3508                pt12d = converter.PixelsToGeo(pt12d);
3509                pt0.x = pt02d.getX();
3510                pt0.y = pt02d.getY();
3511                pt1.x = pt12d.getX();
3512                pt1.y = pt12d.getY();
3513                //azimuth of the orientation indicator
3514                double az12 = mdlGeodesic.GetAzimuth(pt0, pt1);
3515
3516                POINT2 pt2 = null;
3517                ArrayList<POINT2> locModifier = new ArrayList();
3518                //diagnostic
3519                POINT2 ptLeft = null, ptRight = null;
3520                ArrayList<POINT2> locAZModifier = new ArrayList();
3521                //end section
3522                Point2D pt22d = null;
3523                double radius = 0;
3524                for (int k = 0; k < numSectors; k++) {
3525                    if (AM.size() < k + 2) {
3526                        break;
3527                    }
3528                    radius = (AM.get(k) + AM.get(k + 1)) / 2;
3529                    pt2 = mdlGeodesic.geodesic_coordinate(pt0, radius, az12);
3530                    //need locModifier in geo pixels
3531                    pt22d = new Point2D.Double(pt2.x, pt2.y);
3532                    pt22d = converter.GeoToPixels(pt22d);
3533                    pt2.x = pt22d.getX();
3534                    pt2.y = pt22d.getY();
3535                    locModifier.add(pt2);
3536                    //diagnostic
3537                    if (tg.get_HideOptionalLabels())
3538                        continue;
3539                    ptLeft = mdlGeodesic.geodesic_coordinate(pt0, radius, AN.get(2 * k));
3540                    //need ptLeft in geo pixels
3541                    pt22d = new Point2D.Double(ptLeft.x, ptLeft.y);
3542                    pt22d = converter.GeoToPixels(pt22d);
3543                    ptLeft.x = pt22d.getX();
3544                    ptLeft.y = pt22d.getY();
3545                    ptRight = mdlGeodesic.geodesic_coordinate(pt0, radius, AN.get(2 * k + 1));
3546                    //need ptRight in geo pixels
3547                    pt22d = new Point2D.Double(ptRight.x, ptRight.y);
3548                    pt22d = converter.GeoToPixels(pt22d);
3549                    ptRight.x = pt22d.getX();
3550                    ptRight.y = pt22d.getY();
3551                    locAZModifier.add(ptLeft);
3552                    locAZModifier.add(ptRight);
3553                    //end section
3554                }
3555                if(!RendererSettings.getInstance().getGroupModifiers()) {
3556                    if (altitudes != null) {
3557                        for (int k = 0; k < altitudes.length; k++) {
3558                            if (k >= locModifier.size()) {
3559                                break;
3560                            }
3561                            pt0 = locModifier.get(k);
3562                            if(!altitudes[k].isEmpty())
3563                                AddAreaModifier(tg, "ALT " + altitudes[k], area, 0, pt0, pt0);
3564                            else
3565                                AddAreaModifier(tg, "ALT GL", area, 0, pt0, pt0);
3566                        }
3567                    }
3568
3569                    if (!tg.get_HideOptionalLabels()) {
3570                        for (int k = 0; k < numSectors; k++) {
3571                            pt0 = locModifier.get(k);
3572                            AddAreaModifier(tg, "RG " + removeDecimal(AM.get(k + 1)), area, -1, pt0, pt0);
3573                            ptLeft = locAZModifier.get(2 * k);
3574                            ptRight = locAZModifier.get(2 * k + 1);
3575                            AddAreaModifier(tg, removeDecimal(an[2 * k]), area, 0, ptLeft, ptLeft);
3576                            AddAreaModifier(tg, removeDecimal(an[2 * k + 1]), area, 0, ptRight, ptRight);
3577                        }
3578                    }
3579                }
3580                else//grouped
3581                {
3582                    if (!tg.get_HideOptionalLabels()) {
3583                        for (int k = 0; k < numSectors; k++) {
3584                            String label = "";
3585                            if (!tg.get_HideOptionalLabels())
3586                                label = "RG " + removeDecimal(AM.get(k + 1)) + "\n";
3587                            if(altitudes != null)
3588                            {
3589                                label += "ALT " + altitudes[k];
3590                            }
3591                            else
3592                                label += "ALT GL";
3593                            pt0 = locModifier.get(k);
3594                            AddAreaModifier(tg, label, area, 0, pt0, pt0);
3595                            if (!tg.get_HideOptionalLabels()) {
3596                                ptLeft = locAZModifier.get(2 * k);
3597                                ptRight = locAZModifier.get(2 * k + 1);
3598                                AddAreaModifier(tg, removeDecimal(an[2 * k]), area, 0, ptLeft, ptLeft);
3599                                AddAreaModifier(tg, removeDecimal(an[2 * k + 1]), area, 0, ptRight, ptRight);
3600                            }
3601                        }
3602                    }
3603                }
3604            } else if (tg.get_LineType() == TacticalLines.RADAR_SEARCH) {
3605                // Copies functionality from RANGE_FAN_SECTOR with one sector and different modifiers
3606                String strLeftRightMinMax = tg.get_LRMM();
3607                String[] sector = strLeftRightMinMax.split(",");
3608                double left = Double.parseDouble(sector[0]);
3609                double right = Double.parseDouble(sector[1]);
3610
3611                while (left > 360) {
3612                    left -= 360;
3613                }
3614                while (right > 360) {
3615                    right -= 360;
3616                }
3617                while (left < 0) {
3618                    left += 360;
3619                }
3620                while (right < 0) {
3621                    right += 360;
3622                }
3623
3624                double orientation = 0;
3625                if (left > right) {
3626                    orientation = (left - 360 + right) / 2;
3627                } else {
3628                    orientation = (left + right) / 2;
3629                }
3630
3631                double dist = Double.parseDouble(sector[3]);
3632                double radius = dist * 1.1;
3633
3634                POINT2 pt0 = tg.LatLongs.get(0);
3635                Point2D ptPixels = converter.GeoToPixels(new Point2D.Double(pt0.x, pt0.y));
3636                POINT2 pt0F = new POINT2();
3637                pt0F.x = ptPixels.getX();
3638                pt0F.y = ptPixels.getY();
3639                pt0F.style = pt0.style;
3640
3641                POINT2 pt1 = mdlGeodesic.geodesic_coordinate(pt0, radius, orientation);
3642                ptPixels = converter.GeoToPixels(new Point2D.Double(pt1.x, pt1.y));
3643                POINT2 pt1F = new POINT2();
3644                pt1F.x = ptPixels.getX();
3645                pt1F.y = ptPixels.getY();
3646                pt1F.style = pt1.style;
3647
3648                dist = lineutility.CalcDistanceDouble(pt0F, pt1F);
3649                double base = 10;
3650                if (dist < 100) {
3651                    base = dist / 10;
3652                }
3653                if (base < 5) {
3654                    base = 5;
3655                }
3656                double basex2 = 2 * base;
3657                POINT2 ptTipF = lineutility.ExtendAlongLineDouble(pt0F, pt1F, dist + basex2);  //was 20
3658
3659                pt0 = pt0F;
3660                pt1 = ptTipF;
3661
3662                ArrayList<Double> AM = new ArrayList<>();
3663                String[] am = tg.get_AM().split(",");
3664
3665                for (String s : am) {
3666                    AM.add(Double.parseDouble(s));
3667                }
3668
3669                if (AM.size() < 2) {
3670                    if (Double.parseDouble(am[0]) != 0d) {
3671                        AM.add(0, 0d);
3672                    } else {
3673                        return;
3674                    }
3675                }
3676
3677                Point2D pt02d = new Point2D.Double(pt0.x, pt0.y);
3678                Point2D pt12d = new Point2D.Double(pt1.x, pt1.y);
3679                pt02d = converter.PixelsToGeo(pt02d);
3680                pt12d = converter.PixelsToGeo(pt12d);
3681                pt0.x = pt02d.getX();
3682                pt0.y = pt02d.getY();
3683                pt1.x = pt12d.getX();
3684                pt1.y = pt12d.getY();
3685                double az12 = mdlGeodesic.GetAzimuth(pt0, pt1);
3686
3687                Point2D pt22d = null;
3688
3689                radius = (AM.get(0) + AM.get(1)) / 2;
3690                POINT2 pt2 = mdlGeodesic.geodesic_coordinate(pt0, radius, az12);
3691                pt22d = new Point2D.Double(pt2.x, pt2.y);
3692                pt22d = converter.GeoToPixels(pt22d);
3693                pt2.x = pt22d.getX();
3694                pt2.y = pt22d.getY();
3695                AddAreaModifier(tg, tg.get_Name(), area, -1, pt2, pt2);
3696            }
3697        } catch (Exception exc) {
3698            ErrorLogger.LogException(_className, "addSectorModifiers",
3699                    new RendererException("Failed inside addSectorModifiers", exc));
3700        }
3701    }
3702
3703    /**
3704     * Called by the renderer after tg.Pixels has been filled with the
3705     * calculated points. The modifier path depends on points calculated by
3706     * CELineArray.
3707     *
3708     * @param tg
3709     */
3710    public static void AddModifiers2(TGLight tg, IPointConversion converter) {
3711        try {
3712            if (tg.Pixels == null || tg.Pixels.isEmpty()) {
3713                return;
3714            }
3715            switch (tg.get_LineType()) {
3716                case TacticalLines.BS_RECTANGLE:
3717                case TacticalLines.BBS_RECTANGLE:
3718                case TacticalLines.CONVOY:
3719                case TacticalLines.HCONVOY:
3720                case TacticalLines.BREACH:
3721                case TacticalLines.BYPASS:
3722                case TacticalLines.CANALIZE:
3723                case TacticalLines.PENETRATE:
3724                case TacticalLines.CLEAR:
3725                case TacticalLines.DISRUPT:
3726                case TacticalLines.FIX:
3727                case TacticalLines.ISOLATE:
3728                case TacticalLines.OCCUPY:
3729                case TacticalLines.RETAIN:
3730                case TacticalLines.SECURE:
3731                case TacticalLines.CONTROL:
3732                case TacticalLines.LOCATE:
3733                case TacticalLines.AREA_DEFENSE:
3734                case TacticalLines.CONTAIN:
3735                case TacticalLines.SEIZE:
3736                case TacticalLines.CAPTURE:
3737                case TacticalLines.EVACUATE:
3738                case TacticalLines.TURN:
3739                case TacticalLines.CORDONKNOCK:
3740                case TacticalLines.CORDONSEARCH:
3741                case TacticalLines.DENY:
3742                case TacticalLines.ESCORT:
3743                case TacticalLines.EXFILTRATION:
3744                case TacticalLines.INFILTRATION:
3745                case TacticalLines.FOLLA:
3746                case TacticalLines.FOLSP:
3747                case TacticalLines.ACA_RECTANGULAR:
3748                case TacticalLines.ACA_CIRCULAR:
3749                case TacticalLines.RECTANGULAR:
3750                case TacticalLines.CUED_ACQUISITION:
3751                case TacticalLines.CIRCULAR:
3752                case TacticalLines.BDZ:
3753                case TacticalLines.BBS_POINT:
3754                case TacticalLines.FSA_CIRCULAR:
3755                case TacticalLines.NOTACK:
3756                case TacticalLines.ATI_CIRCULAR:
3757                case TacticalLines.CFFZ_CIRCULAR:
3758                case TacticalLines.SENSOR_CIRCULAR:
3759                case TacticalLines.CENSOR_CIRCULAR:
3760                case TacticalLines.DA_CIRCULAR:
3761                case TacticalLines.CFZ_CIRCULAR:
3762                case TacticalLines.ZOR_CIRCULAR:
3763                case TacticalLines.TBA_CIRCULAR:
3764                case TacticalLines.TVAR_CIRCULAR:
3765                case TacticalLines.FFA_CIRCULAR:
3766                case TacticalLines.NFA_CIRCULAR:
3767                case TacticalLines.RFA_CIRCULAR:
3768                case TacticalLines.KILLBOXBLUE_CIRCULAR:
3769                case TacticalLines.KILLBOXPURPLE_CIRCULAR:
3770                case TacticalLines.BLOCK:
3771                case TacticalLines.FFA_RECTANGULAR:
3772                case TacticalLines.NFA_RECTANGULAR:
3773                case TacticalLines.RFA_RECTANGULAR:
3774                case TacticalLines.KILLBOXBLUE_RECTANGULAR:
3775                case TacticalLines.KILLBOXPURPLE_RECTANGULAR:
3776                case TacticalLines.FSA_RECTANGULAR:
3777                case TacticalLines.SHIP_AOI_RECTANGULAR:
3778                case TacticalLines.DEFENDED_AREA_RECTANGULAR:
3779                case TacticalLines.ATI_RECTANGULAR:
3780                case TacticalLines.CFFZ_RECTANGULAR:
3781                case TacticalLines.SENSOR_RECTANGULAR:
3782                case TacticalLines.CENSOR_RECTANGULAR:
3783                case TacticalLines.DA_RECTANGULAR:
3784                case TacticalLines.CFZ_RECTANGULAR:
3785                case TacticalLines.ZOR_RECTANGULAR:
3786                case TacticalLines.TBA_RECTANGULAR:
3787                case TacticalLines.TVAR_RECTANGULAR:
3788                case TacticalLines.PAA:
3789                case TacticalLines.PAA_RECTANGULAR:
3790                case TacticalLines.RECTANGULAR_TARGET:
3791                case TacticalLines.PAA_CIRCULAR:
3792                case TacticalLines.RANGE_FAN:
3793                case TacticalLines.RANGE_FAN_SECTOR:
3794                case TacticalLines.RADAR_SEARCH:
3795                case TacticalLines.SHIP_AOI_CIRCULAR:
3796                case TacticalLines.MFLANE:
3797                case TacticalLines.ENVELOPMENT:
3798                case TacticalLines.MOBILE_DEFENSE:
3799                    break;
3800                default:
3801                    return;
3802            }
3803            //end section
3804            ArrayList<POINT2> origPoints = lineutility.getDeepCopy(tg.Pixels);
3805            int n = tg.Pixels.size();
3806            if (tg.modifiers == null) {
3807                tg.modifiers = new ArrayList();
3808            }
3809            Font font = tg.get_Font();
3810            POINT2 ptCenter = null;
3811            double csFactor = 1d;//this will be used for text spacing the 3d map (CommandCight)
3812            //String affiliation=tg.get_Affiliation();
3813            int linetype = tg.get_LineType();
3814            POINT2 pt0 = null, pt1 = null, pt2 = null, pt3 = null;
3815            int j = 0, k = 0;
3816            double dist = 0;
3817            String label = GetCenterLabel(tg);
3818            String[] X = null;
3819            int lastIndex = tg.Pixels.size() - 1;
3820            int nextToLastIndex = 0;
3821            if (tg.Pixels.size() > 1) {
3822                nextToLastIndex = tg.Pixels.size() - 2;
3823            }
3824            POINT2 ptLast = new POINT2(tg.Pixels.get(lastIndex));
3825            POINT2 ptNextToLast = null;
3826            if (tg.Pixels.size() > 1) {
3827                ptNextToLast = new POINT2(tg.Pixels.get(nextToLastIndex));
3828            }
3829            String WDash = ""; // Dash between W and W1 if they're not empty
3830            String TSpace = "", TDash = ""; // Space or dash between label and T modifier if T isn't empty
3831            if (tg.get_DTG() != null && tg.get_DTG1() != null && !tg.get_DTG().isEmpty() && !tg.get_DTG1().isEmpty()) {
3832                WDash = " - ";
3833            }
3834            if (tg.get_Name() != null && !tg.get_Name().isEmpty()) {
3835                TSpace = " ";
3836                TDash = " - ";
3837            }
3838
3839            POINT2 ptLeft = null, ptRight = null;
3840            BufferedImage bi = new BufferedImage(8, 8, BufferedImage.TYPE_INT_ARGB);
3841            Graphics2D g2d = bi.createGraphics();
3842            g2d.setFont(tg.get_Font());
3843            FontMetrics metrics = g2d.getFontMetrics();
3844            int stringWidth = 0, rfaLines = 0;
3845            pt0 = new POINT2(tg.Pixels.get(0));
3846            if (tg.Pixels.size() > 1) {
3847                pt1 = new POINT2(tg.Pixels.get(1));
3848            }
3849
3850            POINT2[] pts = null;
3851            // if the client is the 3d map (CS) then we want to shrink the spacing between
3852            // the lines of text
3853            if (tg.get_Client().equals("cpof3d")) {
3854                csFactor = 0.9d;
3855            }
3856
3857            shiftModifierPath(tg, pt0, pt1, ptLast, ptNextToLast);
3858
3859            boolean modifiersGrouped = false;
3860            if(RendererSettings.getInstance().getGroupModifiers())
3861            {
3862                switch (linetype) {
3863                    case TacticalLines.PAA_RECTANGULAR:
3864                    case TacticalLines.PAA_CIRCULAR:
3865                        //too complex to duplicate, simpler to group labels in next switch statement
3866                        break;
3867                    case TacticalLines.ACA_RECTANGULAR:
3868                    case TacticalLines.ACA_CIRCULAR:
3869                        ptCenter = lineutility.CalcCenterPointDouble2(tg.Pixels.toArray(), tg.Pixels.size());
3870                        AddIntegralAreaModifier(tg, buildAreaGroupString(tg, label), area, 0, ptCenter, ptCenter, false);
3871                        modifiersGrouped = true;
3872                        break;
3873                    case TacticalLines.FSA_CIRCULAR:
3874                    case TacticalLines.ATI_CIRCULAR:
3875                    case TacticalLines.CFFZ_CIRCULAR:
3876                    case TacticalLines.SENSOR_CIRCULAR:
3877                    case TacticalLines.CENSOR_CIRCULAR:
3878                    case TacticalLines.DA_CIRCULAR:
3879                    case TacticalLines.CFZ_CIRCULAR:
3880                    case TacticalLines.ZOR_CIRCULAR:
3881                    case TacticalLines.TBA_CIRCULAR:
3882                    case TacticalLines.TVAR_CIRCULAR:
3883                    case TacticalLines.KILLBOXBLUE_CIRCULAR:
3884                    case TacticalLines.KILLBOXPURPLE_CIRCULAR:
3885                        ptCenter = lineutility.MidPointDouble(tg.Pixels.get(0), tg.Pixels.get(tg.Pixels.size() / 2), 0);
3886                        //center labels
3887                        AddIntegralAreaModifier(tg, buildAreaGroupString(tg, label), area, 0, ptCenter, ptCenter, false);
3888                        //DTG on top left
3889                        POINT2 dtgCircularPosition = tg.Pixels.get(Math.round(tg.Pixels.size() * 0.5625f));
3890                        AddIntegralAreaModifier(tg, buildAreaGroupDTGString(tg), toEnd, -1 * csFactor, dtgCircularPosition, new POINT2(dtgCircularPosition.x + 0.001, dtgCircularPosition.y, 0), false);
3891                        modifiersGrouped = true;
3892                        break;
3893                    case TacticalLines.FFA_CIRCULAR:
3894                    case TacticalLines.NFA_CIRCULAR:
3895                    case TacticalLines.RFA_CIRCULAR:
3896                        ptCenter = lineutility.MidPointDouble(tg.Pixels.get(0), tg.Pixels.get(51), 0);
3897                        AddIntegralAreaModifier(tg, buildAreaGroupString(tg, label), area, 0, ptCenter, ptCenter, false);
3898                        modifiersGrouped = true;
3899                        break;
3900                    case TacticalLines.FFA_RECTANGULAR:
3901                    case TacticalLines.NFA_RECTANGULAR:
3902                    case TacticalLines.RFA_RECTANGULAR:
3903                        pt0 = lineutility.MidPointDouble(tg.Pixels.get(0), tg.Pixels.get(1), 0);
3904                        pt1 = lineutility.MidPointDouble(tg.Pixels.get(2), tg.Pixels.get(3), 0);
3905                        ptCenter = lineutility.MidPointDouble(pt0, pt1, 0);
3906                        AddIntegralAreaModifier(tg, buildAreaGroupString(tg, label), area, 0, ptCenter, ptCenter, false);
3907                        modifiersGrouped = true;
3908                        break;
3909                    case TacticalLines.KILLBOXBLUE_RECTANGULAR:
3910                    case TacticalLines.KILLBOXPURPLE_RECTANGULAR:
3911                    case TacticalLines.FSA_RECTANGULAR:
3912                    case TacticalLines.ATI_RECTANGULAR:
3913                    case TacticalLines.CFFZ_RECTANGULAR:
3914                    case TacticalLines.SENSOR_RECTANGULAR:
3915                    case TacticalLines.CENSOR_RECTANGULAR:
3916                    case TacticalLines.DA_RECTANGULAR:
3917                    case TacticalLines.CFZ_RECTANGULAR:
3918                    case TacticalLines.ZOR_RECTANGULAR:
3919                    case TacticalLines.TBA_RECTANGULAR:
3920                    case TacticalLines.TVAR_RECTANGULAR:
3921                        ptLeft = lineutility.MidPointDouble(tg.Pixels.get(0), tg.Pixels.get(1), 0);
3922                        ptRight = lineutility.MidPointDouble(tg.Pixels.get(2), tg.Pixels.get(3), 0);
3923                        ptCenter = lineutility.MidPointDouble(ptLeft, ptRight, 0);
3924                        AddIntegralAreaModifier(tg, buildAreaGroupString(tg,label), area, 0 * csFactor, ptCenter, ptCenter, false);
3925
3926                        //highest point left of center
3927                        POINT2 dtgPosition = getHighestPointLeftOfCenter(tg.Pixels,ptCenter);
3928
3929                        AddIntegralAreaModifier(tg, buildAreaGroupDTGString(tg), toEnd, 1 * csFactor, dtgPosition, new POINT2(dtgPosition.x + 0.001, dtgPosition.y, 0), false);
3930                        modifiersGrouped = true;
3931                        break;
3932                }
3933            }
3934
3935            if(!modifiersGrouped) {
3936                switch (linetype) {
3937                    case TacticalLines.BS_RECTANGLE:
3938                    case TacticalLines.BBS_RECTANGLE:
3939                        pts = new POINT2[4];
3940                        for (j = 0; j < 4; j++) {
3941                            pts[j] = tg.Pixels.get(j);
3942                        }
3943                        ptCenter = lineutility.CalcCenterPointDouble2(pts, 4);
3944                        AddIntegralAreaModifier(tg, tg.get_Name(), area, -0.125 * csFactor, ptCenter, ptCenter, false);
3945                        break;
3946                    case TacticalLines.CONVOY:
3947                    case TacticalLines.HCONVOY:
3948                        pt2 = lineutility.MidPointDouble(tg.Pixels.get(0), tg.Pixels.get(3), 0);
3949                        pt3 = lineutility.MidPointDouble(tg.Pixels.get(1), tg.Pixels.get(2), 0);
3950                        AddIntegralAreaModifier(tg, tg.get_V(), aboveEndInside, 0, pt2, pt3, false);
3951                        AddIntegralAreaModifier(tg, tg.get_H(), aboveStartInside, 0, pt2, pt3, false);
3952                        addDTG(tg, aboveMiddle, 1.2 * csFactor, 2.2 * csFactor, pt2, pt3, metrics);
3953                        break;
3954                    case TacticalLines.BREACH:
3955                    case TacticalLines.BYPASS:
3956                    case TacticalLines.CANALIZE:
3957                        pt0 = tg.Pixels.get(1);
3958                        pt1 = tg.Pixels.get(2);
3959                        //pt1=lineutility.ExtendAlongLineDouble(pt1, pt0, -10);
3960                        AddIntegralAreaModifier(tg, label, aboveMiddlePerpendicular, -0.125 * csFactor, pt0, pt1, true);
3961                        break;
3962                    case TacticalLines.PENETRATE:
3963                    case TacticalLines.CLEAR:
3964                        pt0 = tg.Pixels.get(2);
3965                        pt1 = tg.Pixels.get(3);
3966                        //pt1=lineutility.ExtendAlongLineDouble(pt1, pt0, -10);
3967                        AddIntegralAreaModifier(tg, label, aboveMiddle, -0.125 * csFactor, pt0, pt1, true);
3968                        break;
3969                    case TacticalLines.DISRUPT:
3970                        pt0 = tg.Pixels.get(4);
3971                        pt1 = tg.Pixels.get(5);
3972                        //pt1=lineutility.ExtendAlongLineDouble(pt1, pt0, -10);
3973                        AddIntegralAreaModifier(tg, label, aboveMiddle, -0.125 * csFactor, pt0, pt1, true);
3974                        break;
3975                    case TacticalLines.FIX:
3976                        pt0 = tg.Pixels.get(0);
3977                        pt1 = tg.Pixels.get(1);
3978                        //pt1=lineutility.ExtendAlongLineDouble(pt1, pt0, -10);
3979                        AddIntegralAreaModifier(tg, label, aboveMiddle, -0.125 * csFactor, pt0, pt1, true);
3980                        break;
3981                    case TacticalLines.ISOLATE:
3982                    case TacticalLines.OCCUPY:
3983                    case TacticalLines.RETAIN:
3984                    case TacticalLines.SECURE:
3985                    case TacticalLines.CONTROL:
3986                    case TacticalLines.LOCATE:
3987                    case TacticalLines.AREA_DEFENSE:
3988                        pt0 = tg.Pixels.get(13);
3989                        pt1 = tg.Pixels.get(14);
3990                        //pt1=lineutility.ExtendAlongLineDouble(pt1, pt0, -10);
3991                        ptCenter = lineutility.MidPointDouble(pt0, pt1, 0);
3992                        AddIntegralAreaModifier(tg, label, aboveMiddle, -0.125 * csFactor, ptCenter, ptCenter, true);
3993                        break;
3994                    case TacticalLines.CONTAIN:
3995                        pt0 = tg.Pixels.get(13);
3996                        pt1 = tg.Pixels.get(14);
3997                        //ptCenter = lineutility.MidPointDouble(pt0, pt1, 0);//maybe figure out which points are center line to apply an angle
3998                        ptCenter = tg.Pixels.get(13);//always rightside up at mid-point of curve
3999                        //pt1=lineutility.ExtendAlongLineDouble(pt1, pt0, -10);
4000                        AddIntegralAreaModifier(tg, label, aboveMiddle, -0.125 * csFactor, ptCenter, ptCenter, true);
4001
4002                        // Contain always has "ENY" even if friendly (not N modifier)
4003                        for (j = 0; j < n; j++) {
4004                            if (tg.Pixels.get(j).style == 14) {
4005                                pt0 = tg.Pixels.get(j);
4006                                pt1 = tg.Pixels.get(j + 1);
4007                                AddIntegralAreaModifier(tg, "ENY", aboveMiddle, 0, pt0, pt1, true);
4008                                break;
4009                            }
4010                        }
4011                        break;
4012                    case TacticalLines.TURN:
4013                        pt0 = tg.Pixels.get(12);
4014                        pt1 = tg.Pixels.get(13);
4015                        ptCenter = lineutility.MidPointDouble(pt0, pt1, 0);
4016                        AddIntegralAreaModifier(tg, label, area, -0.125 * csFactor, ptCenter, ptCenter, true);
4017                        break;
4018                    case TacticalLines.SEIZE:
4019                    case TacticalLines.CAPTURE:
4020                    case TacticalLines.EVACUATE:
4021                        pt0 = tg.Pixels.get(26);
4022                        pt1 = tg.Pixels.get(27);
4023                        //pt1=lineutility.ExtendAlongLineDouble(pt1, pt0, -10);
4024                        ptCenter = lineutility.MidPointDouble(pt0, pt1, 0);
4025                        AddIntegralAreaModifier(tg, label, aboveMiddle, -0.125 * csFactor, ptCenter, ptCenter, true);
4026                        break;
4027                    case TacticalLines.DEFENDED_AREA_RECTANGULAR:
4028                        ptLeft = lineutility.MidPointDouble(tg.Pixels.get(0), tg.Pixels.get(1), 0);
4029                        ptRight = lineutility.MidPointDouble(tg.Pixels.get(2), tg.Pixels.get(3), 0);
4030                        AddIntegralAreaModifier(tg, label + TDash + tg.get_Name(), aboveMiddle, 0, ptLeft, ptRight, false);
4031                        break;
4032                    case TacticalLines.SHIP_AOI_RECTANGULAR:
4033                        if (tg.Pixels.get(0).x > tg.Pixels.get(3).x) {
4034                            AddIntegralAreaModifier(tg, label, aboveMiddle, 0.6 * csFactor, tg.Pixels.get(0), tg.Pixels.get(3), false);
4035                        } else {
4036                            AddIntegralAreaModifier(tg, label, aboveMiddle, 0.6 * csFactor, tg.Pixels.get(1), tg.Pixels.get(2), false);
4037                        }
4038                        break;
4039                    case TacticalLines.NOTACK:
4040                        ptCenter = lineutility.MidPointDouble(tg.Pixels.get(0), tg.Pixels.get(tg.Pixels.size() / 2), 0);
4041                        AddIntegralAreaModifier(tg, label, area, -1, ptCenter, ptCenter, false);
4042                        addDTG(tg, area, csFactor, 2 * csFactor, ptCenter, ptCenter, metrics);
4043                        break;
4044                    case TacticalLines.SHIP_AOI_CIRCULAR:
4045                        // Moved from AddModifiersGeo()
4046                        // AddModifiersGeo() called before getGeoEllipse(). Unable to use getMBR with single anchor point
4047
4048                        // Get variables from AddModifiersGeo
4049                        POINT2 lr = new POINT2(tg.Pixels.get(0));
4050                        POINT2 ll = new POINT2(tg.Pixels.get(0));
4051                        POINT2 ul = new POINT2(tg.Pixels.get(0));
4052                        POINT2 ur = new POINT2(tg.Pixels.get(0));
4053                        GetMBR(tg, ul, ur, lr, ll);
4054
4055                        AddIntegralAreaModifier(tg, label, aboveMiddle, csFactor, ll, lr, false);
4056                        break;
4057                    case TacticalLines.MFLANE:
4058                        //pt0=tg.Pixels.get(7);
4059                        //pt1=tg.Pixels.get(5);
4060                        pt0 = tg.Pixels.get(4);
4061                        pt1 = tg.Pixels.get(2);
4062                        if (tg.Pixels.get(0).y < tg.Pixels.get(1).y) {
4063                            addDTG(tg, aboveMiddle, 0.5 * csFactor, 1.5 * csFactor, pt0, pt1, metrics);
4064                        } else {
4065                            addDTG(tg, aboveMiddle, -0.5 * csFactor, -1.5 * csFactor, pt0, pt1, metrics);
4066                        }
4067                        break;
4068                    case TacticalLines.CORDONKNOCK:
4069                    case TacticalLines.CORDONSEARCH:
4070                    case TacticalLines.DENY:
4071                        pt0 = tg.Pixels.get(13);
4072                        pt1 = tg.Pixels.get(0);
4073                        stringWidth = metrics.stringWidth(label);
4074                        if (pt0.x < pt1.x) {
4075                            stringWidth = -stringWidth;
4076                        }
4077                        pt1 = lineutility.ExtendAlongLineDouble2(pt0, pt1, 0.75 * stringWidth);
4078                        ptCenter = lineutility.MidPointDouble(pt0, pt1, 0);
4079                        AddIntegralAreaModifier(tg, label, aboveMiddle, 0, ptCenter, ptCenter, true);
4080                        break;
4081                    case TacticalLines.ESCORT:
4082                        if (tg.Pixels.size() == 6) {
4083                            if (tg.Pixels.get(2).x == tg.Pixels.get(3).x &&
4084                                    tg.Pixels.get(2).y == tg.Pixels.get(3).y) {
4085                                //No Room for E labels
4086                                break;//?
4087                            }
4088                            AddIntegralAreaModifier(tg, label, toEnd, 0, tg.Pixels.get(2), tg.Pixels.get(1), true);
4089                            AddIntegralAreaModifier(tg, label, toEnd, 0, tg.Pixels.get(3), tg.Pixels.get(4), true);
4090                        }
4091                        break;
4092                    case TacticalLines.EXFILTRATION:
4093                    case TacticalLines.INFILTRATION:
4094                        AddIntegralAreaModifier(tg, label, aboveMiddle, 0, pt0, pt1, true);
4095                        break;
4096                    case TacticalLines.FOLLA:
4097                        pt0 = tg.Pixels.get(0);
4098                        pt1 = lineutility.MidPointDouble(tg.Pixels.get(5), tg.Pixels.get(6), 0);
4099                        pt1 = lineutility.ExtendAlongLineDouble(pt1, pt0, -10);
4100                        AddIntegralAreaModifier(tg, tg.get_Name(), aboveMiddle, 0, pt0, pt1, true);
4101                        break;
4102                    case TacticalLines.FOLSP:
4103                        pt0 = tg.Pixels.get(3);
4104                        pt1 = tg.Pixels.get(6);
4105                        pt1 = lineutility.ExtendAlongLineDouble(pt1, pt0, -10);
4106                        AddIntegralAreaModifier(tg, tg.get_Name(), aboveMiddle, 0, pt0, pt1, true);
4107                        break;
4108                /*case TacticalLines.ACA_RECTANGULAR:
4109                    ptLeft = lineutility.MidPointDouble(tg.Pixels.get(0), tg.Pixels.get(1), 0);
4110                    ptRight = lineutility.MidPointDouble(tg.Pixels.get(2), tg.Pixels.get(3), 0);
4111                    AddModifier2(tg, label + TSpace + tg.get_Name(), aboveMiddle, -3 * csFactor, ptLeft, ptRight, false);
4112                    AddModifier2(tg, tg.get_T1(), aboveMiddle, -2 * csFactor, ptLeft, ptRight, false, "T1");
4113                    AddModifier2(tg, "MIN ALT: " + tg.get_X(), aboveMiddle, -1 * csFactor, ptLeft, ptRight, false, "H");
4114                    AddModifier2(tg, "MAX ALT: " + tg.get_X1(), aboveMiddle, 0, ptLeft, ptRight, false, "H1");
4115                    AddModifier2(tg, "GRID " + tg.get_Location(), aboveMiddle, 1 * csFactor, ptLeft, ptRight, false, "H2");
4116                    AddModifier2(tg, "EFF " + tg.get_DTG() + WDash, aboveMiddle, 2 * csFactor, ptLeft, ptRight, false, "W");
4117                    AddModifier2(tg, tg.get_DTG1(), aboveMiddle, 3 * csFactor, ptLeft, ptRight, false, "W1");
4118                    break;//*/
4119                    case TacticalLines.ACA_RECTANGULAR://text always right-side-up like circular
4120                    case TacticalLines.ACA_CIRCULAR:
4121                        ptCenter = lineutility.CalcCenterPointDouble2(tg.Pixels.toArray(), tg.Pixels.size());
4122                        AddIntegralAreaModifier(tg, label + TSpace + tg.get_Name(), area, -3 * csFactor, ptCenter, ptCenter, false);
4123                        AddModifier2(tg, tg.get_T1(), area, -2 * csFactor, ptCenter, ptCenter, false, "T1");
4124                        AddIntegralAreaModifier(tg, "MIN ALT: " + tg.get_X(), area, -1 * csFactor, ptCenter, ptCenter, false, "H");
4125                        AddIntegralAreaModifier(tg, "MAX ALT: " + tg.get_X1(), area, 0, ptCenter, ptCenter, false, "H1");
4126                        AddIntegralAreaModifier(tg, "GRID " + tg.get_Location(), area, 1 * csFactor, ptCenter, ptCenter, false, "H2");
4127                        AddIntegralAreaModifier(tg, "EFF " + tg.get_DTG() + WDash, area, 2 * csFactor, ptCenter, ptCenter, false, "W");
4128                        AddIntegralAreaModifier(tg, tg.get_DTG1(), area, 3 * csFactor, ptCenter, ptCenter, false, "W1");
4129                        break;
4130                    case TacticalLines.FSA_CIRCULAR:
4131                    case TacticalLines.ATI_CIRCULAR:
4132                    case TacticalLines.CFFZ_CIRCULAR:
4133                    case TacticalLines.SENSOR_CIRCULAR:
4134                    case TacticalLines.CENSOR_CIRCULAR:
4135                    case TacticalLines.DA_CIRCULAR:
4136                    case TacticalLines.CFZ_CIRCULAR:
4137                    case TacticalLines.ZOR_CIRCULAR:
4138                    case TacticalLines.TBA_CIRCULAR:
4139                    case TacticalLines.TVAR_CIRCULAR:
4140                    case TacticalLines.KILLBOXBLUE_CIRCULAR:
4141                    case TacticalLines.KILLBOXPURPLE_CIRCULAR:
4142                        ptCenter = lineutility.MidPointDouble(tg.Pixels.get(0), tg.Pixels.get(tg.Pixels.size() / 2), 0);
4143                        AddIntegralAreaModifier(tg, label, area, -0.5 * csFactor, ptCenter, ptCenter, false);
4144                        AddIntegralAreaModifier(tg, tg.get_Name(), area, 0.5 * csFactor, ptCenter, ptCenter, false);
4145
4146                        //labels left of circle
4147                        //AddOffsetModifier(tg, tg.get_DTG() + WDash, toEnd, -1 * csFactor, tg.Pixels.size() / 2, 0, 4, "left");
4148                        //AddOffsetModifier(tg, tg.get_DTG1(), toEnd, 0, tg.Pixels.size() / 2, 0, 4, "left");
4149
4150                        //labels top left of circle
4151                        POINT2 dtgCircularPosition = tg.Pixels.get(Math.round(tg.Pixels.size() * 0.5625f));
4152                        AddIntegralAreaModifier(tg, tg.get_DTG() + WDash, toEnd, -2 * csFactor, dtgCircularPosition, new POINT2(dtgCircularPosition.x + 0.001, dtgCircularPosition.y, 0), false);
4153                        AddIntegralAreaModifier(tg, tg.get_DTG1(), toEnd, -1 * csFactor, dtgCircularPosition, new POINT2(dtgCircularPosition.x + 0.001, dtgCircularPosition.y, 0), false);
4154                        break;
4155                    case TacticalLines.FFA_CIRCULAR:
4156                    case TacticalLines.NFA_CIRCULAR:
4157                    case TacticalLines.RFA_CIRCULAR:
4158                        rfaLines = getRFALines(tg);
4159                        ptCenter = lineutility.MidPointDouble(tg.Pixels.get(0), tg.Pixels.get(51), 0);
4160                        switch (rfaLines) {
4161                            case 3: //2 valid modifiers and a label
4162                                AddIntegralAreaModifier(tg, label, area, -1 * csFactor, ptCenter, ptCenter, false);
4163                                AddIntegralAreaModifier(tg, tg.get_Name(), area, 0, ptCenter, ptCenter, false);
4164                                addDTG(tg, area, 1 * csFactor, 2 * csFactor, ptCenter, ptCenter, metrics);
4165                                break;
4166                            case 2: //one valid modifier and a label
4167                                AddIntegralAreaModifier(tg, label, area, -0.5 * csFactor, ptCenter, ptCenter, false);
4168                                if (tg.get_Name() != null && !tg.get_Name().isEmpty()) {
4169                                    AddIntegralAreaModifier(tg, tg.get_Name(), area, 0.5 * csFactor, ptCenter, ptCenter, false);
4170                                } else {
4171                                    addDTG(tg, area, 0.5 * csFactor, 1.5 * csFactor, ptCenter, ptCenter, metrics);
4172                                }
4173                                break;
4174                            default:    //one label only
4175                                AddIntegralAreaModifier(tg, label, area, 0, ptCenter, ptCenter, false);
4176                                break;
4177                        }
4178                        break;
4179                    case TacticalLines.BLOCK:
4180                        //for (j = 0; j < tg.Pixels.size(); j++)
4181                        for (j = 0; j < n; j++) {
4182                            if (tg.Pixels.get(j).style == 14) {
4183                                AddIntegralModifier(tg, label, aboveMiddle, 0, j, j + 1);
4184                                break;
4185                            }
4186                        }
4187                        break;
4188                    case TacticalLines.FFA_RECTANGULAR:
4189                    case TacticalLines.NFA_RECTANGULAR:
4190                    case TacticalLines.RFA_RECTANGULAR:
4191                        rfaLines = getRFALines(tg);
4192                        pt0 = lineutility.MidPointDouble(tg.Pixels.get(0), tg.Pixels.get(1), 0);
4193                        pt1 = lineutility.MidPointDouble(tg.Pixels.get(2), tg.Pixels.get(3), 0);
4194                        ptCenter = lineutility.MidPointDouble(pt0, pt1, 0);
4195                        switch (rfaLines) {
4196                            case 3: //2 valid modifiers and a label
4197                                AddIntegralAreaModifier(tg, label, area, -1 * csFactor, ptCenter, ptCenter, false);
4198                                AddIntegralAreaModifier(tg, tg.get_Name(), area, 0, ptCenter, ptCenter, false);
4199                                addDTG(tg, area, 1 * csFactor, 2 * csFactor, ptCenter, ptCenter, metrics);
4200                                break;
4201                            case 2: //one valid modifier and a label
4202                                AddIntegralAreaModifier(tg, label, area, -0.5 * csFactor, ptCenter, ptCenter, false);
4203                                if (tg.get_Name() != null && !tg.get_Name().isEmpty()) {
4204                                    AddIntegralAreaModifier(tg, tg.get_Name(), area, 0.5 * csFactor, ptCenter, ptCenter, false);
4205                                } else {
4206                                    addDTG(tg, area, 0.5 * csFactor, 1.5 * csFactor, ptCenter, ptCenter, metrics);
4207                                }
4208                                break;
4209                            default:    //one label only
4210                                AddIntegralAreaModifier(tg, label, area, 0, ptCenter, ptCenter, false);
4211                                break;
4212                        }
4213                        break;
4214                    case TacticalLines.KILLBOXBLUE_RECTANGULAR:
4215                    case TacticalLines.KILLBOXPURPLE_RECTANGULAR:
4216                    case TacticalLines.FSA_RECTANGULAR:
4217                    case TacticalLines.ATI_RECTANGULAR:
4218                    case TacticalLines.CFFZ_RECTANGULAR:
4219                    case TacticalLines.SENSOR_RECTANGULAR:
4220                    case TacticalLines.CENSOR_RECTANGULAR:
4221                    case TacticalLines.DA_RECTANGULAR:
4222                    case TacticalLines.CFZ_RECTANGULAR:
4223                    case TacticalLines.ZOR_RECTANGULAR:
4224                    case TacticalLines.TBA_RECTANGULAR:
4225                    case TacticalLines.TVAR_RECTANGULAR:
4226
4227                        ptLeft = lineutility.MidPointDouble(tg.Pixels.get(0), tg.Pixels.get(1), 0);
4228                        ptRight = lineutility.MidPointDouble(tg.Pixels.get(2), tg.Pixels.get(3), 0);
4229                        ptCenter = lineutility.MidPointDouble(ptLeft, ptRight, 0);
4230
4231                        //labels upright
4232                        AddIntegralAreaModifier(tg, label, area, -0.5 * csFactor, ptCenter, ptCenter, false);
4233                        AddIntegralAreaModifier(tg, tg.get_Name(), area, 0.5 * csFactor, ptCenter, ptCenter, false);
4234
4235                        //labels on angle
4236                        //AddModifier2(tg, label, aboveMiddle, -0.5 * csFactor, ptLeft, ptRight, false);
4237                        //AddModifier2(tg, tg.get_Name(), aboveMiddle, 0.5 * csFactor, ptLeft, ptRight, false);
4238
4239                        /*//DTG modifiers top left following angle
4240                        pt0 = tg.Pixels.get(0);
4241                        pt1 = tg.Pixels.get(1);
4242                        pt2 = tg.Pixels.get(2);
4243                        pt3 = tg.Pixels.get(3);
4244
4245                        if (tg.get_Client().equalsIgnoreCase("ge")) {
4246                            pt0.x -= font.getSize() / 2;
4247                            pt2.x -= font.getSize() / 2;
4248                        }
4249                        if (!tg.get_Client().equalsIgnoreCase("ge"))//added 2-27-12
4250                        {
4251                            clsUtility.shiftModifiersLeft(pt0, pt3, 12.5);
4252                            clsUtility.shiftModifiersLeft(pt1, pt2, 12.5);
4253                        }
4254
4255                        if (ptLeft.x == ptRight.x) {
4256                            ptRight.x += 1;
4257                        }
4258                        if (ptLeft.x < ptRight.x) {
4259                            AddModifier(tg, tg.get_DTG() + WDash, toEnd, 0, pt0, pt3);//was 1,2 switched for CPOF
4260                            AddModifier(tg, tg.get_DTG1(), toEnd, 1 * csFactor, pt0, pt3);//was 1,2
4261                        } else {
4262                            AddModifier(tg, tg.get_DTG() + WDash, toEnd, 0, pt2, pt1);//was 3,0 //switched for CPOF
4263                            AddModifier(tg, tg.get_DTG1(), toEnd, 1 * csFactor, pt2, pt1);//was 3,0
4264                        }//*/
4265
4266                        //highest point left of center
4267                        POINT2 dtgPosition = getHighestPointLeftOfCenter(tg.Pixels, ptCenter);
4268
4269                        //DTG at north west-ish point and right-side-up
4270                        AddIntegralAreaModifier(tg, tg.get_DTG() + WDash, toEnd, 0.5 * csFactor, dtgPosition, new POINT2(dtgPosition.x + 0.001, dtgPosition.y, 0), false);
4271                        AddIntegralAreaModifier(tg, tg.get_DTG1() + " ", toEnd, 1.5 * csFactor, dtgPosition, new POINT2(dtgPosition.x + 0.001, dtgPosition.y, 0), false);
4272
4273                        //DTG at first point and angled with rectangle
4274                        //AddOffsetModifier(tg, tg.get_DTG() + WDash, toEnd, -1 * csFactor, tg.Pixels.size() / 2, 0, 4, "left");
4275                        //AddOffsetModifier(tg, tg.get_DTG1(), toEnd, 0, tg.Pixels.size() / 2, 0, 4, "left");
4276
4277                        break;//*/
4278                    case TacticalLines.PAA_RECTANGULAR:
4279
4280                        ptCenter = lineutility.MidPointDouble(tg.Pixels.get(0), tg.Pixels.get(1), 0);
4281                        AddIntegralAreaModifier(tg, label, area, -0.5 * csFactor, ptCenter, ptCenter, true);//label level
4282                        //AddIntegralModifier(tg, label, aboveMiddlePerpendicular, 0, 0, 1, true);//label angled with line
4283                        ptCenter = lineutility.MidPointDouble(tg.Pixels.get(1), tg.Pixels.get(2), 0);
4284                        AddIntegralAreaModifier(tg, label, area, -0.5 * csFactor, ptCenter, ptCenter, true);
4285                        //AddIntegralModifier(tg, label, aboveMiddle, 0, 1, 2, true);
4286                        ptCenter = lineutility.MidPointDouble(tg.Pixels.get(2), tg.Pixels.get(3), 0);
4287                        AddIntegralAreaModifier(tg, label, area, -0.5 * csFactor, ptCenter, ptCenter, true);
4288                        //AddIntegralModifier(tg, label, aboveMiddlePerpendicular, 0, 2, 3, true);
4289                        ptCenter = lineutility.MidPointDouble(tg.Pixels.get(3), tg.Pixels.get(0), 0);
4290                        AddIntegralAreaModifier(tg, label, area, -0.5 * csFactor, ptCenter, ptCenter, true);
4291                        //AddIntegralModifier(tg, label, aboveMiddle, 0, 3, 0, true);
4292                        rfaLines = getRFALines(tg);
4293                        pt0 = lineutility.MidPointDouble(tg.Pixels.get(0), tg.Pixels.get(1), 0);
4294                        pt1 = lineutility.MidPointDouble(tg.Pixels.get(2), tg.Pixels.get(3), 0);
4295                        ptCenter = lineutility.MidPointDouble(pt0, pt1, 0);
4296                        switch (rfaLines) {
4297                            case 3: // two valid modifiers
4298                                if (!RendererSettings.getInstance().getGroupModifiers()) {
4299                                    AddIntegralAreaModifier(tg, tg.get_Name(), area, -1.5, ptCenter, ptCenter, false);
4300                                    addDTG(tg, area, 0.5 * csFactor, 1.5 * csFactor, ptCenter, ptCenter, metrics);
4301                                } else {
4302                                    String modifier = buildAreaGroupString(tg, label);
4303                                    AddIntegralAreaModifier(tg, modifier, area, 0, ptCenter, ptCenter, false);
4304                                }
4305                                break;
4306                            case 2: // one valid modifier
4307                                if (tg.get_Name() != null && !tg.get_Name().isEmpty()) {
4308                                    AddIntegralAreaModifier(tg, tg.get_Name(), area, 0, ptCenter, ptCenter, false);
4309                                } else {
4310                                    addDTG(tg, area, 0, csFactor, ptCenter, ptCenter, metrics);
4311                                }
4312                                break;
4313                            default:
4314                                break;
4315                        }
4316                        break;
4317                    case TacticalLines.PAA_CIRCULAR:
4318                        for (int i = 0; i < 4; i++) {
4319                            AddIntegralModifier(tg, label, area, -0.5 * csFactor, n / 4 * i, n / 4 * i, false);
4320                        }
4321
4322                        rfaLines = getRFALines(tg);
4323                        ptCenter = lineutility.MidPointDouble(tg.Pixels.get(0), tg.Pixels.get((int) (n / 2.0 + 0.5)), 0);
4324                        switch (rfaLines) {
4325                            case 3: // two valid modifiers
4326                                if (!RendererSettings.getInstance().getGroupModifiers()) {
4327                                    AddIntegralAreaModifier(tg, tg.get_Name(), area, -1.5, ptCenter, ptCenter, false);
4328                                    addDTG(tg, area, 0.5 * csFactor, 1.5 * csFactor, ptCenter, ptCenter, metrics);
4329                                } else {
4330                                    String modifier = buildAreaGroupString(tg, label);
4331                                    AddIntegralAreaModifier(tg, modifier, area, 0, ptCenter, ptCenter, false);
4332                                }
4333                                break;
4334                            case 2: // one valid modifier
4335                                if (tg.get_Name() != null && !tg.get_Name().isEmpty()) {
4336                                    AddIntegralAreaModifier(tg, tg.get_Name(), area, 0, ptCenter, ptCenter, false);
4337                                } else {
4338                                    addDTG(tg, area, 0, csFactor, ptCenter, ptCenter, metrics);
4339                                }
4340                                break;
4341                            default:
4342                                break;
4343                        }
4344                        break;
4345                    case TacticalLines.RANGE_FAN:
4346                        if(!RendererSettings.getInstance().getGroupModifiers()) {
4347                            if (tg.get_X() != null) {
4348                                X = tg.get_X().split(",");
4349                                for (j = 0; j < X.length; j++) {
4350                                    String altLabel = "ALT GL";
4351                                    if (tg.Pixels.size() > j * 102 + 25) {
4352                                        pt0 = tg.Pixels.get(j * 102 + 25);
4353                                        if(!X[j].isEmpty())
4354                                            altLabel = "ALT " + X[j];
4355                                        AddAreaModifier(tg, altLabel, area, 1, pt0, pt0);
4356                                    }
4357                                }
4358                            }
4359                            if (!tg.get_HideOptionalLabels()) {
4360                                String[] am = tg.get_AM().split(",");
4361                                for (j = 0; j < am.length; j++) {
4362                                    if (tg.Pixels.size() > j * 102 + 25) {
4363                                        pt0 = tg.Pixels.get(j * 102 + 25);
4364                                        //AddAreaModifier(tg, "RG " + am[j], area, -1, pt0, pt0);
4365                                        if (j == 0)
4366                                            AddAreaModifier(tg, "MIN RG " + removeDecimal(am[j]), 3, 0, pt0, pt0);
4367                                        else
4368                                            AddAreaModifier(tg, "MAX RG " + "(" + Integer.toString(j) + ") " + removeDecimal(am[j]), 3, 0, pt0, pt0);
4369                                    }
4370                                }
4371                            }// end if set range fan text
4372                        }
4373                        else // grouped
4374                        {
4375                            String[] am = tg.get_AM().split(",");
4376                            String crfLabel;
4377                            for (j = 0; j < am.length; j++) {
4378                                crfLabel = "";
4379                                if (!tg.get_HideOptionalLabels()) {
4380                                    if (tg.Pixels.size() > j * 102 + 25) {
4381                                        pt0 = tg.Pixels.get(j * 102 + 25);
4382                                        //AddAreaModifier(tg, "RG " + am[j], area, -1, pt0, pt0);
4383                                        if (j == 0)
4384                                            crfLabel = "MIN RG " + removeDecimal(am[j]) + "\n";
4385                                        else
4386                                            crfLabel = "MAX RG " + "(" + j + ") "  + removeDecimal(am[j]) + "\n";
4387                                    }
4388                                }
4389                                if (tg.get_X() != null && !tg.get_X().isEmpty()) {
4390                                    X = tg.get_X().split(",");
4391                                    if (tg.Pixels.size() > j * 102 + 25) {
4392                                        pt0 = tg.Pixels.get(j * 102 + 25);
4393                                        if(X[j] != null && !X[j].isEmpty())
4394                                            crfLabel += "ALT " + X[j];
4395                                    }
4396                                }
4397                                else
4398                                    crfLabel += "ALT GL";
4399
4400                                AddAreaModifier(tg, crfLabel, 3, 1, pt0, pt0);
4401                            }
4402                        }//*/
4403                        break;
4404                    case TacticalLines.RANGE_FAN_SECTOR:
4405                    case TacticalLines.RADAR_SEARCH:
4406                        addSectorModifiers(tg, converter);
4407                        break;
4408                    case TacticalLines.ENVELOPMENT:
4409                        AddIntegralModifier(tg, label, aboveMiddle, 0, 0, 1, true);
4410                        break;
4411                    case TacticalLines.MOBILE_DEFENSE:
4412                        AddIntegralModifier(tg, label, area, 0, 16, 16, true);
4413                        break;
4414                    default:
4415                        break;
4416                }//end switch
4417            }
4418            scaleModifiers(tg);
4419            tg.Pixels = origPoints;
4420            g2d.dispose();
4421            g2d = null;
4422        } catch (Exception exc) {
4423            ErrorLogger.LogException(_className, "AddModifiers2",
4424                    new RendererException("Failed inside AddModifiers2", exc));
4425        }
4426    }
4427
4428    /**
4429     * Calculates the highest point that is left-of-center given symbol center point and points
4430     * @param pixels Points that make the symbol
4431     * @param ptCenter Represents the center of the symbol
4432     * @return Point that is the highest point, left-of-center
4433     */
4434    private static POINT2 getHighestPointLeftOfCenter(ArrayList<POINT2> pixels, POINT2 ptCenter)
4435    {
4436        //highest point left of center
4437        POINT2 highest = pixels.get(0);
4438        boolean validPointFound = false;
4439        for (POINT2 p : pixels) //loop through points
4440        {
4441            if(p.x <= ptCenter.x)//we only care about points left of center
4442            {
4443                if(!validPointFound)//find initial left-of-center point
4444                {
4445                    highest = p;//set initial value
4446                    validPointFound = true;
4447                }
4448                else if(p.y < highest.y)//see if this point is higher than the current point
4449                    highest = p;//set new highest, left-of-center point
4450            }
4451        }
4452        return highest;
4453    }
4454    private static String buildAreaGroupString(TGLight tg, String label)
4455    {
4456        int linetype = tg.get_LineType();
4457        String modifier = "";
4458        switch (linetype)
4459        {
4460            case TacticalLines.PAA:
4461            case TacticalLines.PAA_CIRCULAR:
4462            case TacticalLines.PAA_RECTANGULAR:
4463                modifier = tg.get_Name();
4464                if(tg.get_DTG() != null && !tg.get_DTG().isEmpty())
4465                    modifier += "\n" + tg.get_DTG() + " -";
4466                if(tg.get_DTG1() != null && !tg.get_DTG1().isEmpty())
4467                    modifier += "\n" + tg.get_DTG1();
4468                break;
4469            case TacticalLines.ACA:
4470            case TacticalLines.ACA_CIRCULAR:
4471            case TacticalLines.ACA_RECTANGULAR:
4472                modifier += label + " " + tg.get_Name();
4473                modifier += "\n" + tg.get_T1();
4474                modifier += "\n" + "MIN ALT: " + tg.get_X();
4475                modifier += "\n" + "MAX ALT: " + tg.get_X1();
4476                modifier += "\n" + "GRID: " + tg.get_Location();
4477                modifier += "\n" + "EFF: " + tg.get_DTG() + " -";
4478                modifier += "\n" + tg.get_DTG1();
4479                break;
4480            case TacticalLines.FFA:
4481            case TacticalLines.NFA:
4482            case TacticalLines.RFA:
4483            case TacticalLines.FFA_RECTANGULAR:
4484            case TacticalLines.NFA_RECTANGULAR:
4485            case TacticalLines.RFA_RECTANGULAR:
4486            case TacticalLines.FFA_CIRCULAR:
4487            case TacticalLines.NFA_CIRCULAR:
4488            case TacticalLines.RFA_CIRCULAR:
4489                modifier = label + "\n" + tg.get_Name();
4490                if(tg.get_DTG() != null && !tg.get_DTG().isEmpty())
4491                    modifier += "\n" + tg.get_DTG() + " -";
4492                if(tg.get_DTG1() != null && !tg.get_DTG1().isEmpty())
4493                    modifier += "\n" + tg.get_DTG1();
4494                break;
4495            case TacticalLines.FSA:
4496                modifier = label + " " + tg.get_Name();
4497                if(tg.get_DTG() != null && !tg.get_DTG().isEmpty())
4498                    modifier += "\n" + tg.get_DTG() + " -";
4499                if(tg.get_DTG1() != null && !tg.get_DTG1().isEmpty())
4500                    modifier += "\n" + tg.get_DTG1();
4501                break;
4502            case TacticalLines.ATI:
4503            case TacticalLines.CFFZ:
4504            case TacticalLines.CFZ:
4505            case TacticalLines.TBA:
4506            case TacticalLines.TVAR:
4507            case TacticalLines.ZOR:
4508            case TacticalLines.DA:
4509            case TacticalLines.SENSOR:
4510            case TacticalLines.CENSOR:
4511            case TacticalLines.KILLBOXBLUE:
4512            case TacticalLines.KILLBOXPURPLE:
4513            case TacticalLines.KILLBOXBLUE_RECTANGULAR:
4514            case TacticalLines.KILLBOXPURPLE_RECTANGULAR:
4515            case TacticalLines.FSA_RECTANGULAR:
4516            case TacticalLines.ATI_RECTANGULAR:
4517            case TacticalLines.CFFZ_RECTANGULAR:
4518            case TacticalLines.SENSOR_RECTANGULAR:
4519            case TacticalLines.CENSOR_RECTANGULAR:
4520            case TacticalLines.DA_RECTANGULAR:
4521            case TacticalLines.CFZ_RECTANGULAR:
4522            case TacticalLines.ZOR_RECTANGULAR:
4523            case TacticalLines.TBA_RECTANGULAR:
4524            case TacticalLines.TVAR_RECTANGULAR:
4525            case TacticalLines.FSA_CIRCULAR:
4526            case TacticalLines.ATI_CIRCULAR:
4527            case TacticalLines.CFFZ_CIRCULAR:
4528            case TacticalLines.SENSOR_CIRCULAR:
4529            case TacticalLines.CENSOR_CIRCULAR:
4530            case TacticalLines.DA_CIRCULAR:
4531            case TacticalLines.CFZ_CIRCULAR:
4532            case TacticalLines.ZOR_CIRCULAR:
4533            case TacticalLines.TBA_CIRCULAR:
4534            case TacticalLines.TVAR_CIRCULAR:
4535            case TacticalLines.KILLBOXBLUE_CIRCULAR:
4536            case TacticalLines.KILLBOXPURPLE_CIRCULAR:
4537                modifier = label + "\n" + tg.get_Name();
4538                break;
4539            case TacticalLines.WFZ_REVD:
4540            case TacticalLines.OBSFAREA:
4541                modifier = label;
4542                modifier += "\n" + tg.get_Name();
4543                modifier += "\n" + "TIME FROM: " + tg.get_DTG();
4544                modifier += "\n" + "TIME TO: " + tg.get_DTG1();
4545                break;
4546            case TacticalLines.OBSAREA:
4547                modifier = tg.get_Name();
4548                modifier += "\n" + "TIME FROM: " + tg.get_DTG();
4549                modifier += "\n" + "TIME TO: " + tg.get_DTG1();
4550                break;
4551            case TacticalLines.WFZ:
4552            case TacticalLines.ROZ:
4553            case TacticalLines.AARROZ:
4554            case TacticalLines.UAROZ:
4555            case TacticalLines.WEZ:
4556            case TacticalLines.FEZ:
4557            case TacticalLines.JEZ:
4558            case TacticalLines.FAADZ:
4559            case TacticalLines.HIDACZ:
4560            case TacticalLines.MEZ:
4561            case TacticalLines.LOMEZ:
4562            case TacticalLines.HIMEZ:
4563                modifier = label;
4564                modifier += "\n" + tg.get_Name();
4565                modifier += "\n" + "MIN ALT: " + tg.get_X();
4566                modifier += "\n" + "MAX ALT: " + tg.get_X1();
4567                modifier += "\n" + "TIME FROM: " + tg.get_DTG();
4568                modifier += "\n" + "TIME TO: " + tg.get_DTG1();
4569                break;
4570            case TacticalLines.AC://Air Corridors
4571            case TacticalLines.LLTR:
4572            case TacticalLines.MRR:
4573            case TacticalLines.SL:
4574            case TacticalLines.TC:
4575            case TacticalLines.SAAFR:
4576            case TacticalLines.SC:
4577                modifier = "NAME: " + tg.get_Name();
4578                modifier += "\n" + "WIDTH: " + tg.get_AM();
4579                modifier += "\n" + "MIN ALT: " + tg.get_X();
4580                modifier += "\n" + "MAX ALT: " + tg.get_X1();
4581                modifier += "\n" + "DTG Start: " + tg.get_DTG();
4582                modifier += "\n" + "DTG End: " + tg.get_DTG1();
4583                modifier += "\n\n" + label + " " + tg.get_Name();
4584                modifier += "\n\n\n\n\n\n\n";
4585        }
4586        return modifier;
4587    }
4588
4589    private static String buildAreaGroupDTGString(TGLight tg)
4590    {
4591        String modifier = "";
4592
4593        if(tg.get_DTG() != null && !tg.get_DTG().isEmpty())
4594            modifier += tg.get_DTG() + " -";
4595        if(tg.get_DTG1() != null && !tg.get_DTG1().isEmpty())
4596            modifier += "\n" + tg.get_DTG1();
4597
4598        return modifier;
4599    }
4600
4601    /**
4602     * Displays the tg modifiers using a client Graphics2D, this is an option
4603     * provided to clients for displaying modifiers without using shapes
4604     *
4605     * @param tg the tactical graphic
4606     * @param g2d the graphics object for drawing
4607     * @deprecated
4608     */
4609    public static void DisplayModifiers(TGLight tg,
4610            Graphics2D g2d) {
4611        try {
4612            Font font = g2d.getFont();
4613            int j = 0;
4614            Modifier2 modifier = null;
4615            g2d.setBackground(Color.white);
4616            POINT2 pt = null;
4617            double theta = 0;
4618            int stringWidth = 0, stringHeight = 0;
4619            FontMetrics metrics = g2d.getFontMetrics();
4620            String s = "";
4621            int x = 0, y = 0;
4622            POINT2 pt1 = null, pt2 = null;
4623            int quadrant = -1;
4624            int n = tg.Pixels.size();
4625            //for (j = 0; j < tg.modifiers.size(); j++) 
4626            for (j = 0; j < n; j++) {
4627                modifier = (Modifier2) tg.modifiers.get(j);
4628                double lineFactor = modifier.lineFactor;
4629                s = modifier.text;
4630                double x1 = 0, y1 = 0, x2 = 0, y2 = 0;
4631                pt = modifier.textPath[0];
4632                x1 = pt.x;
4633                y1 = pt.y;
4634                pt = modifier.textPath[1];
4635                x2 = pt.x;
4636                y2 = pt.y;
4637                theta = Math.atan2(y2 - y1, x2 - x1);
4638                POINT2 midPt;
4639                if (x1 > x2) {
4640                    theta -= Math.PI;
4641                }
4642                switch (modifier.type) {
4643                    case toEnd: //corresponds to LabelAndTextBeforeLineTG
4644                        g2d.rotate(theta, x1, y1);
4645                        stringWidth = metrics.stringWidth(s);
4646                        stringHeight = font.getSize();
4647                        if (x1 < x2 || (x1 == x2 && y1 > y2)) {
4648                            x = (int) x1 - stringWidth;
4649                            y = (int) y1 - (int) stringHeight / 2 + (int) (lineFactor * stringHeight);
4650                            g2d.setColor(tg.get_FontBackColor());
4651                            g2d.clearRect(x, y, stringWidth, stringHeight);
4652                            y = (int) y1 + (int) stringHeight / 2 + (int) (lineFactor * stringHeight);
4653                            g2d.setColor(tg.get_TextColor());
4654                            g2d.drawString(s, x, y);
4655                        } else {
4656                            x = (int) x1;
4657                            y = (int) y1 - (int) stringHeight / 2 + (int) (lineFactor * stringHeight);
4658                            g2d.setColor(tg.get_FontBackColor());
4659                            g2d.clearRect(x, y, stringWidth, stringHeight);
4660                            y = (int) y1 + (int) stringHeight / 2 + (int) (lineFactor * stringHeight);
4661                            g2d.setColor(tg.get_TextColor());
4662                            g2d.drawString(s, x, y);
4663                        }
4664                        break;
4665                    case aboveMiddle:
4666                        midPt = new POINT2((x1 + x2) / 2, (y1 + y2) / 2);
4667                        g2d.rotate(theta, midPt.x, midPt.y);
4668                        stringWidth = metrics.stringWidth(s);
4669                        stringHeight = font.getSize();
4670                        x = (int) midPt.x - stringWidth / 2;
4671                        y = (int) midPt.y - (int) stringHeight / 2 + (int) (lineFactor * stringHeight);
4672                        g2d.setColor(tg.get_FontBackColor());
4673                        g2d.clearRect(x, y, stringWidth, stringHeight);
4674                        y = (int) midPt.y + (int) (stringHeight / 2) + (int) (lineFactor * stringHeight);
4675                        g2d.setColor(tg.get_TextColor());
4676                        g2d.drawString(s, x, y);
4677                        break;
4678                    case area:
4679                        g2d.rotate(0, x1, y1);
4680                        stringWidth = metrics.stringWidth(s);
4681                        stringHeight = font.getSize();
4682
4683                        x = (int) x1 - stringWidth / 2;
4684                        y = (int) y1 - (int) stringHeight / 2 + (int) (lineFactor * stringHeight);
4685                        g2d.setColor(tg.get_FontBackColor());
4686                        g2d.clearRect(x, y, stringWidth, stringHeight);
4687                        y = (int) y1 + (int) (stringHeight / 2) + (int) (lineFactor * stringHeight);
4688                        g2d.setColor(tg.get_TextColor());
4689                        g2d.drawString(s, x, y);
4690                        break;
4691                    case screen:    //for SCREEN, GUARD, COVER
4692                        if (tg.Pixels.size() >= 14) {
4693                            pt1 = tg.Pixels.get(3);
4694                            pt2 = tg.Pixels.get(10);
4695                            quadrant = lineutility.GetQuadrantDouble(pt1, pt2);
4696                            theta = Math.atan2(pt2.y - pt1.y, pt2.x - pt1.x);
4697                            switch (quadrant) {
4698                                case 1:
4699                                    theta += Math.PI / 2;
4700                                    break;
4701                                case 2:
4702                                    theta -= Math.PI / 2;
4703                                    break;
4704                                case 3:
4705                                    theta -= Math.PI / 2;
4706                                    break;
4707                                case 4:
4708                                    theta += Math.PI / 2;
4709                                    break;
4710                                default:
4711                                    break;
4712                            }
4713
4714                            g2d.rotate(theta, x1, y1);
4715                            stringWidth = metrics.stringWidth(s);
4716                            stringHeight = font.getSize();
4717
4718                            x = (int) x1 - stringWidth / 2;
4719                            y = (int) y1 - (int) stringHeight / 2 + (int) (lineFactor * stringHeight);
4720                            g2d.setColor(tg.get_FontBackColor());
4721                            g2d.clearRect(x, y, stringWidth, stringHeight);
4722                            y = (int) y1 + (int) (stringHeight / 2) + (int) (lineFactor * stringHeight);
4723                            g2d.setColor(tg.get_TextColor());
4724                            g2d.drawString(s, x, y);
4725                        } else {
4726                            stringWidth = metrics.stringWidth(s);
4727                            stringHeight = font.getSize();
4728                            x = (int) tg.Pixels.get(0).x;//(int) x1 - stringWidth / 2;
4729                            y = (int) tg.Pixels.get(0).y;//(int) y1 - (int) stringHeight / 2 + (int) (lineFactor * stringHeight);
4730                            g2d.setColor(tg.get_FontBackColor());
4731                            g2d.clearRect(x, y, stringWidth, stringHeight);
4732                            y = (int) y + (int) (stringHeight / 2) + (int) (lineFactor * stringHeight);
4733                            g2d.setColor(tg.get_TextColor());
4734                            g2d.drawString(s, x, y);
4735                        }
4736                        break;
4737                    default:
4738                        break;
4739                }   //end switch
4740            }   //end for
4741        } catch (Exception exc) {
4742            ErrorLogger.LogException(_className, "DisplayModifiers",
4743                    new RendererException("Failed inside DisplayModifiers", exc));
4744        }
4745    }//end function
4746
4747    /**
4748     * Returns a Shape object for the text background for labels and modifiers
4749     *
4750     * @param tg the tactical graphic object
4751     * @param pt0 1st point of segment
4752     * @param pt1 last point of segment
4753     * @param stringWidth string width
4754     * @param stringHeight string height
4755     * @param lineFactor number of text lines above or below the segment
4756     * @param isTextFlipped true if text is flipped
4757     * @return the modifier shape
4758     */
4759    public static Shape2 BuildModifierShape(
4760            TGLight tg,
4761            POINT2 pt0,
4762            POINT2 pt1,
4763            int stringWidth,
4764            int stringHeight,
4765            double lineFactor,
4766            boolean isTextFlipped) {
4767        Shape2 modifierFill = null;
4768        try {
4769
4770            POINT2 ptTemp0 = new POINT2(pt0), ptTemp1 = new POINT2(pt1);
4771
4772            if (isTextFlipped) {
4773                lineFactor += 1;
4774            }
4775
4776            if (lineFactor < 0) //extend pt0,pt1 above the line
4777            {
4778                ptTemp0 = lineutility.ExtendDirectedLine(pt0, pt1, pt0, 2, -lineFactor * stringHeight);
4779                ptTemp1 = lineutility.ExtendDirectedLine(pt0, pt1, pt1, 2, -lineFactor * stringHeight);
4780            }
4781            if (lineFactor > 0) //extend pt0,pt1 below the line
4782            {
4783                ptTemp0 = lineutility.ExtendDirectedLine(pt0, pt1, pt0, 3, lineFactor * stringHeight);
4784                ptTemp1 = lineutility.ExtendDirectedLine(pt0, pt1, pt1, 3, lineFactor * stringHeight);
4785            }
4786            if (ptTemp0.y == ptTemp1.y) {
4787                ptTemp0.y += 1;
4788            }
4789
4790            POINT2 pt3 = null, pt4 = null, pt5 = null, pt6 = null, pt7 = null;
4791            pt3 = lineutility.ExtendAlongLineDouble(ptTemp0, ptTemp1, -stringWidth);
4792            pt4 = lineutility.ExtendDirectedLine(ptTemp1, ptTemp0, pt3, 0, stringHeight / 2);
4793            pt5 = lineutility.ExtendDirectedLine(ptTemp1, ptTemp0, pt3, 1, stringHeight / 2);
4794            pt6 = lineutility.ExtendDirectedLine(ptTemp1, ptTemp0, ptTemp0, 1, stringHeight / 2);
4795            pt7 = lineutility.ExtendDirectedLine(ptTemp1, ptTemp0, ptTemp0, 0, stringHeight / 2);
4796            modifierFill = new Shape2(Shape2.SHAPE_TYPE_MODIFIER_FILL);
4797
4798            modifierFill.moveTo(pt4);
4799            modifierFill.lineTo(pt5);
4800            modifierFill.lineTo(pt6);
4801            modifierFill.lineTo(pt7);
4802            modifierFill.lineTo(pt4);
4803        } catch (Exception exc) {
4804            ErrorLogger.LogException(_className, "BuildModifierShape",
4805                    new RendererException("Failed inside BuildModifierShape", exc));
4806        }
4807        return modifierFill;
4808    }
4809
4810    /**
4811     * For BOUNDARY and other line types which require breaks for the integral
4812     * text. Currently only boundary uses this
4813     *
4814     * @param tg
4815     * @param g2d the graphics object for drawing
4816     * @param shapes the shape array
4817     */
4818    public static void GetIntegralTextShapes(TGLight tg,
4819            Graphics2D g2d,
4820            ArrayList<Shape2> shapes) {
4821        try {
4822            if (tg.Pixels == null || shapes == null) {
4823                return;
4824            }
4825
4826            HashMap<Integer, Color> hmap = clsUtility.getMSRSegmentColors(tg);
4827            Color color = null;
4828
4829            Shape2 shape = null;
4830            Shape2 segShape = null;//diangostic 1-22-13
4831            g2d.setFont(tg.get_Font());
4832            int j = 0;
4833            String affiliation = null;
4834            FontMetrics metrics = g2d.getFontMetrics();
4835            String echelonSymbol = null;
4836            int stringWidthEchelonSymbol = 0;
4837            //boolean lineTooShort = false;
4838            POINT2 ptEchelonStart = null, ptEchelonEnd = null, midpt,
4839                    ptENY0Start = null, ptENY0End = null, ptENY1Start, ptENY1End, pt0 = null, pt1 = null;
4840            double dist = 0;
4841            BasicStroke stroke = null;
4842            switch (tg.get_LineType()) {
4843                case TacticalLines.BOUNDARY:
4844                    echelonSymbol = tg.get_EchelonSymbol();
4845                    //shapes = new ArrayList();
4846                    shape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE);
4847                    shape.setLineColor(tg.get_LineColor());
4848                    shape.set_Style(tg.get_LineStyle());
4849                    stroke = clsUtility.getLineStroke(tg.get_LineThickness(), shape.get_Style(), tg.get_lineCap(), BasicStroke.JOIN_ROUND);
4850                    shape.setStroke(stroke);
4851                    if (echelonSymbol != null && !echelonSymbol.isEmpty()) {
4852                        stringWidthEchelonSymbol = metrics.stringWidth(echelonSymbol);
4853                    }
4854                    //diagnostic
4855                    if (hmap == null || hmap.isEmpty()) {
4856                        shape.moveTo(tg.Pixels.get(0));
4857                        for (j = 1; j < tg.Pixels.size(); j++) {
4858                            shape.lineTo(tg.Pixels.get(j));
4859                        }
4860                        shapes.add(shape);
4861                        break;
4862                    }
4863                    //end section
4864                    int n = tg.Pixels.size();
4865                    //for (j = 0; j < tg.Pixels.size() - 1; j++) 
4866                    for (j = 0; j < n - 1; j++) {
4867                        segShape = null;
4868                        if (hmap != null) {
4869                            if (hmap.containsKey(j)) {
4870                                color = (Color) hmap.get(j);
4871                                segShape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE);
4872                                segShape.setLineColor(color);
4873                                segShape.set_Style(tg.get_LineStyle());
4874                                segShape.setStroke(stroke);
4875                            }
4876                        }
4877
4878                        pt0 = tg.Pixels.get(j);
4879                        pt1 = tg.Pixels.get(j + 1);
4880                        //lineTooShort = GetBoundarySegmentTooShort(tg, g2d, j);
4881                        if (segShape != null) {
4882                            segShape.moveTo(pt0);
4883                        } else {
4884                            shape.moveTo(pt0);
4885                        }
4886
4887                        //uncoment comment to remove line breaks for GE
4888                        //if (lineTooShort || tg.get_Client().equals("ge")) 
4889                        if (tg.get_Client().equals("ge") || GetBoundarySegmentTooShort(tg, g2d, j) == true) {
4890                            if (segShape != null) {
4891                                segShape.lineTo(pt1);
4892                                shapes.add(segShape);
4893                                continue;
4894                            } else {
4895                                shape.lineTo(pt1);
4896                                continue;
4897                            }
4898                        }
4899
4900                        midpt = lineutility.MidPointDouble(pt0, pt1, 0);
4901                        if (segShape != null) {
4902                            segShape.moveTo(pt0);
4903                        } else {
4904                            shape.moveTo(pt0);
4905                        }
4906
4907                        if (stringWidthEchelonSymbol > 0) {
4908                            midpt = lineutility.MidPointDouble(pt0, pt1, 0);
4909                            dist = lineutility.CalcDistanceDouble(pt0, midpt) - stringWidthEchelonSymbol / 1.5;
4910                            ptEchelonStart = lineutility.ExtendAlongLineDouble(pt0, pt1, dist);
4911                            dist = lineutility.CalcDistanceDouble(pt0, midpt) + stringWidthEchelonSymbol / 1.5;
4912                            ptEchelonEnd = lineutility.ExtendAlongLineDouble(pt0, pt1, dist);
4913                            if (segShape != null) {
4914                                segShape.lineTo(ptEchelonStart);
4915                                segShape.moveTo(ptEchelonEnd);
4916                            } else {
4917                                shape.lineTo(ptEchelonStart);
4918                                shape.moveTo(ptEchelonEnd);
4919                            }
4920                        }
4921                        if (segShape != null) {
4922                            segShape.lineTo(pt1);
4923                        } else {
4924                            shape.lineTo(pt1);
4925                        }
4926                        if (segShape != null) {
4927                            shapes.add(segShape);
4928                        }
4929                    }//end for
4930                    shapes.add(shape);
4931                    break;
4932                default:
4933                    break;
4934            }
4935        } catch (Exception exc) {
4936            ErrorLogger.LogException(_className, "GetIntegralTextShapes",
4937                    new RendererException("Failed inside GetIntegralTextShapes", exc));
4938        }
4939    }
4940
4941    /**
4942     * Displays the modifiers to a Graphics2D from a BufferedImage
4943     *
4944     * @param tg the tactical graphic
4945     * @param g2d the Graphic for drawing
4946     * @param shapes the shape array
4947     * @param isTextFlipped true if text is flipped
4948     * @param converter to convert between geographic and pixel coordinates
4949     */
4950    public static void DisplayModifiers2(TGLight tg,
4951            Graphics2D g2d,
4952            ArrayList<Shape2> shapes,
4953            boolean isTextFlipped,
4954            IPointConversion converter) {
4955        try {
4956            if (shapes == null) {
4957                return;
4958            }
4959
4960            if (tg.modifiers == null || tg.modifiers.isEmpty()) {
4961                return;
4962            }
4963            Font font = null;
4964            int j = 0;
4965            Modifier2 modifier = null;
4966            Color fontBackColor = tg.get_FontBackColor();
4967            double theta = 0;
4968            double stringWidth = 0, stringHeight = 0;
4969            String s = "";
4970            Bitmap image = null;
4971            int x = 0, y = 0;
4972            POINT2 pt0 = null, pt1 = null, pt2 = null, pt3 = null;
4973            int quadrant = -1;
4974            Shape2 shape2 = null;
4975            long lineType = tg.get_LineType();
4976            font = tg.get_Font();    //might have to change this
4977            if (font == null) {
4978                font = g2d.getFont();
4979            }
4980            if (font.getSize() == 0) {
4981                return;
4982            }
4983            g2d.setFont(font);
4984            FontMetrics metrics = g2d.getFontMetrics();
4985            //we need a background color
4986            if (fontBackColor != null) {
4987                g2d.setBackground(fontBackColor);
4988            } else {
4989                g2d.setBackground(Color.white);
4990            }
4991
4992            Point2D anchor = null;
4993            Point2D anchorOffset = null;
4994
4995            int direction = -1;
4996            Point glyphPosition = null;
4997            for (j = 0; j < tg.modifiers.size(); j++) {
4998                modifier = (Modifier2) tg.modifiers.get(j);
4999
5000                double lineFactor = modifier.lineFactor;
5001
5002                if (isTextFlipped) {
5003                    lineFactor = -lineFactor;
5004                }
5005
5006                s = modifier.text;
5007                if (s == null || s.equals("")) {
5008
5009                    image = modifier.image;
5010                    if (image == null) {
5011                        continue;
5012                    }
5013                }
5014                stringWidth = s != null ? (double) metrics.stringWidth(s) + 1 : image.getWidth() + 1;
5015                stringHeight = s != null ? (double) font.getSize() : image.getHeight();
5016
5017                double x1 = 0, y1 = 0, x2 = 0, y2 = 0, dist = 0;
5018                pt0 = modifier.textPath[0];
5019                x1 = Math.round(pt0.x);
5020                y1 = Math.round(pt0.y);
5021                pt1 = modifier.textPath[1];
5022                x2 = Math.round(pt1.x);
5023                y2 = Math.round(pt1.y);
5024                theta = Math.atan2(y2 - y1, x2 - x1);
5025                POINT2 midPt;
5026                if (x1 > x2) {
5027                    theta -= Math.PI;
5028                }
5029                pt0 = new POINT2(x1, y1);
5030                pt1 = new POINT2(x2, y2);
5031                midPt = new POINT2((x1 + x2) / 2, (y1 + y2) / 2);
5032                Point2D modifierPosition = null;  //use this if using justify
5033                int justify = ShapeInfo.justify_left;
5034                switch (modifier.type) {
5035                    case aboveEnd: // On line
5036                    case toEnd: // Next to line
5037                        if (x1 == x2) {
5038                            x2 += 1;
5039                        }
5040
5041                        if (lineFactor >= 0) {
5042                            direction = 2;
5043                        } else {
5044                            direction = 3;
5045                        }
5046
5047                        if (lineType == TacticalLines.LC || tg.get_Client().equalsIgnoreCase("ge")) {
5048                            direction = lineutility.reverseDirection(direction);
5049                        }
5050
5051                        if ((modifier.type == toEnd && x1 < x2) || (modifier.type == aboveEnd && x2 < x1)) {
5052                            justify = ShapeInfo.justify_right;
5053                        } else {
5054                            justify = ShapeInfo.justify_left;
5055                        }
5056
5057                        //3rd point value is location to start perpendicular line from
5058                        pt3 = lineutility.ExtendDirectedLine(pt1, pt0, pt0, direction, lineFactor * stringHeight);
5059                        //pt3 is the end point of the perpendicularline
5060
5061                        glyphPosition = new Point((int) pt3.x, (int) pt3.y);
5062                        modifierPosition = new Point2D.Double(pt3.x, pt3.y);
5063
5064                        anchor = new Point2D.Double(pt0.x, pt0.y);
5065                        anchorOffset = new Point2D.Double(pt3.x - pt0.x, pt3.y - pt0.y);
5066
5067                        //adjust so it doesn't start right on top of the line.
5068                        if(justify == ShapeInfo.justify_right)
5069                            anchorOffset.setLocation(anchorOffset.getX() - font.getSize()/2f,anchorOffset.getY());
5070                        else if(justify == ShapeInfo.justify_left)
5071                            anchorOffset.setLocation(anchorOffset.getX() + font.getSize()/2f,anchorOffset.getY());
5072
5073                        if(image != null)//images are centered and don't have text justification
5074                            anchorOffset = new Point2D.Double(pt1.x - pt0.x, pt1.y - pt0.y);
5075
5076                        break;
5077                    case aboveStartInside:
5078                        //returns pt3 which is based on the specified distance from pt0 along the line of pt0 to pt1.
5079                        pt3 = lineutility.ExtendAlongLineDouble(pt0, pt1, stringWidth);
5080
5081                        glyphPosition = new Point((int) pt3.x, (int) pt3.y);
5082                        modifierPosition = new Point2D.Double((int) pt3.x, pt3.y);
5083
5084                        anchor = new Point2D.Double(pt0.x, pt0.y);
5085                        anchorOffset = new Point2D.Double(pt3.x - pt0.x, pt3.y - pt0.y);
5086                        break;
5087                    case aboveEndInside:
5088                        //returns pt3 which is based on the specified distance from pt0 along the line of pt1 to pt0.
5089                        pt3 = lineutility.ExtendAlongLineDouble(pt1, pt0, stringWidth);
5090
5091                        glyphPosition = new Point((int) pt3.x, (int) pt3.y);
5092                        modifierPosition = new Point2D.Double((int) pt3.x, pt3.y);
5093
5094                        anchor = new Point2D.Double(pt1.x, pt1.y);
5095                        anchorOffset = new Point2D.Double(pt3.x - pt1.x, pt3.y - pt1.y);
5096                        break;
5097                    case aboveMiddle:
5098                    case aboveMiddlePerpendicular:
5099                        pt2 = midPt;
5100                        anchor = new Point2D.Double(midPt.x,midPt.y);
5101
5102                        if (tg.get_Client().equals("2D")) {
5103                            lineFactor += 0.5;
5104                        }
5105
5106                        if (lineFactor >= 0) {
5107                            pt3 = lineutility.ExtendDirectedLine(pt0, pt2, pt2, 3, Math.abs((lineFactor) * stringHeight));
5108                            midPt = lineutility.ExtendDirectedLine(pt0, midPt, midPt, 3, Math.abs((lineFactor) * stringHeight));
5109                        } else {
5110                            pt3 = lineutility.ExtendDirectedLine(pt0, pt2, pt2, 2, Math.abs((lineFactor) * stringHeight));
5111                            midPt = lineutility.ExtendDirectedLine(pt0, midPt, midPt, 2, Math.abs((lineFactor) * stringHeight));
5112                        }
5113                        //pt3=lineutility.ExtendDirectedLine(pt0, pt2, pt2, 2, lineFactor*stringHeight);
5114                        if (x1 == x2 && y1 > y2) {
5115                            pt3 = lineutility.ExtendDirectedLine(pt0, pt2, pt2, 1, Math.abs((lineFactor) * stringHeight));
5116                            midPt = lineutility.ExtendDirectedLine(pt0, midPt, midPt, 1, Math.abs((lineFactor) * stringHeight));
5117                        }
5118                        if (x1 == x2 && y1 < y2) {
5119                            pt3 = lineutility.ExtendDirectedLine(pt0, pt2, pt2, 0, Math.abs((lineFactor) * stringHeight));
5120                            midPt = lineutility.ExtendDirectedLine(pt0, midPt, midPt, 0, Math.abs((lineFactor) * stringHeight));
5121                        }
5122
5123                        glyphPosition = new Point((int) pt3.x, (int) pt3.y);
5124                        justify = ShapeInfo.justify_center;
5125                        modifierPosition = new Point2D.Double(midPt.x, midPt.y);
5126
5127                        //anchor = new Point2D.Double(midPt.x, midPt.y);
5128                        anchorOffset = new Point2D.Double(midPt.x - anchor.getX(), midPt.y - anchor.getY());
5129
5130                        if(modifier.type == aboveMiddlePerpendicular) {
5131                            // Need to negate the original rotation
5132                            if (x1 > x2) {
5133                                theta += Math.PI;
5134                            }
5135                            // Adjust the label rotation based on the y values
5136                            if (y1 > y2) {
5137                                theta += Math.PI;
5138                            }
5139                            // Rotate by 90 degrees. This is how we rotate the label perpendicular to the line
5140                            theta -= Math.PI / 2;
5141                        }
5142                        break;
5143                    case area:
5144                        theta = 0;
5145
5146                        //y = (int) y1 + (int) (stringHeight / 2) + (int) (1.25 * lineFactor * stringHeight);
5147                        y = (int) y1 + (int) (stringHeight / 2) + (int) (lineFactor * stringHeight);
5148                        x = image != null ? (int) (x1 - stringWidth / 3) : (int) x1;
5149
5150                        glyphPosition = new Point(x, y);
5151                        justify = ShapeInfo.justify_center;
5152                        modifierPosition = new Point2D.Double(x, y);
5153
5154                        anchor = new Point2D.Double(x1, y1);
5155                        anchorOffset = new Point2D.Double(x - x1, y - y1);
5156                        break;
5157                    case areaImage:
5158                        glyphPosition = new Point((int)x1, (int)y1);
5159                        justify = ShapeInfo.justify_center;
5160                        modifierPosition = new Point2D.Double((int)x1, (int)y1);
5161
5162                        anchor = new Point2D.Double(x1, y1);
5163                        anchorOffset = new Point2D.Double(0, 0);
5164                        break;
5165                    case screen:    //for SCREEN, GUARD, COVER, not currently used
5166                        if (tg.Pixels.size() >= 14) {
5167                            pt1 = tg.Pixels.get(3);
5168                            pt2 = tg.Pixels.get(10);
5169                            quadrant = lineutility.GetQuadrantDouble(pt1, pt2);
5170                            theta = Math.atan2(pt2.y - pt1.y, pt2.x - pt1.x);
5171                            if (Math.abs(theta) < Math.PI / 8) {
5172                                if (theta < 0) {
5173                                    theta -= Math.PI / 2;
5174                                } else {
5175                                    theta += Math.PI / 2;
5176                                }
5177                            }
5178                            switch (quadrant) {
5179                                case 1:
5180                                    theta += Math.PI / 2;
5181                                    break;
5182                                case 2:
5183                                    theta -= Math.PI / 2;
5184                                    break;
5185                                case 3:
5186                                    theta -= Math.PI / 2;
5187                                    break;
5188                                case 4:
5189                                    theta += Math.PI / 2;
5190                                    break;
5191                                default:
5192                                    break;
5193                            }
5194
5195                            x = (int) x1 - (int) stringWidth / 2;
5196                            y = (int) y1 - (int) stringHeight / 2 + (int) (lineFactor * stringHeight);
5197                            y = (int) y1 + (int) (stringHeight / 2) + (int) (lineFactor * stringHeight);
5198                            anchor = new Point2D.Double(x1, y1);
5199                        } else {
5200                            theta = 0;
5201                            x = (int) tg.Pixels.get(0).x;
5202                            y = (int) tg.Pixels.get(0).y;
5203                            anchor = new Point2D.Double(x, y);
5204                            x = (int) x - (int) stringWidth / 2;
5205                            y = (int) y - (int) stringHeight / 2 + (int) (lineFactor * stringHeight);
5206                            y = (int) y + (int) (stringHeight / 2) + (int) (lineFactor * stringHeight);
5207                        }
5208
5209                        glyphPosition = new Point(x, y);
5210                        //glyphPosition=new Point2D.Double(x,y);
5211                        //anchor = new Point2D.Double(x1, y1);
5212                        anchorOffset = new Point2D.Double(x - anchor.getX(), y - anchor.getY());
5213                        break;
5214                    default:
5215                        break;
5216                }   //end switch
5217
5218                shape2 = new Shape2(Shape2.SHAPE_TYPE_MODIFIER_FILL);
5219
5220                shape2.setStroke(new BasicStroke(0, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND, 3));
5221
5222                if (tg.get_TextColor() != null) {
5223                    shape2.setFillColor(tg.get_TextColor());
5224                } else if (tg.get_LineColor() != null) {
5225                    shape2.setFillColor(tg.get_LineColor());
5226                }
5227                if (tg.get_LineColor() != null) {
5228                    shape2.setLineColor(tg.get_LineColor());
5229                }
5230                //only GE uses the converter, generic uses the affine transform and draws at 0,0
5231                if (converter != null) {
5232                    shape2.setGlyphPosition(glyphPosition);
5233                } else {
5234                    shape2.setGlyphPosition(new Point2D.Double(0, 0));
5235                }
5236                //shape2.setGlyphPosition(new Point(0,0));
5237                //added two settings for use by GE
5238                if(s != null && !s.equals("")) {
5239                    shape2.setModifierString(s);
5240                    TextLayout tl = new TextLayout(s, font, g2d.getFontMetrics().getFontRenderContext());
5241                    shape2.setTextLayout(tl);
5242                    shape2.setTextJustify(justify);
5243                } else if (image != null) {
5244                    shape2.setModifierImage(image);
5245                }
5246                //shape2.setModifierStringPosition(glyphPosition);//M. Deutch 7-6-11
5247                shape2.setModifierAngle(theta * 180 / Math.PI);
5248                shape2.setModifierPosition(modifierPosition);
5249                shape2.setModifierAnchor(anchor);
5250                shape2.setModifierAnchorOffset(anchorOffset);
5251
5252                if (shape2 != null) {
5253                    shapes.add(shape2);
5254                }
5255
5256            }   //end for
5257        } //end try
5258        catch (Exception exc) {
5259            ErrorLogger.LogException(_className, "DisplayModifiers2",
5260                    exc);
5261        }
5262    }//end function
5263
5264    /**
5265     * Builds a shape object to wrap text
5266     *
5267     * @param g2d the Graphic object for drawing
5268     * @param str text to wrap
5269     * @param font the draw font
5270     * @param tx the drawing transform, text rotation and translation
5271     * @return
5272     */
5273    public static Shape getTextShape(Graphics2D g2d,
5274                                     String str,
5275                                     Font font,
5276                                     AffineTransform tx) {
5277        TextLayout tl = null;
5278        FontRenderContext frc = null;
5279        try {
5280            frc = g2d.getFontRenderContext();
5281            tl = new TextLayout(str, font, frc);
5282        } catch (Exception exc) {
5283            ErrorLogger.LogException(_className, "getTextShape",
5284                    new RendererException("Failed inside getTextShape", exc));
5285        }
5286        return tl.getOutline(tx);
5287    }
5288
5289    /**
5290     * Creates text outline as a shape
5291     *
5292     * @param originalText the original text
5293     * @return text shape
5294     */
5295    public static Shape2 createTextOutline(Shape2 originalText) {
5296        Shape2 siOutline = null;
5297        try {
5298            Shape outline = originalText.getShape();
5299
5300            siOutline = new Shape2(Shape2.SHAPE_TYPE_MODIFIER_FILL);
5301            siOutline.setShape(outline);
5302
5303            if (originalText.getFillColor().getRed() == 255
5304                    && originalText.getFillColor().getGreen() == 255
5305                    && originalText.getFillColor().getBlue() == 255) {
5306                siOutline.setLineColor(Color.BLACK);
5307            } else {
5308                siOutline.setLineColor(Color.WHITE);
5309            }
5310
5311            int width = RendererSettings.getInstance().getTextOutlineWidth();
5312
5313            siOutline.setStroke(new BasicStroke(width, BasicStroke.CAP_ROUND,
5314                    BasicStroke.JOIN_ROUND, 3));
5315
5316        } catch (Exception exc) {
5317            ErrorLogger.LogException(_className, "createTextOutline",
5318                    new RendererException("Failed inside createTextOutline", exc));
5319        }
5320        return siOutline;
5321    }
5322
5323    /**
5324     * Channels don't return points in tg.Pixels. For Channels modifiers we only
5325     * need to collect the points, don't need internal arrays, and can calculate
5326     * on which segments the modifiers lie.
5327     *
5328     * @param shape
5329     * @return
5330     */
5331    private static ArrayList<POINT2> getShapePoints(Shape shape) {
5332        try {
5333            ArrayList<Point2D> ptsPoly = new ArrayList();
5334            Point2D ptPoly = null;
5335            double[] coords = new double[6];
5336            int zeros = 0;
5337            for (PathIterator i = shape.getPathIterator(null); !i.isDone(); i.next()) {
5338                int type = i.currentSegment(coords);
5339                if (type == 0 && zeros == 2) {
5340                    break;
5341                }
5342                switch (type) {
5343                    case PathIterator.SEG_MOVETO:
5344                        ptPoly = new Point2D.Double(coords[0], coords[1]);
5345                        ptsPoly.add(ptPoly);
5346                        zeros++;
5347                        break;
5348                    case PathIterator.SEG_LINETO:
5349                        ptPoly = new Point2D.Double(coords[0], coords[1]);
5350                        ptsPoly.add(ptPoly);
5351                        break;
5352                    case PathIterator.SEG_QUADTO: //quadTo was never used
5353                        break;
5354                    case PathIterator.SEG_CUBICTO:  //curveTo was used for some METOC's
5355                        break;
5356                    case PathIterator.SEG_CLOSE:    //closePath was never used
5357                        break;
5358                }
5359            }
5360            if (ptsPoly.size() > 0) {
5361                ArrayList<POINT2> pts = null;
5362                pts = new ArrayList();
5363                for (int j = 0; j < ptsPoly.size(); j++) {
5364                    Point2D pt2d = ptsPoly.get(j);
5365                    POINT2 pt = new POINT2(pt2d.getX(), pt2d.getY());
5366                    pts.add(pt);
5367                }
5368                return pts;
5369            }
5370        } catch (Exception exc) {
5371            ErrorLogger.LogException(_className, "getshapePoints",
5372                    new RendererException("Failed inside getShapePoints", exc));
5373        }
5374        return null;
5375    }
5376
5377    private static Bitmap getImageModifier(TGLight tg) {
5378        String symbolID = tg.get_SymbolId();
5379        ImageInfo symbol = null;
5380        Map<String,String> mods = new HashMap<>();
5381        Map<String,String> sa = new HashMap<>();
5382        sa.put(MilStdAttributes.PixelSize, String.valueOf(tg.get_IconSize()));
5383        int contaminationCode = EntityCode.getSymbolForContaminationArea(SymbolID.getEntityCode(symbolID));
5384        int modifier1Code = SymbolID.getModifier1(symbolID);
5385        int lineType = GetLinetypeFromString(symbolID);
5386        if (contaminationCode > 0) {
5387            sa.put(MilStdAttributes.OutlineSymbol, "true");
5388            sa.put(MilStdAttributes.FillColor, RendererUtilities.colorToHexString(tg.get_FillColor(), true));
5389            sa.put(MilStdAttributes.LineColor, RendererUtilities.colorToHexString(tg.get_LineColor(), true));
5390            String contaminationSP = SymbolID.setEntityCode(symbolID, contaminationCode);
5391            contaminationSP = SymbolID.setHQTFD(contaminationSP, 0); // Remove dummy modifier if necessary
5392            symbol = SinglePointRenderer.getInstance().RenderSP(contaminationSP, mods, sa);
5393        } else if (lineType == TacticalLines.DEPICT || lineType == TacticalLines.MINED || lineType == TacticalLines.FENCED || lineType == TacticalLines.MINE_LINE) {
5394            if (modifier1Code < 13 || modifier1Code > 50) {
5395                // Invalid mine type
5396                modifier1Code = 13;//unspecified mine (default value if not specified as per MilStd 2525)
5397                symbolID = SymbolID.setModifier1(symbolID, modifier1Code);
5398            }
5399            if (tg.get_KeepUnitRation()) {
5400                sa.put(MilStdAttributes.PixelSize, String.valueOf((int) (tg.get_IconSize() * 1.5)));
5401            }
5402            sa.put(MilStdAttributes.OutlineSymbol, "true");
5403            symbol = SinglePointRenderer.getInstance().RenderModifier(symbolID, sa);
5404        } else if (lineType == TacticalLines.LAA && modifier1Code > 0) {
5405            sa.put(MilStdAttributes.OutlineSymbol, "true");
5406            sa.put(MilStdAttributes.FillColor, RendererUtilities.colorToHexString(tg.get_FillColor(), true));
5407            sa.put(MilStdAttributes.LineColor, RendererUtilities.colorToHexString(tg.get_LineColor(), true));
5408            if (tg.get_KeepUnitRation()) {
5409                sa.put(MilStdAttributes.PixelSize, String.valueOf((int) (tg.get_IconSize() * 1.5)));
5410            }
5411            symbol = SinglePointRenderer.getInstance().RenderModifier(symbolID, sa);
5412        }
5413        else if (lineType == TacticalLines.DECISION_LINE) {
5414
5415            sa.put(MilStdAttributes.PixelSize, String.valueOf((int) (tg.get_IconSize() * 1.5)));
5416            sa.put(MilStdAttributes.KeepUnitRatio, String.valueOf((tg.get_KeepUnitRation())));
5417            sa.put(MilStdAttributes.FillColor, RendererUtilities.colorToHexString(tg.get_FillColor(), true));
5418            sa.put(MilStdAttributes.LineColor, RendererUtilities.colorToHexString(tg.get_LineColor(), true));
5419            sa.put(MilStdAttributes.OutlineSymbol, "false");
5420            mods.put(Modifiers.T_UNIQUE_DESIGNATION_1, (tg.get_Name()));
5421
5422            String decisionPoint = SymbolID.setEntityCode(symbolID, EntityCode.EntityCode_Decision_Point);
5423            symbol = SinglePointRenderer.getInstance().RenderSP(decisionPoint, mods, sa);
5424        }
5425        else if (lineType == TacticalLines.ANCHORAGE_LINE || lineType == TacticalLines.ANCHORAGE_AREA) {
5426            sa.put(MilStdAttributes.OutlineSymbol, "false");
5427            String anchorPoint = SymbolID.setEntityCode(symbolID, EntityCode.EntityCode_AnchoragePoint);
5428            symbol = SinglePointRenderer.getInstance().RenderSP(anchorPoint, mods, sa);
5429        }
5430
5431        if (symbol != null)
5432            return symbol.getImage();
5433        else
5434            return null;
5435    }
5436
5437    private static String removeDecimal(double doubleVal) {
5438        return String.valueOf(Math.round(doubleVal));
5439    }
5440
5441    private static String removeDecimal(String strDoubleVal) {
5442        if (strDoubleVal.indexOf(" ") > 0) // String contains unit
5443            return removeDecimal(Double.parseDouble(strDoubleVal.substring(0, strDoubleVal.indexOf(" ")))) + strDoubleVal.substring(strDoubleVal.indexOf(" "));
5444        else
5445            return removeDecimal(Double.parseDouble(strDoubleVal));
5446    }
5447}