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}